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