def test_bind_through_execute(self, statement, expected_get_bind_args, expected_engine_name): users, Address, addresses, User = ( self.tables.users, self.classes.Address, self.tables.addresses, self.classes.User, ) mapper(User, users, properties={"addresses": relationship(Address)}) mapper(Address, addresses) e1 = engines.testing_engine() e2 = engines.testing_engine() e3 = engines.testing_engine() canary = mock.Mock() class GetBindSession(Session): def _connection_for_bind(self, bind, **kw): canary._connection_for_bind(bind, **kw) return mock.Mock() def get_bind(self, **kw): canary.get_bind(**kw) return Session.get_bind(self, **kw) sess = GetBindSession(e3, future=True) sess.bind_mapper(User, e1) sess.bind_mapper(Address, e2) lambda_args = dict( session=sess, User=User, Address=Address, e1=e1, e2=e2, e3=e3, addresses=addresses, ) statement = testing.resolve_lambda(statement, **lambda_args) expected_get_bind_args = testing.resolve_lambda( expected_get_bind_args, **lambda_args) engine = {"e1": e1, "e2": e2, "e3": e3}[expected_engine_name] with mock.patch( "sqlalchemy.orm.context.ORMCompileState.orm_setup_cursor_result" ): sess.execute(statement) eq_( canary.mock_calls, [ mock.call.get_bind(**expected_get_bind_args), mock.call._connection_for_bind(engine, close_with_result=True), ], ) sess.close()
def test_with_polymorphic_join_exec_contains_eager_two( self, contains_eager_option ): sess = Session() wp = with_polymorphic(Person, [Engineer, Manager], aliased=True) contains_eager_option = testing.resolve_lambda( contains_eager_option, Company=Company, wp=wp ) q = ( sess.query(Company) .join(Company.employees.of_type(wp)) .order_by(Company.company_id, wp.person_id) .options(contains_eager_option) ) def go(): eq_(q.all(), [self.c1, self.c2]) self.assert_sql_count(testing.db, go, 1) self.assert_compile( q, self._test_with_polymorphic_join_exec_contains_eager_two_result(), )
def test_get_bind(self, testcase, expected): users, Address, addresses, User = ( self.tables.users, self.classes.Address, self.tables.addresses, self.classes.User, ) mapper(User, users, properties={"addresses": relationship(Address)}) mapper(Address, addresses) e1 = engines.testing_engine() e2 = engines.testing_engine() e3 = engines.testing_engine() testcase = testing.resolve_lambda( testcase, User=User, Address=Address, e1=e1, e2=e2, e3=e3, addresses=addresses, ) sess = Session(e3) sess.bind_mapper(User, e1) sess.bind_mapper(Address, e2) engine = {"e1": e1, "e2": e2, "e3": e3}[expected] conn = sess.connection(**testcase) is_(conn.engine, engine) sess.close()
def test_when_dicts(self, test_case, expected): t = table("test", column("col1")) when_dict, value, else_ = testing.resolve_lambda(test_case, t=t) self.assert_compile( case(when_dict, value=value, else_=else_), expected )
def test_unbound_options(self, test_case): sess, User, Address, Dingaling = self._option_test_fixture() opt = testing.resolve_lambda(test_case, User=User, Address=Address) opt2 = pickle.loads(pickle.dumps(opt)) eq_(opt.path, opt2.path) u1 = sess.query(User).options(opt).first() pickle.loads(pickle.dumps(u1))
def test_join_entity_arg(self, plain_fixture, test_case): User, Address = plain_fixture s = Session(testing.db, future=True) stmt = testing.resolve_lambda(test_case, **locals()) self.assert_compile( stmt, "SELECT users.id AS users_id, users.name AS users_name " "FROM users JOIN addresses ON users.id = addresses.user_id", )
def test_string_ops(self, expr): User = self.classes.User test_expr = testing.resolve_lambda(expr, User=User) eval_eq( test_expr, testcases=[ (User(name="named"), True), (User(name="othername"), False), ], )
def test_strict_binds(self, expr, compiled, kw): """test the 'strict' compiler binds.""" from sqlalchemy.dialects.mssql.base import MSSQLStrictCompiler mxodbc_dialect = mxodbc.dialect() mxodbc_dialect.statement_compiler = MSSQLStrictCompiler t = table("sometable", column("foo")) expr = testing.resolve_lambda(expr, t=t) self.assert_compile(expr, compiled, dialect=mxodbc_dialect, **kw)
def test_bound_options(self, test_case): sess, User, Address, Dingaling = self._option_test_fixture() opt = testing.resolve_lambda(test_case, User=User, Address=Address) opt2 = pickle.loads(pickle.dumps(opt)) eq_(opt.path, opt2.path) for v1, v2 in zip(opt.context, opt2.context): eq_(v1.local_opts, v2.local_opts) u1 = sess.query(User).options(opt).first() pickle.loads(pickle.dumps(u1))
def test_when_dicts(self, test_case, expected): t = table("test", column("col1")) whens, value, else_ = testing.resolve_lambda(test_case, t=t) def _case_args(whens, value=None, else_=None): kw = {} if value is not None: kw["value"] = value if else_ is not None: kw["else_"] = else_ return case(whens, **kw) # note: 1.3 also does not allow this form # case([whens], **kw) self.assert_compile( _case_args(whens=whens, value=value, else_=else_), expected, )
def test_no_star_orm_combinations(self, exprtype, testcase): """test for #8235""" User = self.classes.User if exprtype == "plain": star = "*" elif exprtype == "text": star = text("*") elif exprtype == "literal_column": star = literal_column("*") else: assert False args = testing.resolve_lambda(testcase, User=User, star=star) stmt = select(*args).select_from(User) s = fixture_session() with expect_raises_message( exc.CompileError, r"Can't generate ORM query that includes multiple expressions " r"at the same time as '\*';", ): s.execute(stmt)