def test_delete_against_metadata(self):
User = self.classes.User
users = self.tables.users
sess = Session()
sess.query(users).delete(synchronize_session=False)
eq_(sess.query(User).count(), 0)
def test_update_from_multitable_same_names(self):
Document = self.classes.Document
User = self.classes.User
s = Session()
s.query(Document).filter(User.id == Document.user_id).filter(
User.id == 2).update(
{
Document.samename: "d_samename",
User.samename: "u_samename"
},
synchronize_session=False,
)
eq_(
s.query(User.id, Document.samename, User.samename).filter(
User.id == Document.user_id).order_by(User.id).all(),
[
(1, None, None),
(1, None, None),
(2, "d_samename", "u_samename"),
(2, "d_samename", "u_samename"),
(3, None, None),
(3, None, None),
],
)
def test_inner_joinedload_wo_limit(self):
User = self.classes.User
sess = Session()
sess.query(User).options(
joinedload(User.addresses, innerjoin=True)
).with_for_update().all()
sess.close()
def test_update_changes_resets_dirty(self):
User = self.classes.User
sess = Session(autoflush=False)
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
john.age = 50
jack.age = 37
# autoflush is false. therefore our '50' and '37' are getting
# blown away by this operation.
sess.query(User).filter(User.age > 29).update(
{"age": User.age - 10}, synchronize_session="evaluate")
for x in (john, jack, jill, jane):
assert not sess.is_modified(x)
eq_([john.age, jack.age, jill.age, jane.age], [25, 37, 29, 27])
john.age = 25
assert john in sess.dirty
assert jack in sess.dirty
assert jill not in sess.dirty
assert not sess.is_modified(john)
assert not sess.is_modified(jack)
def test_callable_bind(self):
Address, addresses, users, User = (
self.classes.Address,
self.tables.addresses,
self.tables.users,
self.classes.User,
)
mapper(
User,
users,
properties=dict(addresses=relationship(
mapper(Address, addresses),
lazy="select",
primaryjoin=and_(
users.c.id == addresses.c.user_id,
users.c.name == bindparam("name", callable_=lambda: "ed"),
),
)),
)
s = Session()
ed = s.query(User).filter_by(name="ed").one()
eq_(
ed.addresses,
[
Address(id=2, user_id=8),
Address(id=3, user_id=8),
Address(id=4, user_id=8),
],
)
fred = s.query(User).filter_by(name="fred").one()
eq_(fred.addresses, []) # fred is missing
def test_cast_type(self):
Json = self.classes.Json
s = Session(testing.db)
j = Json(json={"field": 10})
s.add(j)
s.commit()
jq = s.query(Json).filter(Json.int_field == 10).one()
eq_(j.id, jq.id)
jq = s.query(Json).filter(Json.text_field == "10").one()
eq_(j.id, jq.id)
jq = s.query(Json).filter(Json.json_field.astext == "10").one()
eq_(j.id, jq.id)
jq = s.query(Json).filter(Json.text_field == "wrong").first()
is_(jq, None)
j.json = {"field": True}
s.commit()
jq = s.query(Json).filter(Json.text_field == "true").one()
eq_(j.id, jq.id)
def test_join_w_subquery(self):
User = self.classes.User
Address = self.classes.Address
sess = Session()
q1 = sess.query(User).with_for_update().subquery()
sess.query(q1).join(Address).all()
sess.close()
def test_bundle_nesting_unions(self):
Data = self.classes.Data
sess = Session()
b1 = Bundle("b1", Data.d1, Bundle("b2", Data.d2, Data.d3))
q1 = (sess.query(b1).filter(b1.c.d1.between("d3d1", "d7d1")).filter(
b1.c.b2.c.d2.between("d4d2", "d5d2")))
q2 = (sess.query(b1).filter(b1.c.d1.between("d3d1", "d7d1")).filter(
b1.c.b2.c.d2.between("d5d2", "d6d2")))
eq_(
q1.union(q2).all(),
[
(("d4d1", ("d4d2", "d4d3")), ),
(("d5d1", ("d5d2", "d5d3")), ),
(("d6d1", ("d6d2", "d6d3")), ),
],
)
# naming structure is preserved
row = q1.union(q2).first()
eq_(row.b1.d1, "d4d1")
eq_(row.b1.b2.d2, "d4d2")
def test_partial_load_no_invoke_eagers(self):
# test issue #4199
self._fixture_from_geometry(
{
"a": {
"subclasses": {
"a1": {"polymorphic_load": "selectin"},
"a2": {"polymorphic_load": "selectin"},
}
}
}
)
a, a1, a2 = self.classes("a", "a1", "a2")
sess = Session()
a1_obj = a1()
a2_obj = a2()
sess.add_all([a1_obj, a2_obj])
del a2_obj
sess.flush()
sess.expire_all()
# _with_invoke_all_eagers(False), used by the lazy loader
# strategy, will cause one less state to be present such that
# the poly loader won't locate a state limited to the "a1" mapper,
# needs to test that it has states
sess.query(a)._with_invoke_all_eagers(False).all()
def test_update_preserve_parameter_order(self):
User = self.classes.User
session = Session()
# Do update using a tuple and check that order is preserved
q = session.query(User)
with mock.patch.object(q, "_execute_crud") as exec_:
q.filter(User.id == 15).update(
(("id", 123), ("name", "foob")),
update_args={"preserve_parameter_order": True},
)
cols = [
c.key for c in exec_.mock_calls[0][1][0]._parameter_ordering
]
eq_(["id", "name"], cols)
# Now invert the order and use a list instead, and check that order is
# also preserved
q = session.query(User)
with mock.patch.object(q, "_execute_crud") as exec_:
q.filter(User.id == 15).update(
[("name", "foob"), ("id", 123)],
update_args={"preserve_parameter_order": True},
)
cols = [
c.key for c in exec_.mock_calls[0][1][0]._parameter_ordering
]
eq_(["name", "id"], cols)
def test_defer_many_cols(self):
# with [ticket:2778], this goes from 50805 to 32817,
# as it should be fewer function calls than the baseline
A = self.classes.A
s = Session()
s.query(A).options(
*[defer(letter)
for letter in ["x", "y", "z", "p", "q", "r"]]).all()
def go():
session = Session(testing.db)
with session.transaction:
sc = SomeClass()
session.add(sc)
with session.begin_nested():
session.query(SomeClass).first()
def test_custom_bind(self):
Address, addresses, users, User = (
self.classes.Address,
self.tables.addresses,
self.tables.users,
self.classes.User,
)
mapper(
User,
users,
properties=dict(addresses=relationship(
mapper(Address, addresses),
lazy="select",
primaryjoin=and_(
users.c.id == addresses.c.user_id,
users.c.name == bindparam("name"),
),
)),
)
canary = mock.Mock()
class MyOption(MapperOption):
propagate_to_loaders = True
def __init__(self, crit):
self.crit = crit
def process_query_conditionally(self, query):
"""process query during a lazyload"""
canary()
query._params = query._params.union(dict(name=self.crit))
s = Session()
ed = s.query(User).options(MyOption("ed")).filter_by(name="ed").one()
eq_(
ed.addresses,
[
Address(id=2, user_id=8),
Address(id=3, user_id=8),
Address(id=4, user_id=8),
],
)
eq_(canary.mock_calls, [mock.call()])
fred = (s.query(User).options(
MyOption("ed")).filter_by(name="fred").one())
eq_(fred.addresses, []) # fred is missing
eq_(canary.mock_calls, [mock.call(), mock.call()])
# the lazy query was not cached; the option is re-applied to the
# Fred object due to populate_existing()
fred = (s.query(User).populate_existing().options(
MyOption("fred")).filter_by(name="fred").one())
eq_(fred.addresses, [Address(id=5, user_id=9)]) # fred is there
eq_(canary.mock_calls, [mock.call(), mock.call(), mock.call()])
def test_evaluate_hybrid_attr_indirect_w_update_expr(self):
Person = self.classes.Person
s = Session()
jill = s.query(Person).get(3)
s.query(Person).update({Person.uname: "moonbeam sunshine"},
synchronize_session="evaluate")
eq_(jill.uname, "moonbeam sunshine")
def test_fetch_hybrid_attr_w_update_expr(self):
Person = self.classes.Person
s = Session()
jill = s.query(Person).get(3)
s.query(Person).update({Person.name: "moonbeam sunshine"},
synchronize_session="fetch")
eq_(jill.name, "moonbeam sunshine")
def test_fetch_hybrid_attr_plain(self):
Person = self.classes.Person
s = Session()
jill = s.query(Person).get(3)
s.query(Person).update({Person.fname: "moonbeam"},
synchronize_session="fetch")
eq_(jill.fname, "moonbeam")
def test_evaluate_hybrid_attr_indirect(self):
Person = self.classes.Person
s = Session()
jill = s.query(Person).get(3)
s.query(Person).update({Person.fname2: "moonbeam"},
synchronize_session="evaluate")
eq_(jill.fname2, "moonbeam")
def go():
class T2(object):
pass
t2_mapper = mapper(T2, t2)
t1_mapper.add_property("bar", relationship(t2_mapper))
s1 = Session()
# this causes the path_registry to be invoked
s1.query(t1_mapper)._compile_context()
def test_update_against_table_col(self):
User, users = self.classes.User, self.tables.users
sess = Session()
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
eq_([john.age, jack.age, jill.age, jane.age], [25, 47, 29, 37])
sess.query(User).filter(User.age > 27).update(
{users.c.age_int: User.age - 10}, synchronize_session="evaluate")
eq_([john.age, jack.age, jill.age, jane.age], [25, 37, 19, 27])
def test_delete_with_eager_relationships(self):
Document = self.classes.Document
sess = Session()
sess.query(Document).filter(Document.user_id == 1).delete(
synchronize_session=False)
eq_(sess.query(Document.title).all(), list(zip(["baz"])))
def test_autoflush_before_fetch_update(self):
User = self.classes.User
sess = Session()
john = sess.query(User).filter_by(name="john").one()
john.name = "j2"
sess.query(User).filter_by(name="j2").update(
{"age": 42}, synchronize_session="fetch")
eq_(john.age, 42)
def test_fetch_before_delete(self):
User = self.classes.User
sess = Session()
john = sess.query(User).filter_by(name="john").one()
sess.expire(john, ["age"])
sess.query(User).filter_by(name="john").filter_by(age=25).delete(
synchronize_session="fetch")
assert john not in sess
def test_autoflush_before_fetch_delete(self):
User = self.classes.User
sess = Session()
john = sess.query(User).filter_by(name="john").one()
john.name = "j2"
sess.query(User).filter_by(name="j2").delete(
synchronize_session="fetch")
assert john not in sess
def test_evaluate_unmapped_col(self):
User = self.classes.User
s = Session()
jill = s.query(User).get(3)
s.query(User).update({column("name"): "moonbeam"},
synchronize_session="evaluate")
eq_(jill.name, "jill")
s.expire(jill)
eq_(jill.name, "moonbeam")
def test_delete_with_bindparams(self):
User = self.classes.User
sess = Session()
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
sess.query(User).filter(
text("name = :name")).params(name="john").delete("fetch")
assert john not in sess
eq_(sess.query(User).order_by(User.id).all(), [jack, jill, jane])
def test_update_against_metadata(self):
User, users = self.classes.User, self.tables.users
sess = Session()
sess.query(users).update({users.c.age_int: 29},
synchronize_session=False)
eq_(
sess.query(User.age).order_by(User.id).all(),
list(zip([29, 29, 29, 29])),
)
def test_update_without_load(self):
User = self.classes.User
sess = Session()
sess.query(User).filter(User.id == 3).update(
{"age": 44}, synchronize_session="fetch")
eq_(
sess.query(User.age).order_by(User.id).all(),
list(zip([25, 47, 44, 37])),
)
def test_delete_all(self):
User = self.classes.User
sess = Session()
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
sess.query(User).delete(synchronize_session="evaluate")
assert not (john in sess or jack in sess or jill in sess
or jane in sess)
eq_(sess.query(User).count(), 0)
def test_evaluate_synonym_attr(self):
class Foo(object):
pass
mapper(Foo, self.tables.users, properties={"uname": synonym("name")})
s = Session()
jill = s.query(Foo).get(3)
s.query(Foo).update({Foo.uname: "moonbeam"},
synchronize_session="evaluate")
eq_(jill.uname, "moonbeam")
def test_delete_rollback_with_fetch(self):
User = self.classes.User
sess = Session()
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
sess.query(User).filter(
or_(User.name == "john",
User.name == "jill")).delete(synchronize_session="fetch")
assert john not in sess and jill not in sess
sess.rollback()
assert john in sess and jill in sess
