Est-il possible de stocker Python les objets de la classe dans SQLite?

Je voudrais stocker des objets Python dans un SQLite base de données. Est-ce possible?

Si oui, quels seraient certains des liens /des exemples pour elle?

InformationsquelleAutor webminal.org | 2010-01-12

55

Vous ne pouvez pas stocker l'objet lui-même dans la DB. Ce que vous faites est de stocker les données de l'objet et de le reconstruire plus tard.

Une bonne façon est d'utiliser l'excellent SQLAlchemy de la bibliothèque. Il vous permet de mapper votre classe définie à une table dans la base de données. Chaque mappé attribut seront stockées et peuvent être utilisées pour reconstruire l'objet. L'interrogation de la base de données renvoie les instances de votre classe.

Avec elle, vous pouvez utiliser non seulement sqlite, mais la plupart des bases de données - actuellement, Il prend également en charge Postgres, MySQL, Oracle, MS-SQL, Firebird, MaxDB, MS Access, Sybase, Informix et DB2 d'IBM. Et vous pouvez avoir votre utilisateur de choisir qui elle veut l'utiliser, parce que vous pouvez basculer entre ces bases de données sans modifier le code.

Il y a aussi un grand nombre de fonctionnalités intéressantes comme automatique JOINs, polymorphing...

Un moyen rapide, simple exemple, vous pouvez exécuter:
```
from sqlalchemy import Column, Integer, Unicode, UnicodeText, String
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

from random import choice
from string import letters

engine = create_engine('sqlite:////tmp/teste.db', echo=True)
Base = declarative_base(bind=engine)

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(Unicode(40))
    address = Column(UnicodeText, nullable=True)
    password = Column(String(20))

    def __init__(self, name, address=None, password=None):
        self.name = name
        self.address = address
        if password is None:
            password = ''.join(choice(letters) for n in xrange(10))
        self.password = password

Base.metadata.create_all()

Session = sessionmaker(bind=engine)
s = Session()
```
Alors je peux l'utiliser comme ceci:
```
# create instances of my user object
u = User('nosklo')
u.address = '66 Some Street #500'

u2 = User('lakshmipathi')
u2.password = 'ihtapimhskal'

# testing
s.add_all([u, u2])
s.commit()
```
Qui irait à l' INSERT déclarations à l'encontre de la base de données.
```
# When you query the data back it returns instances of your class:

for user in s.query(User):
    print type(user), user.name, user.password
```
Que la requête souhaitez exécuter SELECT users.id AS users_id, users.name AS users_name, users.address AS users_address, users.password AS users_password.

Le résultat imprimé serait:
```
<class '__main__.User'> nosklo aBPDXlTPJs
<class '__main__.User'> lakshmipathi ihtapimhskal
```
De sorte que vous êtes effectivement le stockage de votre objet dans la base de données, la meilleure façon.
- Tout d'abord,merci à vous tous pour vos réponses/guide/conseils!!! et @ nosklo ,grâce à vous un exemple de code a fonctionné comme un charme 🙂 Merci beaucoup. Je vais explorer plus à propos de sqlalchemy avec votre exemple - Semble qui permettra de répondre à ma demande..merci à vous tous encore une fois.
- Tout d'abord,merci à vous tous pour vos réponses/guide/conseils!!! et @ nosklo ,grâce à vous un exemple de code a fonctionné comme un charme 🙂 Merci beaucoup. Je vais explorer plus à propos de sqlalchemy avec votre exemple - Semble qui permettra de répondre à mon exigence de plus de cornichon..merci à vous tous encore une fois.
- Ouais, à mon humble avis pickle est pas en vaut la peine. Il semble cool et tout, mais vous vous ne pouvez pas filtre/participer/agreggate de données, puisque l'objet est stocké comme un goutte, défaisant le but de l'utilisation d'une base de données en premier lieu.
- +1 Grande réponse. Je pense que choisir fonctionne uniquement pour les objets qui n'ont pas besoin de la recherche.
- oui,j'ai besoin d'effectuer de la recherche sur les données ..donc pickle ne vais pas m'aider...mais sqlalchemy semble être le candidat idéal.
- Puis-je utiliser cette technique pour stocker dictionnaire (plus précisément une conséquence de la population locale() ) dans une base de données?
InformationsquelleAutor nosklo
14

