स्क्लेक्लेमी

Question

में डायनामिक टेबल क्रिएशन और ओआरएम मैपिंग मैं रिलेशनल डेटाबेस का उपयोग करने के लिए बिल्कुल नया हूं, इसलिए मैं चीजों को सरल बनाने के लिए एक अच्छा ओआरएम का उपयोग करना पसंद करता हूं। मैंने अलग-अलग पायथन ओआरएम का मूल्यांकन करने में समय बिताया और मुझे लगता है कि मुझे स्क्लेक्लेमी की ज़रूरत है। हालांकि, मैं एक मानसिक मृत अंत में आया हूँ।

मुझे अपने ऐप की प्लेयर तालिका में बनाए गए प्लेयर के प्रत्येक उदाहरण के साथ जाने के लिए एक नई टेबल बनाने की आवश्यकता है। मुझे लगता है कि मुझे मेटाडेटा के माध्यम से तालिका का नाम बदलकर तालिका बनाने का तरीका पता है, फिर निर्माण फ़ंक्शन को कॉल करना, लेकिन मुझे कोई नई गतिशील कक्षा में मैप करने के तरीके पर कोई संकेत नहीं है।

क्या कोई मुझे मेरे दिमाग को स्थिर करने में मदद करने के लिए कुछ सुझाव दे सकता है? क्या यह भी संभव है?

नोट: मैं अजगर में अन्य ORMs के लिए खुला है कि मैं क्या पूछ रहा हूँ implement.Just करने के लिए आसान है अगर मुझे दिखा कर रहा हूँ कैसे :-)

Answer 1

हम बिल्कुल SQLAlchemy द्वारा खराब कर रहे हैं के लिए किसी भी अड्डों से पारित नहीं है।
नीचे दिए गए नीचे सीधे tutorial,
से लिया गया है और सेटअप करना और काम करना वास्तव में आसान है।

और क्योंकि यह इतनी बार किया जाता है,
माइक बायर इस और भी आसान
all-in-one "declarative" method साथ बना दिया है। अपने वातावरण

सेटअप (मैं परीक्षण करने के लिए DB में स्मृति SQLite उपयोग कर रहा हूँ):

>>> from sqlalchemy import create_engine 
>>> engine = create_engine('sqlite:///:memory:', echo=True) 
>>> from sqlalchemy import Table, Column, Integer, String, MetaData 
>>> metadata = MetaData() 

अपनी मेज निर्धारित करें:

>>> players_table = Table('players', metadata, 
... Column('id', Integer, primary_key=True), 
... Column('name', String), 
... Column('score', Integer) 
...) 
>>> metadata.create_all(engine) # create the table 

आप लॉगिंग चालू है, तो आप करेंगे एसक्यूएल देखें जो एसक्यूएलकेमी आपके लिए बनाता है।

>>> class Player(object): 
...  def __init__(self, name, score): 
...   self.name = name 
...   self.score = score 
... 
...  def __repr__(self): 
...  return "<Player('%s','%s')>" % (self.name, self.score) 

अपनी तालिका में वर्ग मानचित्र:

अपने वर्ग को परिभाषित करें

>>> from sqlalchemy.orm import mapper 
>>> mapper(Player, players_table) 
<Mapper at 0x...; Player> 

एक खिलाड़ी बनाएँ:

>>> a_player = Player('monty', 0) 
>>> a_player.name 
'monty' 
>>> a_player.score 
0 

यह है कि, अब आप एक अपने खिलाड़ी मेज है ।
इसके अलावा, एसक्लक्लेमी googlegroup बहुत अच्छा है।
माइक बेयर सवालों के जवाब देने में बहुत तेज़ है।

Answer 2

हो सकता है एसक्यूएल सूप, जो SQLAlchemy से अधिक परत है पर देखने के http://www.sqlalchemy.org/trac/wiki/SqlSoup

या अमृत (फिर से SQLAlchemy पर एक आवरण) http://elixir.ematia.de/trac/wiki

आप भी सादा एसक्यूएल का उपयोग कर तालिका बना सकते हैं, और अगर वे पहले से ही मेज समारोह बनाने की जरूरत नहीं है गतिशील रूप से इन libs का उपयोग मैप करने के लिए।

या वैकल्पिक रूप से एक गतिशील वर्ग बनाएं और इसे मानचित्र करें उदा। मेरे अपने कोड से झलकी

tableClass = type(str(table.fullname), (BaseTable.BaseTable,), {}) 
mapper(tableClass, table) 

जहां BaseTable किसी भी अजगर वर्ग जो आप अपने सभी तालिका वर्गों से प्राप्त करना चाहते हो सकता है, जैसे कि ऐसी बेस क्लास में कुछ उपयोगिता या सामान्य विधियां हो सकती हैं, उदा। बुनियादी CRUD तरीकों

class BaseTable(object): pass 

अन्यथा आप type(...)

Answer 3

आप डेटाबेस

from sqlalchemy.ext.declarative import declarative_base 
from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey 


Base = declarative_base() 

class Language(Base): 
    __tablename__ = 'languages' 

    id = Column(Integer, primary_key=True) 
    name = Column(String(20)) 
    extension = Column(String(20)) 

    def __init__(self, name, extension): 
     self.name = name 
     self.extension = extension 

Answer 4

में गतिशील बनाने तालिकाओं के लिए घोषणात्मक विधि का उपयोग कर सकते हैं जब मैं SQLAlchemy का उपयोग कर सरल CRUD कार्यों को स्वचालित करने की कोशिश कर रहा था एक ही समस्या का सामना करना पड़ा। यहाँ इसे आसानी से समझा और कुछ कोड है: http://www.devx.com/dbzone/Article/42015

Answer 5

शायद मैं काफी आप क्या चाहते हैं समझ में नहीं आया है, लेकिन यह नुस्खा अलग __tablename__ में समान स्तंभ बनाने

class TBase(object): 
    """Base class is a 'mixin'. 
    Guidelines for declarative mixins is at: 

    http://www.sqlalchemy.org/docs/orm/extensions/declarative.html#mixin-classes 

    """ 
    id = Column(Integer, primary_key=True) 
    data = Column(String(50)) 

    def __repr__(self): 
     return "%s(data=%r)" % (
      self.__class__.__name__, self.data 
     ) 

class T1Foo(TBase, Base): 
    __tablename__ = 't1' 

class T2Foo(TBase, Base): 
    __tablename__ = 't2' 

engine = create_engine('sqlite:///foo.db', echo=True) 

Base.metadata.create_all(engine) 

sess = sessionmaker(engine)() 

sess.add_all([T1Foo(data='t1'), T1Foo(data='t2'), T2Foo(data='t3'), 
     T1Foo(data='t4')]) 

print sess.query(T1Foo).all() 
print sess.query(T2Foo).all() 
sess.commit() 

info in example sqlalchemy