def setup_mappers(self):
# set up bi-directional eager loads
mapper(Left, left)
mapper(Right, right)
mapper(Middle, middle, properties=dict(
left=relation(Left,
lazy=False,
backref=backref('middle',lazy=False)),
right=relation(Right,
lazy=False,
backref=backref('middle', lazy=False)))),
def setup_mappers(self):
# set up bi-directional eager loads
mapper(Left, left)
mapper(Right, right)
mapper(Middle,
middle,
properties=dict(left=relation(Left,
lazy=False,
backref=backref('middle',
lazy=False)),
right=relation(Right,
lazy=False,
backref=backref('middle',
lazy=False)))),
def setup_mappers(self):
mapper(Account, accounts)
mapper(Transaction, transactions)
mapper(Entry, entries, properties=dict(
account=relation(Account,
uselist=False,
backref=backref('entries', lazy=True,
order_by=entries.c.entry_id)),
transaction=relation(Transaction,
uselist=False,
backref=backref('entries', lazy=False,
order_by=entries.c.entry_id))))
def test_single_parent_backref(self):
"""test that setting m2m via a uselist=False backref bypasses the single_parent raise"""
mapper(
A,
a,
properties={
"bs": relation(
B,
secondary=atob,
cascade="all, delete-orphan",
single_parent=True,
backref=backref("a", uselist=False),
)
},
)
mapper(B, b)
sess = create_session()
b1 = B(data="b1")
a1 = A(data="a1", bs=[b1])
self.assertRaises(sa_exc.InvalidRequestError, A, data="a2", bs=[b1])
a2 = A(data="a2")
b1.a = a2
assert b1 not in a1.bs
assert b1 in a2.bs
def test_one(self):
p_m = mapper(Part, parts)
mapper(InheritedPart, inherited_part, properties=dict(
part=relation(Part, lazy=False)))
d_m = mapper(Design, design, properties=dict(
inheritedParts=relation(InheritedPart,
cascade="all, delete-orphan",
backref="design")))
mapper(DesignType, design_types)
d_m.add_property(
"type", relation(DesignType, lazy=False, backref="designs"))
p_m.add_property(
"design", relation(
Design, lazy=False,
backref=backref("parts", cascade="all, delete-orphan")))
d = Design()
sess = create_session()
sess.add(d)
sess.flush()
sess.expunge_all()
x = sess.query(Design).get(1)
x.inheritedParts
def test_one(self):
p_m = mapper(Part, parts)
mapper(InheritedPart,
inherited_part,
properties=dict(part=relation(Part, lazy=False)))
d_m = mapper(
Design,
design,
properties=dict(inheritedParts=relation(
InheritedPart, cascade="all, delete-orphan",
backref="design")))
mapper(DesignType, design_types)
d_m.add_property("type",
relation(DesignType, lazy=False, backref="designs"))
p_m.add_property(
"design",
relation(Design,
lazy=False,
backref=backref("parts", cascade="all, delete-orphan")))
d = Design()
sess = create_session()
sess.add(d)
sess.flush()
sess.clear()
x = sess.query(Design).get(1)
x.inheritedParts
def setup_mappers(self):
mapper(Address, addresses)
mapper(
User,
users,
properties={"address": relation(Address, backref=backref("user", single_parent=True), uselist=False)},
)
def setup_mappers(self):
mapper(TT,
item,
properties={
'children':
relation(TT,
remote_side=[item.c.parent_uuid],
backref=backref('parent',
remote_side=[item.c.uuid]))
})
def test_nesting_with_functions(self):
mapper(Data, datas)
mapper(Foo, foo, properties={"data": relation(Data, backref=backref("foo", uselist=False))})
mapper(Stat, stats, properties={"data": relation(Data)})
session = create_session()
data = [Data(a=x) for x in range(5)]
session.add_all(data)
session.add_all(
(
Stat(data=data[0], somedata=1),
Stat(data=data[1], somedata=2),
Stat(data=data[2], somedata=3),
Stat(data=data[3], somedata=4),
Stat(data=data[4], somedata=5),
Stat(data=data[0], somedata=6),
Stat(data=data[1], somedata=7),
Stat(data=data[2], somedata=8),
Stat(data=data[3], somedata=9),
Stat(data=data[4], somedata=10),
)
)
session.flush()
arb_data = sa.select(
[stats.c.data_id, sa.func.max(stats.c.somedata).label("max")],
stats.c.data_id <= 5,
group_by=[stats.c.data_id],
).alias("arb")
arb_result = arb_data.execute().fetchall()
# order the result list descending based on 'max'
arb_result.sort(key=lambda a: a["max"], reverse=True)
# extract just the "data_id" from it
arb_result = [row["data_id"] for row in arb_result]
# now query for Data objects using that above select, adding the
# "order by max desc" separately
q = (
session.query(Data)
.options(sa.orm.eagerload("foo"))
.select_from(datas.join(arb_data, arb_data.c.data_id == datas.c.id))
.order_by(sa.desc(arb_data.c.max))
.limit(10)
)
# extract "data_id" from the list of result objects
verify_result = [d.id for d in q]
eq_(verify_result, arb_result)
def setup_mappers(self):
mapper(Account, accounts)
mapper(Transaction, transactions)
mapper(Entry,
entries,
properties=dict(account=relation(
Account,
uselist=False,
backref=backref('entries',
lazy=True,
order_by=entries.c.entry_id)),
transaction=relation(
Transaction,
uselist=False,
backref=backref(
'entries',
lazy=False,
order_by=entries.c.entry_id))))
def test_expunge_cascade(self):
mapper(Address, addresses)
mapper(User, users, properties={
'addresses':relation(Address,
backref=backref("user", cascade="all"),
cascade="all")})
_fixtures.run_inserts_for(users)
_fixtures.run_inserts_for(addresses)
session = create_session()
u = session.query(User).filter_by(id=7).one()
# get everything to load in both directions
print [a.user for a in u.addresses]
def test_nesting_with_functions(self):
mapper(Data, datas)
mapper(Foo,
foo,
properties={
'data': relation(Data,
backref=backref('foo', uselist=False))
})
mapper(Stat, stats, properties={'data': relation(Data)})
session = create_session()
data = [Data(a=x) for x in range(5)]
session.add_all(data)
session.add_all(
(Stat(data=data[0], somedata=1), Stat(data=data[1], somedata=2),
Stat(data=data[2], somedata=3), Stat(data=data[3], somedata=4),
Stat(data=data[4], somedata=5), Stat(data=data[0], somedata=6),
Stat(data=data[1], somedata=7), Stat(data=data[2], somedata=8),
Stat(data=data[3], somedata=9), Stat(data=data[4], somedata=10)))
session.flush()
arb_data = sa.select(
[stats.c.data_id,
sa.func.max(stats.c.somedata).label('max')],
stats.c.data_id <= 5,
group_by=[stats.c.data_id]).alias('arb')
arb_result = arb_data.execute().fetchall()
# order the result list descending based on 'max'
arb_result.sort(key=lambda a: a['max'], reverse=True)
# extract just the "data_id" from it
arb_result = [row['data_id'] for row in arb_result]
# now query for Data objects using that above select, adding the
# "order by max desc" separately
q = (session.query(Data).options(sa.orm.eagerload('foo')).select_from(
datas.join(arb_data, arb_data.c.data_id == datas.c.id)).order_by(
sa.desc(arb_data.c.max)).limit(10))
# extract "data_id" from the list of result objects
verify_result = [d.id for d in q]
eq_(verify_result, arb_result)
def test_no_save_cascade_2(self):
mapper(Address, addresses)
mapper(User, users, properties=dict(
addresses=relation(Address,
cascade="all",
backref=backref("user", cascade="none"))))
s = create_session()
u = User(name='u1')
a = Address(email_address='u1@e')
a.user = u
s.add(a)
assert u not in s
assert a in s
s.flush()
s.expunge_all()
assert s.query(Address).one().id == a.id
assert s.query(User).first() is None
def test_no_save_cascade_2(self):
mapper(Address, addresses)
mapper(User, users, properties=dict(
addresses=relation(Address,
cascade="all",
backref=backref("user", cascade="none"))))
s = create_session()
u = User(name='u1')
a = Address(email_address='u1@e')
a.user = u
s.add(a)
assert u not in s
assert a in s
s.flush()
s.clear()
assert s.query(Address).one().id == a.id
assert s.query(User).first() is None
def test_unidirectional_cascade_o2m(self):
mapper(Order, orders)
mapper(User, users, properties=dict(orders=relation(Order, backref=backref("user", cascade=None))))
sess = create_session()
o1 = Order()
sess.add(o1)
u1 = User(orders=[o1])
assert u1 not in sess
assert o1 in sess
sess.expunge_all()
o1 = Order()
u1 = User(orders=[o1])
sess.add(o1)
assert u1 not in sess
assert o1 in sess
def test_mapped_binds_from_expression(self):
"""Session can extract Table objects from ClauseElements and match them to tables."""
mapper(Address, addresses)
mapper(User, users, properties={
'addresses':relation(Address,
backref=backref("user", cascade="all"),
cascade="all")})
Session = sessionmaker(binds={User: self.metadata.bind,
Address: self.metadata.bind})
sess = Session()
sess.execute(users.insert(), params=dict(id=1, name='ed'))
eq_(sess.execute(users.select(users.c.id == 1)).fetchall(),
[(1, 'ed')])
eq_(sess.execute(users.select(User.id == 1)).fetchall(),
[(1, 'ed')])
sess.close()
def test_mapped_binds_from_expression(self):
"""Session can extract Table objects from ClauseElements and match them to tables."""
mapper(Address, addresses)
mapper(User, users, properties={
'addresses':relation(Address,
backref=backref("user", cascade="all"),
cascade="all")})
Session = sessionmaker(binds={User: self.metadata.bind,
Address: self.metadata.bind})
sess = Session()
sess.execute(users.insert(), params=dict(id=1, name='ed'))
eq_(sess.execute(users.select(users.c.id == 1)).fetchall(),
[(1, 'ed')])
eq_(sess.execute(users.select(User.id == 1)).fetchall(),
[(1, 'ed')])
sess.close()
def test_unidirectional_cascade_m2o(self):
mapper(Order, orders, properties={"user": relation(User, backref=backref("orders", cascade=None))})
mapper(User, users)
sess = create_session()
u1 = User()
sess.add(u1)
o1 = Order()
o1.user = u1
assert o1 not in sess
assert u1 in sess
sess.expunge_all()
u1 = User()
o1 = Order()
o1.user = u1
sess.add(u1)
assert o1 not in sess
assert u1 in sess
def test_unidirectional_cascade_o2m(self):
mapper(Order, orders)
mapper(User, users, properties = dict(
orders = relation(
Order, backref=backref("user", cascade=None))
))
sess = create_session()
o1 = Order()
sess.add(o1)
u1 = User(orders=[o1])
assert u1 not in sess
assert o1 in sess
sess.clear()
o1 = Order()
u1 = User(orders=[o1])
sess.add(o1)
assert u1 not in sess
assert o1 in sess
def test_unidirectional_cascade_m2o(self):
mapper(Order, orders, properties={
'user':relation(User, backref=backref("orders", cascade=None))
})
mapper(User, users)
sess = create_session()
u1 = User()
sess.add(u1)
o1 = Order()
o1.user = u1
assert o1 not in sess
assert u1 in sess
sess.clear()
u1 = User()
o1 = Order()
o1.user = u1
sess.add(u1)
assert o1 not in sess
assert u1 in sess
def test_expunge_cascade(self):
mapper(Address, addresses)
mapper(User, users, properties={
'addresses':relation(Address,
backref=backref("user", cascade="all"),
cascade="all")})
_fixtures.run_inserts_for(users)
_fixtures.run_inserts_for(addresses)
session = create_session()
u = session.query(User).filter_by(id=7).one()
# get everything to load in both directions
print [a.user for a in u.addresses]
# then see if expunge fails
session.expunge(u)
assert sa.orm.object_session(u) is None
assert sa.orm.attributes.instance_state(u).session_id is None
for a in u.addresses:
assert sa.orm.object_session(a) is None
assert sa.orm.attributes.instance_state(a).session_id is None
def testbasic(self):
"""Post_update only fires off when needed.
This test case used to produce many superfluous update statements,
particularly upon delete
"""
mapper(Node,
node,
properties={
'children':
relation(Node,
primaryjoin=node.c.id == node.c.parent_id,
lazy=True,
cascade="all",
backref=backref("parent", remote_side=node.c.id)),
'prev_sibling':
relation(Node,
primaryjoin=node.c.prev_sibling_id == node.c.id,
remote_side=node.c.id,
lazy=True,
uselist=False),
'next_sibling':
relation(Node,
primaryjoin=node.c.next_sibling_id == node.c.id,
remote_side=node.c.id,
lazy=True,
uselist=False,
post_update=True)
})
session = create_session()
def append_child(parent, child):
if parent.children:
parent.children[-1].next_sibling = child
child.prev_sibling = parent.children[-1]
parent.children.append(child)
def remove_child(parent, child):
child.parent = None
node = child.next_sibling
node.prev_sibling = child.prev_sibling
child.prev_sibling.next_sibling = node
session.delete(child)
root = Node('root')
about = Node('about')
cats = Node('cats')
stories = Node('stories')
bruce = Node('bruce')
append_child(root, about)
assert (about.prev_sibling is None)
append_child(root, cats)
assert (cats.prev_sibling is about)
assert (cats.next_sibling is None)
assert (about.next_sibling is cats)
assert (about.prev_sibling is None)
append_child(root, stories)
append_child(root, bruce)
session.add(root)
session.flush()
remove_child(root, cats)
# pre-trigger lazy loader on 'cats' to make the test easier
cats.children
self.assert_sql_execution(
testing.db, session.flush,
CompiledSQL(
"UPDATE node SET prev_sibling_id=:prev_sibling_id "
"WHERE node.id = :node_id", lambda ctx: {
'prev_sibling_id': about.id,
'node_id': stories.id
}),
CompiledSQL(
"UPDATE node SET next_sibling_id=:next_sibling_id "
"WHERE node.id = :node_id", lambda ctx: {
'next_sibling_id': stories.id,
'node_id': about.id
}),
CompiledSQL(
"UPDATE node SET next_sibling_id=:next_sibling_id "
"WHERE node.id = :node_id", lambda ctx: {
'next_sibling_id': None,
'node_id': cats.id
}),
CompiledSQL("DELETE FROM node WHERE node.id = :id",
lambda ctx: [{
'id': cats.id
}]))
def setup_mappers(self):
mapper(T1, t1, properties=dict(t2=relation(T2, cascade="all, delete-orphan", single_parent=True)))
mapper(
T2,
t2,
properties=dict(
t3=relation(T3, cascade="all, delete-orphan", single_parent=True, backref=backref("t2", uselist=False))
),
)
mapper(T3, t3)
def setup_mappers(self):
mapper(TT, item, properties={
'children': relation(
TT,
remote_side=[item.c.parent_uuid],
backref=backref('parent', remote_side=[item.c.uuid]))})
def testbasic(self):
"""Post_update only fires off when needed.
This test case used to produce many superfluous update statements,
particularly upon delete
"""
mapper(Node, node, properties={
'children': relation(
Node,
primaryjoin=node.c.id==node.c.parent_id,
lazy=True,
cascade="all",
backref=backref("parent", remote_side=node.c.id)
),
'prev_sibling': relation(
Node,
primaryjoin=node.c.prev_sibling_id==node.c.id,
remote_side=node.c.id,
lazy=True,
uselist=False),
'next_sibling': relation(
Node,
primaryjoin=node.c.next_sibling_id==node.c.id,
remote_side=node.c.id,
lazy=True,
uselist=False,
post_update=True)})
session = create_session()
def append_child(parent, child):
if parent.children:
parent.children[-1].next_sibling = child
child.prev_sibling = parent.children[-1]
parent.children.append(child)
def remove_child(parent, child):
child.parent = None
node = child.next_sibling
node.prev_sibling = child.prev_sibling
child.prev_sibling.next_sibling = node
session.delete(child)
root = Node('root')
about = Node('about')
cats = Node('cats')
stories = Node('stories')
bruce = Node('bruce')
append_child(root, about)
assert(about.prev_sibling is None)
append_child(root, cats)
assert(cats.prev_sibling is about)
assert(cats.next_sibling is None)
assert(about.next_sibling is cats)
assert(about.prev_sibling is None)
append_child(root, stories)
append_child(root, bruce)
session.add(root)
session.flush()
remove_child(root, cats)
# pre-trigger lazy loader on 'cats' to make the test easier
cats.children
self.assert_sql_execution(
testing.db,
session.flush,
CompiledSQL("UPDATE node SET prev_sibling_id=:prev_sibling_id "
"WHERE node.id = :node_id",
lambda ctx:{'prev_sibling_id':about.id, 'node_id':stories.id}),
CompiledSQL("UPDATE node SET next_sibling_id=:next_sibling_id "
"WHERE node.id = :node_id",
lambda ctx:{'next_sibling_id':stories.id, 'node_id':about.id}),
CompiledSQL("UPDATE node SET next_sibling_id=:next_sibling_id "
"WHERE node.id = :node_id",
lambda ctx:{'next_sibling_id':None, 'node_id':cats.id}),
CompiledSQL("DELETE FROM node WHERE node.id = :id",
lambda ctx:[{'id':cats.id}])
)
