Python, Sqlite3 - Wie man eine Liste in eine BLOB-Zelle konvertiert

Question

Was ist die eleganteste Methode, um eine Liste in Python in eine SQLite3 DB als Binärdaten (d. H. Eine BLOB-Zelle) zu entladen?

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

Answer 1

Vorausgesetzt, dass Sie es als eine Folge von 8-Bit-Werte ohne Vorzeichen behandelt möchten, verwenden Sie das array Modul.

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

Verwenden Sie unterschiedliche Typcodes als 'B' wenn Sie möchten die Daten als verschiedene Arten behandeln. z.B. 'b' für eine Folge von vorzeichenbehafteten Bytes oder 'i' für eine ganze Zahl mit Vorzeichen.

Answer 2

Es scheint, dass Brians Lösung Ihren Bedürfnissen entspricht, aber denken Sie daran, dass Sie mit dieser Methode Ihre Daten nur als String speichern.

Wenn Sie die rohen Binärdaten in der Datenbank speichern möchten (so dass es nicht so viel Platz einnimmt), konvertieren Sie Ihre Daten in ein Binäres sqlite-Objekt und fügen Sie es dann zu Ihrer Datenbank hinzu.

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

(Aus irgendeinem Grund scheint dies nicht in der Python-Dokumentation dokumentiert werden)

Hier sind einige Hinweise auf SQLite-BLOB-Daten Einschränkungen:

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

Answer 3

Sehen Sie diese allgemeine Lösung bei SourceForge, die jedes beliebige Python-Objekt abdeckt (einschließlich Liste, Tupel, Wörterbuch usw.):

y_serial.py mo dule :: warehouse Python-Objekte mit SQLite

"Serialisierung + persistance :: komprimieren und kommentieren Sie in einigen Codezeilen Python-Objekte in SQLite; dann später chronologisch durch Schlüsselwörter ohne SQL abrufen. Am nützlichsten „Standard“ Modul für eine Datenbank zum Speichern von Schema-weniger Daten.“

http://yserial.sourceforge.net

Answer 4

ich das gleiche Problem habe, und ich denke darüber in einer anderen Art und Weise zu lösen.

Ich denke, das pickle Modul ist genau so (Serialisierung auf python-Objekten) für etwas getan

Beispiel (dieser für Dumping Datei ... aber ich denke, es ist leicht changeble für db Lagerung)

Ersparnis:

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

Laden:

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

IMHO ich glaube, diese Art und Weise eleganter und sicherer ist (es funktioniert für jedes Python-Objekt).

Das ist meine 2 Cent

UPDATE ist: After doing a bit of search on my idea, zeigen sie einige gotchas auf meine Lösung (ich kann nicht SQL-Suche auf diesem Gebiet machen). Aber ich denke immer noch, dass es eine anständige Lösung ist (wenn Sie dieses Feld nicht suchen müssen).

Answer 5

Es ist möglich, Objektdaten als Pickle Dump, Jason usw. zu speichern, aber es ist auch möglich, sie zu indizieren, einzuschränken und ausgewählte Abfragen auszuführen, die diese Indizes verwenden. Hier ist ein Beispiel mit Tupeln, die leicht für jede andere Python-Klasse angewendet werden können. Alles, was benötigt wird, ist in der Dokumentation von python sqlite3 erklärt (jemand hat den Link bereits gepostet). Wie auch immer hier ist es alles zusammen in dem folgenden Beispiel:

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()