Python, Sqlite3 - Jak przekonwertować listę na komórkę BLOB

Question

Jaka jest najbardziej elegancka metoda zrzucania listy w pythonie do DB sqlite3 jako danych binarnych (to znaczy komórki BLOB)?

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

Answer 1

Zakładając chcesz to traktować jako ciąg 8-bitowych wartości bez znaku, użyć modułu array.

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

Używaj różnych typecodes niż 'B' jeśli chcesz traktować te dane jako różnych typów. na przykład. "b" dla sekwencji podpisanych bajtów lub 'i' dla liczby całkowitej ze znakiem.

Answer 2

Wygląda na to, że rozwiązanie Briana pasuje do Twoich potrzeb, ale pamiętaj, że dzięki tej metodzie twoje dane są przechowywane jako ciąg.

Jeśli chcesz zapisać surowe dane binarne w bazie danych (aby nie zajmował tak dużo miejsca), skonwertuj dane do obiektu sqlite Binarnego, a następnie dodaj je do swojej bazy danych.

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

(Z jakiegoś powodu to nie wydaje się być udokumentowane w dokumentacji Pythona)

Oto kilka uwag na temat ograniczeń danych SQLite BLOB:

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

Answer 3

zobaczyć ten ogólny rozwiązanie na SourceForge, które obejmuje dowolny dowolny obiekt Pythona (w tym listę, krotkę, słownik itp.):

y_serial.py mo dule :: warehouse Obiekty w języku Python z SQLite

"Serializacja + persistance :: w kilku liniach kodu, kompresuj i dodawaj adnotacje do obiektów SQLite w Pythonie; następnie odzyskać je chronologicznie według słów kluczowych bez żadnego SQL. Najbardziej użyteczne „standard” moduł do bazy danych do przechowywania danych schematu mniej.”

http://yserial.sourceforge.net

Answer 4

Mam ten sam problem, i myślę o rozwiązywaniu tego w inny sposób.

myślę moduł pickle odbywa się dokładnie na coś takiego (na serializacji obiektów Pythona)

przykład (ten jest dla dumping złożyć ... ale myślę, że to łatwo changeble do przechowywania db)

Zapisywanie:

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

Załadunek:

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

IMHO myślę, że ten sposób jest bardziej elegancki i bezpieczniejsze (działa dla dowolnego obiektu Pythona).

To moje 2 centy

UPDATE: After doing a bit of search on my idea, pokazują one pewne gotchas na moim Solution (nie mogę zrobić sql wyszukiwania w tej dziedzinie). Ale nadal uważam, że to przyzwoite rozwiązanie (jeśli nie musisz szukać tego pola.

Answer 5

Możliwe jest przechowywanie danych obiektu jako zrzutu, jason itp., Ale możliwe jest również ich indeksowanie, ograniczanie i uruchamianie wybranych zapytań, które używają tych indeksów. Oto przykład z krotkami, które można łatwo zastosować dla każdej innej klasy Pythona. Wszystko, co potrzebne jest wyjaśnione w dokumentacji python sqlite3 (ktoś już opublikował link). W każdym razie tutaj wszystko jest zestawione w następującym przykładzie:

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