Python, Sqlite3 - Cómo convertir una lista en una celda BLOB

Question

¿Cuál es el método más elegante para volcar una lista en python en una base de datos sqlite3 como datos binarios (es decir, una celda BLOB)?

data = [ 0, 1, 2, 3, 4, 5 ] 
# now write this to db as binary data 
# 0000 0000 
# 0000 0001 
# ... 
# 0000 0101 

Answer 1

Suponiendo que desea que trata como una secuencia de valores sin signo de 8 bits, utilice el módulo array.

a = array.array('B', data) 
>>> a.tostring() 
'\x00\x01\x02\x03\x04\x05' 

Use typecodes diferentes que 'B' si quieren tratar los datos como diferentes tipos. p.ej. 'b' para una secuencia de bytes con signo, o 'i' para un entero con signo.

Answer 2

Parece que la solución de Brian se ajusta a sus necesidades, pero tenga en cuenta que con ese método su solo almacenamiento de los datos como una cadena.

Si desea almacenar los datos binarios en bruto en la base de datos (para que no ocupe tanto espacio), convierta sus datos en un objeto Binary sqlite y luego agréguelo a su base de datos.

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

(Por alguna razón esto no parece ser documentado en la documentación de Python)

Aquí están algunas notas sobre las restricciones de datos BLOB sqlite:

http://effbot.org/zone/sqlite-blob.htm

Answer 3

ver este general, solución en SourceForge que cubre cualquier objeto arbitrario de Python (incluyendo lista, tupla, diccionario, etc.):

y_serial.py mo dule :: almacén de objetos Python con SQLite

"Serialización + persistencia :: en unas pocas líneas de código, comprima y anote objetos de Python en SQLite; luego, los recupera cronológicamente por palabras clave sin ningún SQL. Más útil módulo "estándar" para una base de datos a los datos sin esquema de la tienda."

http://yserial.sourceforge.net

Answer 4

que tienen el mismo problema, y ​​estoy pensando en resolver esto de otra manera.

pienso el módulo pickle se hace exactamente para algo como esto (la serialización de objetos de python)

Ejemplo (esto es para vertido a presentar ... pero creo que es fácil para el almacenamiento changeble db)

Ahorro:

# Save a dictionary into a pickle file. 
import pickle 
favorite_color = { "lion": "yellow", "kitty": "red" } 
pickle.dump(favorite_color, open("save.p", "w")) 

Carga:

# Load the dictionary back from the pickle file. 
import pickle 
favorite_color = pickle.load(open("save.p")) 

mi humilde opinión creo que de esta manera es más elegante y más seguro (que funciona para cualquier objeto de Python).

de que es mi 2 centavos

ACTUALIZACIÓN: After doing a bit of search on my idea, muestran algunos aspectos críticos sobre mi solución (no puedo realizar búsquedas SQL en ese campo). Pero todavía creo que es una solución decente (si no necesita buscar ese campo).

Answer 5

Es posible almacenar datos de objeto como pickle dump, jason, etc. pero también es posible indexarlos, restringirlos y ejecutar consultas selectas que usan esos índices. Aquí hay un ejemplo con tuplas, que se puede aplicar fácilmente para cualquier otra clase de python. Todo lo que se necesita se explica en la documentación de python sqlite3 (alguien ya publicó el enlace). De todos modos aquí está todo junto 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("select p from test where pycmp(p,?) >= 0", ((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()