sqlalchemy une cartographie dynamique

J'ai le problème suivant:

J'ai la classe:


class Word(object):

    def __init__(self):
        self.id = None
        self.columns = {}

    def __str__(self):
        return "(%s, %s)" % (str(self.id), str(self.columns))

auto.colonnes est une dict qui tiendra (columnName:columnValue) les valeurs. Le nom des colonnes sont connus au moment de l'exécution et qu'ils sont chargés dans un wordColumns liste, par exemple


wordColumns = ['english', 'korean', 'romanian']


wordTable = Table('word', metadata,
                  Column('id', Integer, primary_key = True)
                  )
for columnName in wordColumns:
    wordTable.append_column(Column(columnName, String(255), nullable = False))

J'ai même créé un explicite de mapper des propriétés de "forcer" les colonnes de la table pour être mappé sur parole.les colonnes[nomrubrique], au lieu de la parole.columnName, je n'obtiens aucune erreur sur la cartographie, mais il semble que cela ne fonctionne pas.


mapperProperties = {}
for column in wordColumns:
    mapperProperties['columns[\'%']' % column] = wordTable.columns[column]

mapper(Word, wordTable, mapperProperties)

Lorsque je charge un objet word, SQLAlchemy crée un objet qui a la parole.les colonnes de['anglais'], word.les colonnes ["coréen"] etc. propriétés au lieu de les charger dans word.les colonnes dict. Donc, pour chaque colonne, il crée une nouvelle propriété. En outre parole.les colonnes du dictionnaire n'a même pas existe.

De la même façon, lorsque j'essaie de conserver un mot, SQLAlchemy s'attend à trouver les valeurs de la colonne
dans les propriétés nommé comme word.les colonnes de['anglais'] (string type) au lieu du mot du dictionnaire.les colonnes.

Je dois dire que mon expérience avec Python et SQLAlchemy est assez limité, peut-être qu'il n'est pas possible de faire ce que je suis en train de faire.

Toute aide appréciée,

Merci à l'avance.

InformationsquelleAutor Alex D | 2010-04-04

python sqlalchemy

32

Il semble que vous pouvez simplement utiliser les attributs directement au lieu d'utiliser la columns dict.

Considérer la configuration suivante:
```
from sqlalchemy import Table, Column, Integer, Unicode, MetaData, create_engine
from sqlalchemy.orm import mapper, create_session

class Word(object):
    pass

wordColumns = ['english', 'korean', 'romanian']
e = create_engine('sqlite://')
metadata = MetaData(bind=e)

t = Table('words', metadata, Column('id', Integer, primary_key=True),
    *(Column(wordCol, Unicode(255)) for wordCol in wordColumns))
metadata.create_all()
mapper(Word, t)
session = create_session(bind=e, autocommit=False, autoflush=True)
```
Avec cette classe vide que vous pouvez faire:
```
w = Word()
w.english = u'name'
w.korean = u'이름'
w.romanian = u'nume'

session.add(w)
session.commit()
```
Et quand vous voulez accéder aux données:
```
w = session.query(Word).filter_by(english=u'name').one()
print w.romanian
```
C'est le ensemble sqlalchemy's ORM point, au lieu d'utiliser un tuple ou dict pour accéder aux données, vous utilisez attribut comme accès sur votre propre classe.

Alors je me demandais, pour des raisons que vous souhaitez utiliser un dict. C'est peut-être parce que vous avez des chaînes de caractères avec les noms des langues. Eh bien, pour vous permettre de l'utiliser python getattr et setattr au lieu de cela, comme vous le feriez sur n'importe quel objet python:
```
language = 'korean'
print getattr(w, language)
```
Qui devrait résoudre tous vos problèmes.

Cela dit, si vous voulez toujours utiliser dict-comme l'accès aux colonnes, il est également possible. Vous avez juste à le mettre en œuvre un dict-comme l'objet. Je vais maintenant vous fournir le code pour faire cela, même si je pense qu'il est absolument inutiles, puisque l'attribut d'accès est si propre. Si votre problème est déjà résolu en utilisant la méthode ci-dessus, ne pas utiliser le code ci-dessous sur ce point.

Vous pourriez le faire sur le Word classe:
```
class Word(object):
    def __getitem__(self, item): 
        return getattr(self, item)
    def __setitem__(self, item, value):
        return setattr(self, item, value)
```
Le reste de la configuration comme ci-dessus. Ensuite, vous pouvez l'utiliser comme ceci:
```
w = Word()
w['english'] = u'name'
```
Si vous voulez un columns attribut alors vous avez besoin d'un dict-comme
```
class AttributeDict(DictMixin):
    def __init__(self, obj):
        self._obj = obj
    def __getitem__(self, item):
        return getattr(self._obj, item)
    def __setitem__(self, item, value):
        return setattr(self._obj, item, value)

class Word(object):
    def __init__(self):
        self.columns = AttributeDict(self)
```
Alors vous pouvez utiliser comme vous le souhaitez:
```
w = Word()
w.columns['english'] = u'name' 
```
Je pense que vous serez d'accord que tout cela est unnecessarly compliqué avec pas d'avantage supplémentaire.
- Je vous remercie de prendre le temps de rédiger une réponse complète. Je suis d'accord que la première solution est plus propre et plus élégante que la seconde. Je n'ai pas de bonnes raisons pour l'utilisation d'un dict, sauf le fait que c'était la "normale", chose qui est venu dans mon esprit. Comme je l'ai dit avant, je suis un peu nouveau en Python et je n'ai pas encore appris à tirer parti des avantages de la dynamique des langues. Je vais utiliser votre première solution. Merci encore 🙂
- Je ne peux pas obtenir sur la façon dont beaucoup de messages comme celui-ci existent pas ici, mais je suis toujours impressionné quand j'en vois un. Merci de mettre beaucoup de pensée dans ce. Toujours utile, à de nouvelles personnes, plus d'un an plus tard. Bravo à vous
- Maintenant, si je voulais utiliser kwargs pour lancer Word, comme w = Mot(anglais = 'nom', coréen = 'Phoo', roumain = 'nume'), comment cela fonctionnerait-il? Dans mon cas, il va continuer à jeter un init d'erreur. Merci!
InformationsquelleAutor nosklo
3

J'ai utilisé nosklo de la solution (merci!) mais j'ai déjà eu une clé primaire (transmis en tant que pk_col) à l'intérieur de la colonne de la ligne (première ligne du csv). J'ai donc pensé que je devais partager ma modification. J'ai utilisé un ternaire.
```
table = Table(tablename, metadata,
    *((Column(pk_col, Integer, primary_key=True)) if rowname == pk_col else (Column(rowname, String())) for rowname in row.keys()))
table.create()
```
InformationsquelleAutor trash80

Vous devez vous connecter pour publier un commentaire.