Oui c'est possible, mais il existe des approches différentes et dont l'un est le convient, tout dépendra de vos besoins.
- Décapage
  
  Vous pouvez utiliser le cornichon module de sérialiser des objets, ensuite stocker ces objets dans un blob dans sqlite3 (ou un champ de texte, si l'image est par exemple codé en base64). Être conscient de certains problèmes possibles: questions/198692/can-i-cornichon-un-python-dictionnaire-dans-un-sqlite3-le champ texte
- Object-Relational Mapping
  
  Vous pouvez utiliser le mapping objet-relationnel. Cela crée, en effet, un "objet virtuel" base de données qui peut être utilisé dans le langage de programmation (Wikipédia). Pour python, il y a une belle trousse à outils pour cela: sqlalchemy.
InformationsquelleAutor miku
7

Vous pouvez utiliser cornichon.dumps, son retour cliquable objets comme des chaînes de caractères, vous n'auriez pas besoin de l'écrire dans les fichiers temporaires.

Retour de la marinés représentation de
l'objet comme un chaîne, au lieu de
écrire dans un fichier.
```
import pickle

class Foo:
    attr = 'a class attr'

picklestring = pickle.dumps(Foo)
```
InformationsquelleAutor YOU
1

Vous d'autres choix au lieu de décapage consiste à utiliser un ORM. Cela vous permet de mapper des lignes dans une base de données d'un objet. Voir http://wiki.python.org/moin/HigherLevelDatabaseProgramming pour un point de départ. Je le recommande SQLAlchemy ou SQLObject.

InformationsquelleAutor Sam Doshi
1

Vous pouvez utiliser cornichon pour sérialiser l'objet. L'objet sérialisé peut être inséré à la DB sqlite comme un objet bytearray champ.
```
f=open('object.dump', 'rw')
pickle.dump(obj, f)
```
Maintenant lire object.dump à partir du fichier, et de l'écrire à la DB sqlite. Vous pourriez écrire comme un type de données binaire; lisez à propos de stocker des données binaires et d'objets blob dans SQLite ici. Note que, selon cette source, SQLite limite la taille de ces datafield à 1 mo.

Je pense que la meilleure option serait la sérialisation de votre objet dans un fichier, et de conserver le fichier nom, pas le contenu, dans la base de données.
- C'est loin d'être une bonne pratique. Le stockage marinés objets blob dans une base de données subvertit le raisonnement pour l'utilisation d'une base de données, la recherche. stocker les noms de fichiers dans la base de données en raison de restriction de taille de fichier ne permet pas de faire ce pas mieux.
InformationsquelleAutor Adam Matan
1

En fonction de vos besoins, il pourrait être intéressant de regarder dans Django (www.djangoproject.com) pour cette tâche. Django est en fait un framework web, mais l'une des tâches qu'il gère est de vous permettre de définir des Modèles comme des objets python (héritant d'une classe de base fournies par le framework). Il va alors créer automatiquement les tables de base de données pour stocker ces objets, et sqlite est parmi les backends supportés. Il fournit également des fonctions pratiques pour interroger la base de données et de retourner un ou plusieurs objets correspondants. Voir, par exemple, la documentation sur les Modèles django:

http://docs.djangoproject.com/en/1.9/topics/db/models/

L'inconvénient est bien sûr que vous devez installer complète framework web, et (comme je me souviens bien), vous ne pouvez stocker des objets dont les attributs sont pris en charge par django. Aussi, il est fait pour stocker de nombreuses instances d'objets prédéfinis, pas pour le stockage d'une instance de chacun des nombreux objets différents. En fonction de vos besoins, cela peut ou peut ne pas être pratique.

InformationsquelleAutor Tor
0

Une option est d'utiliser un O/R mapper comme SQLObject. plus de la plomberie pour conserver l'objet Python à une base de données, et il prend en charge SQLite. Comme mentionné ailleurs, vous pouvez également serialise l'objet à l'aide d'une méthode telle que pickle, qui déverse une représentation de l'objet qu'il est possible de le reconstituer par la lecture et l'analyse.

InformationsquelleAutor ConcernedOfTunbridgeWells

Il est relativement simple de la façon de stocker et de comparer des objets, eaven pour indexer ces objets et à les limiter (avec ubique) les colonnes contenant des objets. Et tout cela sans l'aide de l'ORM moteurs. Objets mât être stocké à l'aide de pickle dump (donc la performance pourrait être un problème) Voici l'exemple pour le stockage de python tuples, l'indexation de la restriction et le comparant. Cette méthode peut être facilement appliquée à tout autre python classe. Tout ce qui est nécessaire est expliqué en python sqlite3 documentation (quelqu'un a déjà posté le lien). De toute façon ici c'est tous 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)")
######################### Test ########################
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()

InformationsquelleAutor pervlad

Vous devez vous connecter pour publier un commentaire.