क्या एसक्यूएलकेमी सत्र में ऑब्जेक्ट जोड़ने में ऑर्डर बचाता है?

Question

क्या यह जोर हमेशा से गुज़रता है या नहीं? दूसरे शब्दों में, सत्र में नई ऑब्जेक्ट्स जोड़ने पर SQLAlchemy ऑर्डर (INSERT क्वेरी जेनरेट करने में) सहेजता है?

from sqlalchemy.ext.declarative import declarative_base 
from sqlalchemy.orm.session import sessionmaker 
from sqlalchemy.engine import create_engine 
from sqlalchemy.types import Integer 
from sqlalchemy.schema import Column 

engine = create_engine('sqlite://') 
Base = declarative_base(engine) 
Session = sessionmaker(bind=engine) 
session = Session() 

class Entity(Base): 
    __tablename__ = 'entity' 
    id = Column(Integer(), primary_key=True) 
Entity.__table__.create(checkfirst=True) 


first = Entity() 
session.add(first) 

second = Entity() 
session.add(second) 

session.commit() 
assert second.id > first.id 
print(first.id, second.id) 

कोई नहीं, उत्पादन में मैं PostgreSQL उपयोग कर रहा हूँ, SQLite के परीक्षण के लिए है।

Answer 1

नहीं, जब आप प्रतिबद्ध करते हैं, तो यह तब होता है जब आप जोड़ते हैं।

Answer 2

SQLAlchemy स्रोत पर एक सा देखने के बाद, यह add() रिकॉर्ड की तरह लग रहा है जब यह डाला गया था: https://github.com/zzzeek/sqlalchemy/blob/master/lib/sqlalchemy/orm/session.py#L1719

प्रासंगिक स्निपेट:

def _save_impl(self, state): 
    if state.key is not None: 
     raise sa_exc.InvalidRequestError(
      "Object '%s' already has an identity - it can't be registered " 
      "as pending" % state_str(state)) 

    self._before_attach(state) 
    if state not in self._new: 
     self._new[state] = state.obj() 
     state.insert_order = len(self._new) # THE INSERT ORDER IS SAVED! 
    self._attach(state) 

और इस से Session.add =>self._save_or_update_state = कहा जाता है>self._save_or_update_impl =>self._save_impl।

यह तो जब बचत _sort_states में किया जाता है: https://github.com/zzzeek/sqlalchemy/blob/master/lib/sqlalchemy/orm/persistence.py#L859

दुर्भाग्य से, यह केवल कार्यान्वयन स्तर के सबूत है। मैं प्रलेखन यह गारंटी देता है कि में कुछ भी नहीं मिला ...

अद्यतन: के बाद से इस में और अधिक एक सा लग रहा था मैंने, यह पता चला है कि वहाँ एक अवधारणा SQLAlchemy में काम की यूनिट कहा जाता है कि कुछ हद तक फ्लश के दौरान ऑर्डर को परिभाषित करता है: http://www.aosabook.org/en/sqlalchemy.html (कार्य इकाई की खोज)।

उसी कक्षा के भीतर, आदेश वास्तव में आदेश द्वारा निर्धारित किया जाता है कि add कहा गया था। हालांकि, आप अलग-अलग वर्गों के बीच INSERT में अलग-अलग ऑर्डर देख सकते हैं। आप प्रकार A की वस्तु a जोड़ सकते हैं और बाद में प्रकार B की वस्तु b जोड़ने के लिए, लेकिन a पता चला है b के लिए एक विदेशी कुंजी है करने के लिए हैं, तो आप a के लिए सम्मिलित पहले b के लिए एक सम्मिलित देखेंगे।