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_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_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_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) == []