def setup_model(model, metadata, **p): model.UserBalance = UserBalance model.users_balances_table = Table("users_balances", metadata, autoload=True) model.users_balances_mapper = mapper(UserBalance, model.users_balances_table) model.AuthenticatedUser = AuthenticatedUser model.authenticated_users_table = Table("authenticated_users", metadata, autoload=True) model.authenticated_users_mapper = mapper(AuthenticatedUser, model.authenticated_users_table, properties = { "balances": relation(model.UserBalance, lazy=True, backref="user", cascade="all, delete-orphan"), }) model.PasswordResetRequest = PasswordResetRequest model.password_reset_requests_table = Table("password_reset_requests", metadata, autoload=True) model.password_reset_requests_mapper = mapper(PasswordResetRequest, model.password_reset_requests_table) model.password_reset_requests_mapper.add_property("user", relation(model.AuthenticatedUser)) model.BalanceInvitation = BalanceInvitation model.balance_invitations_table = Table("balance_invitations", metadata, autoload=True) model.balance_invitations_mapper = mapper(BalanceInvitation, model.balance_invitations_table) model.balance_invitations_mapper.add_property("sender", relation(model.AuthenticatedUser)) model.Invitation = Invitation model.invitations_table = Table("invitations", metadata, autoload=True) model.invitations_mapper = mapper(Invitation, model.invitations_table) model.invitations_mapper.add_property("sender", relation(model.AuthenticatedUser)) model.BalanceTag = BalanceTag model.balance_tags_table = Table("balance_tags", metadata, autoload=True) model.balance_tags_mapper = mapper(BalanceTag, model.balance_tags_table) model.ChangeTag = ChangeTag model.changes_tags_table = Table("changes_tags", metadata, autoload=True) model.changes_tags_mapper = mapper(ChangeTag, model.changes_tags_table) model.BalanceChange = BalanceChange model.balance_changes_table = Table("balance_changes", metadata, autoload=True) model.balance_changes_mapper = mapper(BalanceChange, model.balance_changes_table, properties = { "tags": relation(model.BalanceTag, secondary=model.changes_tags_table, backref="changes"), }) model.balance_changes_mapper.add_property("user", relation(model.AuthenticatedUser)) model.Balance = Balance model.balances_table = Table("balances", metadata, autoload=True) model.balances_mapper = mapper(Balance, model.balances_table, properties = { "users" : dynamic_loader(model.UserBalance, backref="balance", cascade="all, delete-orphan"), "tags" : dynamic_loader(model.BalanceTag, backref="balance", cascade="all, delete-orphan"), "invitations": dynamic_loader(model.BalanceInvitation, backref="balance", cascade="all, delete-orphan"), "changes": dynamic_loader(model.BalanceChange, backref="balance", cascade="all, delete-orphan"), }) model.ChangeCategory = ChangeCategory model.change_categories_table = Table("change_categories", metadata, autoload=True) model.change_categories_mapper = mapper(ChangeCategory, model.change_categories_table, properties = { "balance_changes" : dynamic_loader(model.BalanceChange, backref="change_category"), })
def setup_model(model, metadata): """ Define model used by our application - classes, tables, relationships. """ model.UserBalance = UserBalance model.users_balances_table = Table("users_balances", metadata, autoload=True) model.users_balances_mapper = mapper(UserBalance, model.users_balances_table) model.AuthenticatedUser = AuthenticatedUser model.authenticated_users_table = Table("authenticated_users", metadata, autoload=True) model.authenticated_users_mapper = mapper(AuthenticatedUser, model.authenticated_users_table, properties = { "balances": relation(model.UserBalance, lazy=True, backref="user", cascade="all, delete-orphan"), }) model.PasswordResetRequest = PasswordResetRequest model.password_reset_requests_table = Table("password_reset_requests", metadata, autoload=True) model.password_reset_requests_mapper = mapper(PasswordResetRequest, model.password_reset_requests_table) model.password_reset_requests_mapper.add_property("user", relation(model.AuthenticatedUser)) model.BalanceInvitation = BalanceInvitation model.balance_invitations_table = Table("balance_invitations", metadata, autoload=True) model.balance_invitations_mapper = mapper(BalanceInvitation, model.balance_invitations_table) model.balance_invitations_mapper.add_property("sender", relation(model.AuthenticatedUser)) model.Invitation = Invitation model.invitations_table = Table("invitations", metadata, autoload=True) model.invitations_mapper = mapper(Invitation, model.invitations_table) model.invitations_mapper.add_property("sender", relation(model.AuthenticatedUser)) model.ChangeTag = ChangeTag model.changes_tags_table = Table("changes_tags", metadata, autoload=True) model.changes_tags_mapper = mapper(ChangeTag, model.changes_tags_table) model.BalanceChange = BalanceChange model.balance_changes_table = Table("balance_changes", metadata, autoload=True) model.balance_changes_mapper = mapper(BalanceChange, model.balance_changes_table, properties = { "tags": relation(model.ChangeTag, backref="change", cascade="all, delete-orphan", lazy=False), "transfer": relation(model.BalanceChange, uselist=False, remote_side=[model.balance_changes_table.c.uid], lazy=False, post_update=True), }) model.balance_changes_mapper.add_property("user", relation(model.AuthenticatedUser)) model.Balance = Balance model.balances_table = Table("balances", metadata, autoload=True) model.balances_mapper = mapper(Balance, model.balances_table, properties = { "users" : dynamic_loader(model.UserBalance, backref="balance", cascade="all, delete-orphan"), "invitations": dynamic_loader(model.BalanceInvitation, backref="balance", cascade="all, delete-orphan"), "changes": dynamic_loader(model.BalanceChange, backref="balance", cascade="all, delete-orphan"), }) model.ChangeCategory = ChangeCategory model.change_categories_table = Table("change_categories", metadata, autoload=True) model.change_categories_mapper = mapper(ChangeCategory, model.change_categories_table, properties = { "balance_changes" : dynamic_loader(model.BalanceChange, backref="change_category"), })
def init_model_extra(): """ The model uses the string based arguments (because the class may not have been defined yet) I'm unsure as to wether the problem was with the version of SQLAlchemy but with the string method it was not possible to specify multiple conditions under the primary join param even though the SQL created was correct In the future it may be possible to intigrate these with the main class defentions """ period_in_days = 30 Member.active_assignments_period = relationship( AssignmentContent, primaryjoin=and_( AssignmentContent.creator_id == Member.id, AssignmentContent.creation_date > (now() - datetime.timedelta(days=period_in_days))), order_by=AssignmentContent.update_date.desc()) Member.interest = dynamic_loader( Content, primaryjoin=Member.id == Interest.member_id, secondary=Interest.__table__, secondaryjoin=Interest.content_id == Content.id, foreign_keys=[Interest.member_id, Interest.content_id], backref='interested_members', ) AssignmentContent.accepted_by = dynamic_loader( Member, primaryjoin=and_( AssignmentContent.id == MemberAssignment.content_id, MemberAssignment.status == "accepted", ), secondary=MemberAssignment.__table__, secondaryjoin=MemberAssignment.member_id == Member.id, foreign_keys=[MemberAssignment.content_id, MemberAssignment.member_id], backref='assignments_accepted') AssignmentContent.invited_members = dynamic_loader( Member, primaryjoin=and_( AssignmentContent.id == MemberAssignment.content_id, MemberAssignment.status == "pending", ), secondary=MemberAssignment.__table__, secondaryjoin=MemberAssignment.member_id == Member.id, foreign_keys=[MemberAssignment.content_id, MemberAssignment.member_id], backref='assignments_invited') Member.boomed_content = relationship( "Content", primaryjoin=Member.id == Boom.member_id, secondary=Boom.__table__, secondaryjoin=Boom.content_id == Content.id, backref=backref('boomed_by'), foreign_keys=[Boom.member_id, Boom.content_id], #cascade="all,delete-orphan", )
def test_remove_orphans(self): mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses), order_by=Address.id, cascade="all, delete-orphan", backref='user') }) sess = create_session(autoflush=True) u = User(name='ed') u.addresses.append(Address(email_address='a')) u.addresses.append(Address(email_address='b')) u.addresses.append(Address(email_address='c')) u.addresses.append(Address(email_address='d')) u.addresses.append(Address(email_address='e')) u.addresses.append(Address(email_address='f')) sess.add(u) eq_([Address(email_address='a'), Address(email_address='b'), Address(email_address='c'), Address(email_address='d'), Address(email_address='e'), Address(email_address='f')], sess.query(Address).all()) eq_(Address(email_address='c'), u.addresses[2]) try: del u.addresses[3] assert False except TypeError, e: assert "doesn't support item deletion" in str(e), str(e)
def test_order_by(self): mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) sess = create_session() u = sess.query(User).get(8) eq_(list(u.addresses.order_by(desc(Address.email_address))), [Address(email_address=u'*****@*****.**'), Address(email_address=u'*****@*****.**'), Address(email_address=u'*****@*****.**')])
def _backref_test(self, autoflush, saveuser): mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses), backref='user') }) sess = create_session(autoflush=autoflush) u = User(name='buffy') a = Address(email_address='*****@*****.**') a.user = u if saveuser: sess.add(u) else: sess.add(a) if not autoflush: sess.flush() assert u in sess assert a in sess eq_(list(u.addresses), [a]) a.user = None if not autoflush: eq_(list(u.addresses), [a]) if not autoflush: sess.flush() eq_(list(u.addresses), [])
def test_count(self): mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) sess = create_session() u = sess.query(User).first() eq_(u.addresses.count(), 1)
def test_delete_nocascade(self): mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses), order_by=Address.id, backref='user') }) sess = create_session(autoflush=True) u = User(name='ed') u.addresses.append(Address(email_address='a')) u.addresses.append(Address(email_address='b')) u.addresses.append(Address(email_address='c')) u.addresses.append(Address(email_address='d')) u.addresses.append(Address(email_address='e')) u.addresses.append(Address(email_address='f')) sess.add(u) assert Address(email_address='c') == u.addresses[2] sess.delete(u.addresses[2]) sess.delete(u.addresses[4]) sess.delete(u.addresses[3]) assert [Address(email_address='a'), Address(email_address='b'), Address(email_address='d')] == list(u.addresses) sess.expunge_all() u = sess.query(User).get(u.id) sess.delete(u) # u.addresses relation will have to force the load # of all addresses so that they can be updated sess.flush() sess.close() assert testing.db.scalar(addresses.count(addresses.c.user_id != None)) ==0
def test_delete_cascade(self): mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses), order_by=Address.id, backref='user', cascade="all, delete-orphan") }) sess = create_session(autoflush=True) u = User(name='ed') u.addresses.append(Address(email_address='a')) u.addresses.append(Address(email_address='b')) u.addresses.append(Address(email_address='c')) u.addresses.append(Address(email_address='d')) u.addresses.append(Address(email_address='e')) u.addresses.append(Address(email_address='f')) sess.add(u) eq_(Address(email_address='c'), u.addresses[2]) sess.delete(u.addresses[2]) sess.delete(u.addresses[4]) sess.delete(u.addresses[3]) eq_([Address(email_address='a'), Address(email_address='b'), Address(email_address='d')], list(u.addresses)) sess.expunge_all() u = sess.query(User).get(u.id) sess.delete(u) # u.addresses relationship will have to force the load # of all addresses so that they can be updated sess.flush() sess.close() eq_(testing.db.scalar(addresses.count()), 0)
def test_configured_order_by(self): mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses), order_by=desc(Address.email_address)) }) sess = create_session() u = sess.query(User).get(8) eq_(list(u.addresses), [Address(email_address=u'*****@*****.**'), Address(email_address=u'*****@*****.**'), Address(email_address=u'*****@*****.**')])
class Indicator(Base): implements(IIndicator) __tablename__ = 'indicators' id = Column(UUID, primary_key=True, default=uuid.uuid4) indicator_set_id = Column(UUID, ForeignKey('indicator_sets.id')) title = Column(Unicode(255)) description = Column(UnicodeText) type = Column(Unicode(255)) weight = Column(Float) sort_order = Column(Integer) indicator_set = relation(IndicatorSet, backref=backref( 'indicators', lazy='dynamic', cascade='all,delete-orphan', order_by='indicators.c.sort_order')) journal_entries = dynamic_loader(JournalEntry, secondary=journal_entries_indicators, backref=backref('indicators', lazy='dynamic')) @property def __name__(self): return str(self.id)
def test_collection_set(self): users, Address, addresses, User = (self.tables.users, self.classes.Address, self.tables.addresses, self.classes.User) mapper(User, users, properties={ 'addresses': dynamic_loader(mapper(Address, addresses), order_by=addresses.c.email_address) }) sess = create_session(autoflush=True, autocommit=False) u1 = User(name='jack') a1 = Address(email_address='a1') a2 = Address(email_address='a2') a3 = Address(email_address='a3') a4 = Address(email_address='a4') sess.add(u1) u1.addresses = [a1, a3] eq_(list(u1.addresses), [a1, a3]) u1.addresses = [a1, a2, a4] eq_(list(u1.addresses), [a1, a2, a4]) u1.addresses = [a2, a3] eq_(list(u1.addresses), [a2, a3]) u1.addresses = [] eq_(list(u1.addresses), [])
def test_no_count(self): users, Address, addresses, User = (self.tables.users, self.classes.Address, self.tables.addresses, self.classes.User) mapper(User, users, properties={ 'addresses': dynamic_loader(mapper(Address, addresses)) }) sess = create_session() q = sess.query(User) # dynamic collection cannot implement __len__() (at least one that # returns a live database result), else additional count() queries are # issued when evaluating in a list context def go(): eq_([ User(id=7, addresses=[Address(id=1, email_address='*****@*****.**')]) ], q.filter(User.id == 7).all()) self.assert_sql_count(testing.db, go, 2)
def test_custom_query(self): class MyQuery(Query): pass mapper(User, users, properties={ 'addresses': dynamic_loader(mapper(Address, addresses), query_class=MyQuery) }) sess = create_session() u = User() sess.add(u) col = u.addresses assert isinstance(col, Query) assert isinstance(col, MyQuery) assert hasattr(col, 'append') assert type(col).__name__ == 'AppenderMyQuery' q = col.limit(1) assert isinstance(q, Query) assert isinstance(q, MyQuery) assert not hasattr(q, 'append') assert type(q).__name__ == 'MyQuery'
def test_configured_order_by(self): mapper(User, users, properties={ 'addresses': dynamic_loader(mapper(Address, addresses), order_by=desc(Address.email_address)) }) sess = create_session() u = sess.query(User).get(8) eq_(list(u.addresses), [ Address(email_address=u'*****@*****.**'), Address(email_address=u'*****@*****.**'), Address(email_address=u'*****@*****.**') ]) # test cancellation of None, replacement with something else eq_(list(u.addresses.order_by(None).order_by(Address.email_address)), [ Address(email_address=u'*****@*****.**'), Address(email_address=u'*****@*****.**'), Address(email_address=u'*****@*****.**') ]) # test cancellation of None, replacement with nothing eq_( set(u.addresses.order_by(None)), set([ Address(email_address=u'*****@*****.**'), Address(email_address=u'*****@*****.**'), Address(email_address=u'*****@*****.**') ]))
def test_basic(self): mapper(User, users, properties={ 'addresses': dynamic_loader(mapper(Address, addresses)) }) sess = create_session() u1 = User(name='jack') u2 = User(name='ed') u2.addresses.append(Address(email_address='*****@*****.**')) u1.addresses.append(Address(email_address='*****@*****.**')) sess.add_all((u1, u2)) sess.flush() from sqlalchemy.orm import attributes self.assertEquals( attributes.get_history(attributes.instance_state(u1), 'addresses'), ([], [Address(email_address='*****@*****.**')], [])) sess.clear() # test the test fixture a little bit assert User(name='jack', addresses=[Address(email_address='wrong') ]) != sess.query(User).first() assert User(name='jack', addresses=[Address(email_address='*****@*****.**') ]) == sess.query(User).first() assert [ User(name='jack', addresses=[Address(email_address='*****@*****.**')]), User(name='ed', addresses=[Address(email_address='*****@*****.**')]) ] == sess.query(User).all()
def test_delete_nocascade(self): mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses), order_by=Address.id, backref='user') }) sess = create_session(autoflush=True) u = User(name='ed') u.addresses.append(Address(email_address='a')) u.addresses.append(Address(email_address='b')) u.addresses.append(Address(email_address='c')) u.addresses.append(Address(email_address='d')) u.addresses.append(Address(email_address='e')) u.addresses.append(Address(email_address='f')) sess.add(u) assert Address(email_address='c') == u.addresses[2] sess.delete(u.addresses[2]) sess.delete(u.addresses[4]) sess.delete(u.addresses[3]) assert [Address(email_address='a'), Address(email_address='b'), Address(email_address='d')] == list(u.addresses) sess.clear() u = sess.query(User).get(u.id) sess.delete(u) # u.addresses relation will have to force the load # of all addresses so that they can be updated sess.flush() sess.close() assert testing.db.scalar(addresses.count(addresses.c.user_id != None)) ==0
def test_flush(self): mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) sess = create_session() u1 = User(name='jack') u2 = User(name='ed') u2.addresses.append(Address(email_address='*****@*****.**')) u1.addresses.append(Address(email_address='*****@*****.**')) sess.add_all((u1, u2)) sess.flush() from sqlalchemy.orm import attributes eq_(attributes.get_history(u1, 'addresses'), ([], [Address(email_address='*****@*****.**')], [])) sess.expunge_all() # test the test fixture a little bit ne_(User(name='jack', addresses=[Address(email_address='wrong')]), sess.query(User).first()) eq_(User(name='jack', addresses=[Address(email_address='*****@*****.**')]), sess.query(User).first()) eq_([ User(name='jack', addresses=[Address(email_address='*****@*****.**')]), User(name='ed', addresses=[Address(email_address='*****@*****.**')]) ], sess.query(User).all())
def test_basic(self): mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) sess = create_session() u1 = User(name='jack') u2 = User(name='ed') u2.addresses.append(Address(email_address='*****@*****.**')) u1.addresses.append(Address(email_address='*****@*****.**')) sess.add_all((u1, u2)) sess.flush() from sqlalchemy.orm import attributes self.assertEquals(attributes.get_history(attributes.instance_state(u1), 'addresses'), ([], [Address(email_address='*****@*****.**')], [])) sess.clear() # test the test fixture a little bit assert User(name='jack', addresses=[Address(email_address='wrong')]) != sess.query(User).first() assert User(name='jack', addresses=[Address(email_address='*****@*****.**')]) == sess.query(User).first() assert [ User(name='jack', addresses=[Address(email_address='*****@*****.**')]), User(name='ed', addresses=[Address(email_address='*****@*****.**')]) ] == sess.query(User).all()
def test_collection_set(self): users, Address, addresses, User = (self.tables.users, self.classes.Address, self.tables.addresses, self.classes.User) mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses), order_by=addresses.c.email_address) }) sess = create_session(autoflush=True, autocommit=False) u1 = User(name='jack') a1 = Address(email_address='a1') a2 = Address(email_address='a2') a3 = Address(email_address='a3') a4 = Address(email_address='a4') sess.add(u1) u1.addresses = [a1, a3] eq_(list(u1.addresses), [a1, a3]) u1.addresses = [a1, a2, a4] eq_(list(u1.addresses), [a1, a2, a4]) u1.addresses = [a2, a3] eq_(list(u1.addresses), [a2, a3]) u1.addresses = [] eq_(list(u1.addresses), [])
def test_rollback(self): users, Address, addresses, User = (self.tables.users, self.classes.Address, self.tables.addresses, self.classes.User) mapper(User, users, properties={ 'addresses': dynamic_loader(mapper(Address, addresses)) }) sess = create_session(expire_on_commit=False, autocommit=False, autoflush=True) u1 = User(name='jack') u1.addresses.append(Address(email_address='*****@*****.**')) sess.add(u1) sess.flush() sess.commit() u1.addresses.append(Address(email_address='*****@*****.**')) eq_( u1.addresses.order_by(Address.id).all(), [ Address(email_address='*****@*****.**'), Address(email_address='*****@*****.**') ]) sess.rollback() eq_(u1.addresses.all(), [Address(email_address='*****@*****.**')])
def test_custom_query(self): users, Address, addresses, User = (self.tables.users, self.classes.Address, self.tables.addresses, self.classes.User) class MyQuery(Query): pass mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses), query_class=MyQuery) }) sess = create_session() u = User() sess.add(u) col = u.addresses assert isinstance(col, Query) assert isinstance(col, MyQuery) assert hasattr(col, 'append') eq_(type(col).__name__, 'AppenderMyQuery') q = col.limit(1) assert isinstance(q, Query) assert isinstance(q, MyQuery) assert not hasattr(q, 'append') eq_(type(q).__name__, 'MyQuery')
def test_events(self): mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) sess = create_session() u1 = User(name='jack') a1 = Address(email_address='foo') sess.add_all([u1, a1]) sess.flush() eq_(testing.db.scalar(select([func.count(1)]).where(addresses.c.user_id!=None)), 0) u1 = sess.query(User).get(u1.id) u1.addresses.append(a1) sess.flush() eq_(testing.db.execute(select([addresses]).where(addresses.c.user_id!=None)).fetchall(), [(a1.id, u1.id, 'foo')]) u1.addresses.remove(a1) sess.flush() eq_(testing.db.scalar(select([func.count(1)]).where(addresses.c.user_id!=None)), 0) u1.addresses.append(a1) sess.flush() eq_(testing.db.execute(select([addresses]).where(addresses.c.user_id!=None)).fetchall(), [(a1.id, u1.id, 'foo')]) a2 = Address(email_address='bar') u1.addresses.remove(a1) u1.addresses.append(a2) sess.flush() eq_(testing.db.execute(select([addresses]).where(addresses.c.user_id!=None)).fetchall(), [(a2.id, u1.id, 'bar')])
def test_merge(self): mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses), order_by=addresses.c.email_address) }) sess = create_session() u1 = User(name='jack') a1 = Address(email_address='a1') a2 = Address(email_address='a2') a3 = Address(email_address='a3') u1.addresses.append(a2) u1.addresses.append(a3) sess.add_all([u1, a1]) sess.flush() u1 = User(id=u1.id, name='jack') u1.addresses.append(a1) u1.addresses.append(a3) u1 = sess.merge(u1) eq_(attributes.get_history(u1, 'addresses'), ( [a1], [a3], [a2] )) sess.flush() eq_( list(u1.addresses), [a1, a3] )
class Student(User): implements(IStudent) __tablename__ = 'students' id = Column(UUID, ForeignKey('users.id'), primary_key=True) __mapper_args__ = {'polymorphic_identity': u'student'} # student specific fields date_of_birth = Column(Date) languages = Column(Unicode(255)) interests = Column(UnicodeText) experiences = Column(UnicodeText) hobbies = Column(UnicodeText) projects = dynamic_loader(Project, secondary=students_projects, backref=backref('students', lazy='dynamic')) @property def groups(self): groups = [ 'group:students', ] for project in self.projects: groups.append('group:students_%s' % project.id) return tuple(groups)
def test_transient_detached(self): mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) sess = create_session() u1 = User() u1.addresses.append(Address()) eq_(u1.addresses.count(), 1) eq_(u1.addresses[0], Address())
def test_hasattr(self): mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) u1 = User(name='jack') assert 'addresses' not in u1.__dict__.keys() u1.addresses = [Address(email_address='test')] assert 'addresses' in dir(u1)
def test_no_populate(self): mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) u1 = User() assert_raises_message( NotImplementedError, "Dynamic attributes don't support collection population.", attributes.set_committed_value, u1, 'addresses', [] )
class MyParent(Base): __tablename__ = 'parent' id = Column(Integer, primary_key=True) name = Column(String(50)) _collection = dynamic_loader("MyChild", cascade="all, delete-orphan") def child_map(self): return MyProxyDict(self, '_collection', MyChild, 'key') child_map = property(child_map)
def test_no_populate(self): mapper(User, users, properties={ 'addresses': dynamic_loader(mapper(Address, addresses)) }) u1 = User() assert_raises_message( NotImplementedError, "Dynamic attributes don't support collection population.", attributes.set_committed_value, u1, 'addresses', [])
def test_count(self): users, Address, addresses, User = (self.tables.users, self.classes.Address, self.tables.addresses, self.classes.User) mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) sess = create_session() u = sess.query(User).first() eq_(u.addresses.count(), 1)
def test_basic(self): mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) sess = create_session() q = sess.query(User) u = q.filter(User.id==7).first() eq_([User(id=7, addresses=[Address(id=1, email_address='*****@*****.**')])], q.filter(User.id==7).all()) eq_(self.static.user_address_result, q.all())
def test_rollback(self): mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) sess = create_session(expire_on_commit=False, autocommit=False, autoflush=True) u1 = User(name='jack') u1.addresses.append(Address(email_address='*****@*****.**')) sess.add(u1) sess.flush() sess.commit() u1.addresses.append(Address(email_address='*****@*****.**')) eq_(u1.addresses.all(), [Address(email_address='*****@*****.**'), Address(email_address='*****@*****.**')]) sess.rollback() eq_(u1.addresses.all(), [Address(email_address='*****@*****.**')])
def config_keyable(cls,name="settings"): """Object - List Mixin/Mutator""" mapper = class_mapper(cls) table = mapper.local_table cls_name = str(cls) cls_name = cls_name[cls_name.rfind('.')+1:cls_name.rfind('\'')].lower() mapper.add_property(name, dynamic_loader(ConfigAttribute, primaryjoin=and_(table.c.id==configattribute_table.c.object_id,configattribute_table.c.object_type==cls_name), foreign_keys=[configattribute_table.c.object_id], backref='%s' % table.name)) # initialize some stuff def on_new(self): self.object_type = cls_name setattr(cls, "on_new", on_new)
def test_order_by(self): users, Address, addresses, User = (self.tables.users, self.classes.Address, self.tables.addresses, self.classes.User) mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) sess = create_session() u = sess.query(User).get(8) eq_( list(u.addresses.order_by(desc(Address.email_address))), [Address(email_address=u'*****@*****.**'), Address(email_address=u'*****@*****.**'), Address(email_address=u'*****@*****.**')] )
def test_no_count(self): mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) sess = create_session() q = sess.query(User) # dynamic collection cannot implement __len__() (at least one that # returns a live database result), else additional count() queries are # issued when evaluating in a list context def go(): eq_([User(id=7, addresses=[Address(id=1, email_address='*****@*****.**')])], q.filter(User.id==7).all()) self.assert_sql_count(testing.db, go, 2)
def userlistable(cls,name="users"): """User - List Mixin/Mutator""" mapper = class_mapper(cls) table = mapper.local_table cls_name = str(cls) cls_name = cls_name[cls_name.rfind('.')+1:cls_name.rfind('\'')].lower() mapper.add_property(name, dynamic_loader(UserAttribute, primaryjoin=and_(table.c.id==userattribute_table.c.object_id,userattribute_table.c.object_type==cls_name), foreign_keys=[userattribute_table.c.object_id], backref='%s' % table.name)) #log.debug("userlistable table.name = %s" % table.name) # initialize some stuff def on_new(self): self.object_type = cls_name setattr(cls, "on_new", on_new)
def test_statement(self): """test that the .statement accessor returns the actual statement that would render, without any _clones called.""" mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses)) }) sess = create_session() q = sess.query(User) u = q.filter(User.id==7).first() self.assert_compile( u.addresses.statement, "SELECT addresses.id, addresses.user_id, addresses.email_address FROM " "addresses WHERE :param_1 = addresses.user_id", use_default_dialect=True )
def test_detached_raise(self): users, Address, addresses, User = (self.tables.users, self.classes.Address, self.tables.addresses, self.classes.User) mapper(User, users, properties={ 'addresses': dynamic_loader(mapper(Address, addresses)) }) sess = create_session() u = sess.query(User).get(8) sess.expunge(u) assert_raises( orm_exc.DetachedInstanceError, u.addresses.filter_by, email_address='e' )
def versionable(cls,name): """Versionable Mixin/Mutator""" mapper = class_mapper(cls) table = mapper.local_table cls_name = str(cls) cls_name = cls_name[cls_name.rfind('.')+1:cls_name.rfind('\'')].lower() mapper.add_property('versions', dynamic_loader(Version, primaryjoin=and_(table.c.id==version.c.object_id,version.c.object_type==cls_name), foreign_keys=[version.c.object_id], backref='%ss' % table.name)) # most recent version def version_latest(self): if self.versions is None: return None return self.versions.order_by(version.c.version.desc()).first() setattr(cls, "version_latest", property(version_latest))
def orm_load_dynamic_dataset(man): man.dynamicdataset_table = Table( "dynamic_dataset", man.metadata, Column("basedataset_id", Integer, ForeignKey("basedataset.id"), primary_key=True), ) # man.metadata.create_all() mapper( DynamicDataSet, man.dynamicdataset_table, inherits=BaseDataSet, polymorphic_identity="dynamic_dataset", properties={ "data": dynamic_loader( BaseData, secondary=man.data_basedataset_table, backref="dynamicdatasets", cascade="all" ) }, )
def test_remove_orphans(self): users, Address, addresses, User = (self.tables.users, self.classes.Address, self.tables.addresses, self.classes.User) mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses), order_by=Address.id, cascade="all, delete-orphan", backref='user') }) sess = create_session(autoflush=True, autocommit=False) u = User(name='ed') u.addresses.append(Address(email_address='a')) u.addresses.append(Address(email_address='b')) u.addresses.append(Address(email_address='c')) u.addresses.append(Address(email_address='d')) u.addresses.append(Address(email_address='e')) u.addresses.append(Address(email_address='f')) sess.add(u) eq_([Address(email_address='a'), Address(email_address='b'), Address(email_address='c'), Address(email_address='d'), Address(email_address='e'), Address(email_address='f')], sess.query(Address).all()) eq_(Address(email_address='c'), u.addresses[2]) def go(): del u.addresses[3] assert_raises( TypeError, go ) for a in u.addresses.filter(Address.email_address.in_(['c', 'e', 'f'])): u.addresses.remove(a) eq_([Address(email_address='a'), Address(email_address='b'), Address(email_address='d')], list(u.addresses)) eq_([Address(email_address='a'), Address(email_address='b'), Address(email_address='d')], sess.query(Address).all()) sess.delete(u) sess.close()
def test_custom_query_with_custom_mixin(self): users, Address, addresses, User = (self.tables.users, self.classes.Address, self.tables.addresses, self.classes.User) class MyAppenderMixin(AppenderMixin): def add(self, items): if isinstance(items, list): for item in items: self.append(item) else: self.append(items) class MyQuery(Query): pass class MyAppenderQuery(MyAppenderMixin, MyQuery): query_class = MyQuery mapper(User, users, properties={ 'addresses': dynamic_loader(mapper(Address, addresses), query_class=MyAppenderQuery) }) sess = create_session() u = User() sess.add(u) col = u.addresses assert isinstance(col, Query) assert isinstance(col, MyQuery) assert hasattr(col, 'append') assert hasattr(col, 'add') eq_(type(col).__name__, 'MyAppenderQuery') q = col.limit(1) assert isinstance(q, Query) assert isinstance(q, MyQuery) assert not hasattr(q, 'append') assert not hasattr(q, 'add') eq_(type(q).__name__, 'MyQuery')
def orm_load_dynamic_dataset(man): man.dynamicdataset_table = Table( 'dynamic_dataset', man.metadata, Column('basedataset_id', Integer, ForeignKey('basedataset.id'), primary_key=True)) #man.metadata.create_all() mapper(DynamicDataSet, man.dynamicdataset_table, inherits=BaseDataSet, polymorphic_identity='dynamic_dataset', properties={ 'data': dynamic_loader(BaseData, secondary=man.data_basedataset_table, backref='dynamicdatasets', cascade='all') })
def test_configured_order_by(self): mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses), order_by=desc(Address.email_address)) }) sess = create_session() u = sess.query(User).get(8) eq_(list(u.addresses), [Address(email_address=u'*****@*****.**'), Address(email_address=u'*****@*****.**'), Address(email_address=u'*****@*****.**')]) # test cancellation of None, replacement with something else eq_( list(u.addresses.order_by(None).order_by(Address.email_address)), [Address(email_address=u'*****@*****.**'), Address(email_address=u'*****@*****.**'), Address(email_address=u'*****@*****.**')] ) # test cancellation of None, replacement with nothing eq_( set(u.addresses.order_by(None)), set([Address(email_address=u'*****@*****.**'), Address(email_address=u'*****@*****.**'), Address(email_address=u'*****@*****.**')]) )
class Teacher(User): implements(ITeacher) __tablename__ = 'teachers' id = Column(UUID, ForeignKey('users.id'), primary_key=True) __mapper_args__ = {'polymorphic_identity': u'teacher'} # teacher specific fields projects = dynamic_loader(Project, secondary=teachers_projects, backref=backref('teachers', lazy='dynamic')) @property def groups(self): groups = ['group:teachers',] for project in self.projects: groups.append('group:teachers_%s' % project.id) return tuple(groups)
def test_collection_set(self): mapper(User, users, properties={ 'addresses':dynamic_loader(mapper(Address, addresses), order_by=addresses.c.email_address) }) sess = create_session(autoflush=True, autocommit=False) u1 = User(name='jack') a1 = Address(email_address='a1') a2 = Address(email_address='a2') a3 = Address(email_address='a3') a4 = Address(email_address='a4') sess.add(u1) u1.addresses = [a1, a3] assert list(u1.addresses) == [a1, a3] u1.addresses = [a1, a2, a4] assert list(u1.addresses) == [a1, a2, a4] u1.addresses = [a2, a3] assert list(u1.addresses) == [a2, a3] u1.addresses = [] assert list(u1.addresses) == []