Cualquier artimañas que debo tener en cuenta? Puedo almacenar en un campo de texto, o tengo que usar un blob?
(Yo no estoy demasiado familiarizado con pepinillos o sqlite, así que quería asegurarme de que estoy ladrando al árbol del lado derecho con algunos de mis diseño de alto nivel de las ideas.)

  • Todo depende de lo que el diccionario contiene. También, suena muy parecido a lo que estás haciendo algo mal. ¿Cuáles son tus razones para utilizar una base de datos? ¿Cuáles son sus razones para la elección de SQLite?
  • La buena noticia es que esta es una pequeña aplicación que se va a utilizar, en la mayoría, alrededor de 5 personas, y sólo necesita guardar algunos datos y escupir. El pepinillo -> sqlite idea surgió después de unos dews montaña, pero tenía curiosidad por ver si era posible.

14 Comentarios

  1. 17

    Si desea almacenar un escabeche objeto, usted necesitará utilizar un blob, ya que es binario de datos. Sin embargo, puede, decir, codificar en base64 el escabeche objeto de obtener una cadena que puede ser almacenado en un campo de texto.

    Por lo general, aunque, haciendo este tipo de cosas es indicativo de un mal diseño, ya que usted está almacenando opaco de datos se pierde la capacidad de usar SQL para hacer cualquier tipo de manipulación en los datos. Aunque sin saber lo que en realidad estamos haciendo, realmente no puedo hacer un llamamiento moral en él.

    • Sí, soy consciente de que esto es un poco dudoso de diseño. Los datos en cuestión nunca tendría que ser seleccionado en contra, sólo necesita ser salvado y luego escupió de vuelta para el usuario del «placer de la visión». (Esto es lo que la especificación escritor nos habla de mí, de todos modos.)
    • Tanto tiempo como usted lo está haciendo con la salvedad de que es rápido y sucio de la solución, en contraposición a pensar que es una muy cuidada y truco, creo que voy a estar bien.
  2. 46

    Necesitaba para lograr la misma cosa.

    Me resulta, no me causó gran dolor de cabeza antes de que finalmente comprendí, gracias a este post, cómo hacerlo funcionar en un formato binario.

    Insertar/actualizar:

    pdata = cPickle.dumps(data, cPickle.HIGHEST_PROTOCOL)
    curr.execute("insert into table (data) values (:data)", sqlite3.Binary(pdata))

    Debe especificar el segundo argumento volcados a la fuerza de un binario de decapado.

    También tenga en cuenta el sqlite3.Binario para que se ajuste en el campo BLOB.

    Para recuperar datos:

    curr.execute("select data from table limit 1")
    for row in curr:
      data = cPickle.loads(str(row['data']))

    Al recuperar un campo BLOB, sqlite3 consigue un ‘buffer’ tipo de python, que necesita ser strinyfied utilizando str antes de ser pasados a las cargas método.

    • Me encanta que el hombre! Se solucionó un problema que estaba teniendo con Redis! Yo no se si se especifica el protocolo y aunque yo no estaba recibiendo ningún unpickling error que yo estaba recibiendo datos incoherentes probablemente debido a algún problema de codificación. ¿Esto algún sentido?
  3. 6

    Escribí un blog sobre esta idea, excepto que en lugar de un apuro, he utilizado json, ya que yo quería ser interoperables con perl y otros programas.

    http://writeonly.wordpress.com/2008/12/05/simple-object-db-using-json-and-python-sqlite/

    Arquitectónicamente, esta es una forma rápida y sucia para conseguir la persistencia, transacciones, y el como arbitrarias de las estructuras de datos. He encontrado esta combinación para ser realmente útil cuando quiero persistencia, y no necesita hacer mucho en la capa de sql con los datos (o es muy complejo para tratarlo en sql, y simple con los generadores).

    El código en sí es bastante simple:

    #  register the "loader" to get the data back out.
    sqlite3.register_converter("pickle", cPickle.loads) 

    Entonces, cuando usted desea volcar en la db,

    p_string = p.dumps( dict(a=1,b=[1,2,3]))  
    conn.execute(''' 
       create table snapshot( 
          id INTEGER PRIMARY KEY AUTOINCREMENT, 
            mydata pickle); 
    ''')  
    
    conn.execute(''' 
        insert into snapshot values 
        (null, ?)''', (p_string,))
    ''')
  4. 3

    Pickle tiene texto y binarios de formatos de salida. Si utiliza el formato de texto que se pueden almacenar en un campo de TEXTO, pero tendrá que ser una nota si utiliza el (más eficiente) a formato binario.

  5. 2

    Desde la Salmuera puede volcar su objeto gráfico en una cadena debería ser posible.

    Tener en cuenta a pesar de que los campos de TEXTO en SQLite utiliza codificación de base de datos, de modo que usted puede ser que necesite para convertir a una simple cadena de caracteres antes de onu-pickle.

  6. 2

    Si de un diccionario se puede vinagre, puede ser almacenada en texto/campo blob así.

    Acaba de ser conscientes de los diccionarios que no puede ser en escabeche (aka que contienen unpickable objetos).

  7. 2

    Sí, puede almacenar un escabeche objeto en un TEXTO o de un campo BLOB en una base de datos SQLite3, como otros lo han explicado.

    Acaba de ser conscientes de que algún objeto no puede ser en escabeche. El construido-en los tipos de contenedor puede (dict, conjunto, lista, tupla, etc.). Pero algunos objetos, tales como identificadores de archivo, consulte el estado que es externo a sus propias estructuras de datos, y otros tipos de extensión tienen problemas similares.

    Desde un diccionario puede contener arbitraria anidada estructuras de datos, no podría ser de encurtidos-poder.

  8. 2

    Tengo que estar de acuerdo con algunos de los comentarios aquí. Tenga cuidado y asegúrese de que usted realmente desea guardar el pepinillo de datos en una db, es probable que exista una mejor manera.

    En cualquier caso he tenido problemas en el pasado tratando de guardar datos binarios en el db sqlite.
    Al parecer, usted tiene que utilizar el sqlite3.Binario() para preparar los datos de sqlite.

    Aquí está el código de ejemplo:

    query = u'''insert into testtable VALUES(?)'''
    b = sqlite3.Binary(binarydata)
    cur.execute(query,(b,))
    con.commit()
  9. 1

    SpoonMeiser es correcta, usted necesita tener una fuerte razón para pepinillo en una base de datos.

    No es difícil escribir objetos de Python que implemente la persistencia con SQLite. A continuación, puede utilizar el SQLite CLI para jugar con los datos. Que en mi experiencia vale la pena el extra de trabajo, ya que muchos de depuración y administración de las funciones se puede simplemente realizar desde la CLI, en lugar de escribir específicos de código de Python.

    En las primeras etapas de un proyecto, hice lo que te proponemos y terminó re-escribir con una clase de Python para cada objeto de negocio (nota: no me diga para cada mesa!!!) De esta manera el cuerpo de la aplicación puede centrarse en «lo que» se necesita hacer más que el «cómo» se hace.

  10. 1

    La otra opción, teniendo en cuenta que su condición es la de guardar un diccionario y luego escupir para el usuario del «placer de la visión», es el uso de la shelve módulo que te permitirá conservar los pickleable datos a un archivo. El python docs son aquí.

  11. 1

    Dependiendo de lo que usted está trabajando, usted puede desear mirar en el empujar módulo. Hace algo similar, donde se auto-tiendas de objetos de Python dentro de una base de datos sqlite (y todo tipo de otras opciones) y pretende ser un diccionario (como el dejar de lado módulo).

  12. 1

    Es posible almacenar datos de objeto, como el pepinillo de volcado, jason, etc, pero también es posible índice, ellos, limitarlos y ejecutar consultas de selección que utilizan los índices. Aquí es un ejemplo con tuplas, que puede aplicarse fácilmente para cualquier otra clase de python. Todo lo que se necesita es explicado en python sqlite3 documentación (alguien que ya está publicado el enlace). De todos modos aquí está, todos juntos en el siguiente ejemplo:

    import sqlite3
    import pickle
    def adapt_tuple(tuple):
    return pickle.dumps(tuple)    
    sqlite3.register_adapter(tuple, adapt_tuple)    #cannot use pickle.dumps directly because of inadequate argument signature 
    sqlite3.register_converter("tuple", pickle.loads)
    def collate_tuple(string1, string2):
    return cmp(pickle.loads(string1), pickle.loads(string2))
    #########################
    # 1) Using declared types
    con = sqlite3.connect(":memory:", detect_types=sqlite3.PARSE_DECLTYPES)
    con.create_collation("cmptuple", collate_tuple)
    cur = con.cursor()
    cur.execute("create table test(p tuple unique collate cmptuple) ")
    cur.execute("create index tuple_collated_index on test(p collate cmptuple)")
    cur.execute("select name, type  from sqlite_master") # where type = 'table'")
    print(cur.fetchall())
    p = (1,2,3)
    p1 = (1,2)
    cur.execute("insert into test(p) values (?)", (p,))
    cur.execute("insert into test(p) values (?)", (p1,))
    cur.execute("insert into test(p) values (?)", ((10, 1),))
    cur.execute("insert into test(p) values (?)", (tuple((9, 33)) ,))
    cur.execute("insert into test(p) values (?)", (((9, 5), 33) ,))
    try:
    cur.execute("insert into test(p) values (?)", (tuple((9, 33)) ,))
    except Exception as e:
    print e
    cur.execute("select p from test order by p")
    print "\nwith declared types and default collate on column:"
    for raw in cur:
    print raw
    cur.execute("select p from test order by p collate cmptuple")
    print "\nwith declared types collate:"
    for raw in cur:
    print raw
    con.create_function('pycmp', 2, cmp)
    print "\nselect grater than using cmp function:"
    cur.execute("select p from test where pycmp(p,?) >= 0", ((10, ),) )
    for raw in cur:
    print raw
    cur.execute("explain query plan select p from test where p > ?", ((3,)))
    for raw in cur:
    print raw 
    print "\nselect grater than using collate:"
    cur.execute("select p from test where p > ?", ((10,),) )
    for raw in cur:
    print raw  
    cur.execute("explain query plan select p from test where p > ?", ((3,)))
    for raw in cur:
    print raw
    cur.close()
    con.close()
  13. 0

    Ver esta solución en SourceForge:

    y_serial.py módulo :: almacén de objetos de Python con SQLite

    «Serialización + persistencia :: en un par de líneas de código, comprimir y anotar los objetos de Python en SQLite; luego recuperar en orden cronológico por palabras clave sin ningún tipo de SQL. Más útil «estándar» módulo para una base de datos para almacenar menos de esquema de datos.»

    http://yserial.sourceforge.net

  14. 0

    Muchas aplicaciones de uso sqlite3 como un backend para SQLAlchemy así que, naturalmente, esta cuestión se puede plantear en el SQLAlchemy marco (que es como me encontré con esta pregunta).

    Para ello, se ha querido definir la columna en la que el pepinillo se desea datos a ser almacenados a la tienda «PickleType de datos». La aplicación es bastante sencilla:

    from sqlalchemy import PickleType, Integer
    from sqlalchemy.orm import sessionmaker
    from sqlalchemy.ext.declarative import declarative_base
    from sqlalchemy import create_engine
    import pickle
    Base= declarative_base()
    class User(Base):
    __tablename__= 'Users'
    id= Column(Integer, primary_key= True)
    user_login_data_array= Column(PickleType)
    login_information= {'User1':{'Times': np.arange(0,20),
    'IP': ['123.901.12.189','123.441.49.391']}}
    engine= create_engine('sqlite:///memory:',echo= False) 
    Base.metadata.create_all(engine)
    Session_maker= sessionmaker(bind=engine)
    Session= Session_maker()
    # The pickling here is very intuitive! Just need to have 
    # defined the column "user_login_data_array" to take pickletype data.
    pickled_login_data_array= pickle.dumps(login_information)
    user_object_to_add= User(user_login_data_array= pickled_login_data_array)
    Session.add(user_object_to_add)
    Session.commit()

    (Que no estoy diciendo que en este ejemplo sería el que mejor se adapte a utilizar la salmuera, como otros han señalado problemas con.)

Dejar respuesta

Please enter your comment!
Please enter your name here