Python, Sqlite3 - Comment convertir une liste en une cellule BLOB

Question

Quelle est la méthode la plus élégante pour faire passer une liste en python dans une base de données sqlite3 en tant que donnée binaire (c'est-à-dire une cellule BLOB)?

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

Answer 1

En supposant que vous voulez traité comme une séquence de valeurs non signés 8 bits, utilisez le module array.

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

Utilisez différentes typecodes que 'B' si vous voulez traiter les données avec différents types. par exemple. 'b' pour une séquence d'octets signés, ou 'i' pour un entier signé.

Answer 2

Il semble que la solution de Brian corresponde à vos besoins, mais gardez à l'esprit qu'avec cette méthode, il vous suffit de stocker les données sous forme de chaîne.

Si vous souhaitez stocker les données binaires brutes dans la base de données (il ne prend pas autant d'espace), convertir vos données à un binaire objet sqlite et ajoutez-le à votre base de données.

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

(Pour une raison quelconque, cela ne semble pas être documenté dans la documentation python)

Voici quelques notes sur les restrictions de données blob sqlite:

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

Answer 3

voir cette général solution à SourceForge qui couvre tout objet Python arbitraire (y compris liste, tuple, dictionnaire, etc):

y_serial.py mo dule :: warehouse Objets Python avec SQLite

"Sérialisation + persistance :: dans quelques lignes de code, compresser et annoter des objets Python dans SQLite; puis plus tard les récupérer chronologiquement par mots-clés sans aucun SQL. Plus utile module « standard » pour une base de données pour stocker un schéma-moins de données. »

http://yserial.sourceforge.net

Answer 4

J'ai le même problème, et je pense à la résolution de cette autre manière.

Je pense le module pickle est fait exactement pour quelque chose comme ça (sérialisation sur les objets python)

Exemple (celui-ci est pour le dumping fichier ... mais je pense qu'il est facilement changeble pour le stockage db)

Enregistrement:

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

Chargement:

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

à mon humble avis, je pense que cette façon est plus élégante et plus sûr (cela fonctionne pour tout objet python).

Ce sont mes 2 cents

MISE À JOUR: After doing a bit of search on my idea, ils montrent quelques trucs sur ma solution (je ne peux pas faire des recherches sur ce domaine sql). Mais je pense toujours que c'est une solution décente (si vous n'avez pas besoin de chercher ce champ.

Answer 5

Il est possible de stocker des données d'objet en tant que vidage pickle, jason etc. mais il est également possible de les indexer, de les restreindre et d'exécuter des requêtes select qui utilisent ces index. Voici un exemple avec des tuples, qui peuvent être facilement appliqués pour n'importe quelle autre classe python. Tout ce qui est nécessaire est expliqué dans la documentation de python sqlite3 (quelqu'un a déjà posté le lien). Quoi qu'il en soit, ici, tout est mis ensemble dans l'exemple suivant:

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