for this :class:`.Sequence` within any SQL expression.
"""
- return util.preloaded.sql_functions.func.next_value(
- self, bind=self.bind
- )
+ if self.bind:
+ return util.preloaded.sql_functions.func.next_value(
+ self, bind=self.bind
+ )
+ else:
+ return util.preloaded.sql_functions.func.next_value(self)
def _set_parent(self, column, **kw):
super(Sequence, self)._set_parent(column)
cls.bind = cls.setup_bind()
cls._tables_metadata = sa.MetaData()
- cls._tables_metadata.bind = cls.bind
@classmethod
def _setup_once_inserts(cls):
return sa.orm.Session(config.db, **kw)
+def fixture_session(**kw):
+ kw.setdefault("autoflush", True)
+ kw.setdefault("expire_on_commit", True)
+ return sa.orm.Session(config.db, **kw)
+
+
class ORMTest(_ORMTest, TestBase):
pass
from sqlalchemy import bindparam
from sqlalchemy import Column
from sqlalchemy import Integer
+from sqlalchemy import select
from sqlalchemy import Sequence
from sqlalchemy import String
from sqlalchemy import Table
[{"name": n, "department": d} for n, d in data],
)
- def test_basic(self):
+ def test_basic(self, connection):
employees_table = self.tables.employees
- s = employees_table.select()
- r = s.execute().fetchall()
+ s = select(
+ employees_table.c.name, employees_table.c.department
+ ).order_by(employees_table.c.employee_id)
+ rows = connection.execute(s).fetchall()
- assert len(r) == len(self.data)
+ eq_(rows, self.data)
def test_update_rowcount1(self, connection):
employees_table = self.tables.employees
r"The Connection.connect\(\) method is considered legacy",
# r".*DefaultGenerator.execute\(\)",
#
- # bound metadaa
- #
- r"The ``bind`` argument for schema methods that invoke SQL ",
- r"The Function.bind argument",
- r"The select.bind argument",
#
# result sets
#
from sqlalchemy.testing import engines
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from sqlalchemy.testing.util import gc_collect
@testing.emits_warning("Compiled statement cache for.*")
def test_many_updates(self):
- metadata = MetaData(self.engine)
+ metadata = MetaData()
wide_table = Table(
"t",
mapper(Wide, wide_table, _compiled_cache_size=10)
- metadata.create_all()
- with Session() as session:
+ metadata.create_all(self.engine)
+ with Session(self.engine) as session:
w1 = Wide()
session.add(w1)
session.commit()
@profile_memory()
def go():
- with Session() as session:
+ with Session(self.engine) as session:
w1 = session.query(Wide).first()
x = counter[0]
dec = 10
try:
go()
finally:
- metadata.drop_all()
+ metadata.drop_all(self.engine)
@testing.requires.savepoints
@testing.provide_metadata
t2_mapper = mapper(T2, t2)
t1_mapper.add_property("bar", relationship(t2_mapper))
- s1 = Session()
+ s1 = fixture_session()
# this causes the path_registry to be invoked
s1.query(t1_mapper)._compile_context()
User, Address = self.classes("User", "Address")
configure_mappers()
- s = Session()
+ s = fixture_session()
@assert_cycles()
def go():
User, Address = self.classes("User", "Address")
configure_mappers()
- s = Session()
+ s = fixture_session()
@assert_cycles()
def go():
User, Address = self.classes("User", "Address")
configure_mappers()
- s = Session()
+ s = fixture_session()
u1 = aliased(User)
User, Address = self.classes("User", "Address")
configure_mappers()
- s = Session()
+ s = fixture_session()
def generate():
objects = s.query(User).filter(User.id == 7).all()
def test_orm_objects_from_query_w_selectinload(self):
User, Address = self.classes("User", "Address")
- s = Session()
+ s = fixture_session()
def generate():
objects = s.query(User).options(selectinload(User.addresses)).all()
def test_orm_objects_from_query_w_joinedload(self):
User, Address = self.classes("User", "Address")
- s = Session()
+ s = fixture_session()
def generate():
objects = s.query(User).options(joinedload(User.addresses)).all()
def test_query_filtered(self):
User, Address = self.classes("User", "Address")
- s = Session()
+ s = fixture_session()
@assert_cycles()
def go():
def test_query_joins(self):
User, Address = self.classes("User", "Address")
- s = Session()
+ s = fixture_session()
# cycles here are due to ClauseElement._cloned_set, others
# as of cache key
def test_query_joinedload(self):
User, Address = self.classes("User", "Address")
- s = Session()
+ s = fixture_session()
def generate():
s.query(User).options(joinedload(User.addresses)).all()
@assert_cycles()
def go():
- str(users.join(addresses))
+ str(users.join(addresses).compile(testing.db))
go()
@assert_cycles(7)
def go():
s = select(users).select_from(users.join(addresses))
- state = s._compile_state_factory(s, s.compile())
+ state = s._compile_state_factory(s, s.compile(testing.db))
state.froms
go()
@assert_cycles()
def go():
- str(orm_join(User, Address, User.addresses))
+ str(orm_join(User, Address, User.addresses).compile(testing.db))
go()
User, Address = self.classes("User", "Address")
configure_mappers()
- s = Session()
+ s = fixture_session()
@assert_cycles()
def go():
User, Address = self.classes("User", "Address")
configure_mappers()
- s = Session()
+ s = fixture_session()
@assert_cycles()
def go():
User, Address = self.classes("User", "Address")
configure_mappers()
- s = Session()
+ s = fixture_session()
stmt = s.query(User).join(User.addresses).statement
User, Address = self.classes("User", "Address")
configure_mappers()
- s = Session()
+ s = fixture_session()
stmt = s.query(User).join(User.addresses).statement
User, Address = self.classes("User", "Address")
configure_mappers()
- s = Session()
+ s = fixture_session()
stmt = s.query(User).join(User.addresses).statement
User, Address = self.classes("User", "Address")
configure_mappers()
- s = Session()
+ s = fixture_session()
stmt = s.query(User).join(User.addresses).statement
User, Address = self.classes("User", "Address")
configure_mappers()
- s = Session()
+ s = fixture_session()
stmt = s.query(User).join(User.addresses).statement
from sqlalchemy.testing import config
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import profiling
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
def test_merge_no_load(self):
Parent = self.classes.Parent
- sess = sessionmaker()()
- sess2 = sessionmaker()()
+ sess = fixture_session()
+ sess2 = fixture_session()
p1 = sess.query(Parent).get(1)
p1.children
def test_merge_load(self):
Parent = self.classes.Parent
- sess = sessionmaker()()
- sess2 = sessionmaker()()
+ sess = fixture_session()
+ sess2 = fixture_session()
p1 = sess.query(Parent).get(1)
p1.children
def test_many_to_one_load_no_identity(self):
Parent = self.classes.Parent
- sess = Session()
+ sess = fixture_session()
parents = sess.query(Parent).all()
@profiling.function_call_count(variance=0.2)
def test_many_to_one_load_identity(self):
Parent, Child = self.classes.Parent, self.classes.Child
- sess = Session()
+ sess = fixture_session()
parents = sess.query(Parent).all()
children = sess.query(Child).all()
children # strong reference
self.classes.C,
self.classes.D,
)
- s = Session()
+ s = fixture_session()
for a in [
A(
id=i,
def test_baseline(self):
# as of [ticket:2778], this is at 39025
A = self.classes.A
- s = Session()
+ s = fixture_session()
s.query(A).all()
@profiling.function_call_count(variance=0.10)
# 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 = fixture_session()
s.query(A).options(
*[defer(letter) for letter in ["x", "y", "z", "p", "q", "r"]]
).all()
Parent(children=[Child() for j in range(10)]) for i in range(10)
]
- sess = Session()
+ sess = fixture_session()
sess.add_all(obj)
sess.flush()
def _fixture(self):
Parent = self.classes.Parent
- sess = Session()
+ sess = fixture_session()
sess.add_all(
[
Parent(data1="d1", data2="d2", data3="d3", data4="d4")
def test_query_cols(self):
Parent = self.classes.Parent
self._fixture()
- sess = Session()
+ sess = fixture_session()
# warm up cache
for attr in [Parent.data1, Parent.data2, Parent.data3, Parent.data4]:
def test_round_trip_results(self):
A, B, C = self.classes("A", "B", "C")
- sess = Session()
+ sess = fixture_session()
q = sess.query(A).options(selectinload(A.bs).selectinload(B.cs))
def test_build_query(self):
A, B, C, D, E, F, G = self.classes("A", "B", "C", "D", "E", "F", "G")
- sess = Session()
+ sess = fixture_session()
@profiling.function_call_count()
def go():
base.joinedload(B.fs),
]
- q = Session().query(A)
+ q = fixture_session().query(A)
context = q._compile_state()
base.joinedload(B.fs),
]
- q = Session().query(A)
+ q = fixture_session().query(A)
context = q._compile_state()
def test_no_bundle(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
q = s.query(A).select_from(A)
def test_no_entity_wo_annotations(self):
A = self.classes.A
a = self.tables.a
- s = Session()
+ s = fixture_session()
q = s.query(a.c.data).select_from(A)
def test_no_entity_w_annotations(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
q = s.query(A.data).select_from(A)
@profiling.function_call_count(warmup=1)
def test_entity_w_annotations(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
q = s.query(A, A.data).select_from(A)
@profiling.function_call_count(warmup=1)
def test_entity_wo_annotations(self):
A = self.classes.A
a = self.tables.a
- s = Session()
+ s = fixture_session()
q = s.query(A, a.c.data).select_from(A)
@profiling.function_call_count(warmup=1)
def test_no_bundle_wo_annotations(self):
A = self.classes.A
a = self.tables.a
- s = Session()
+ s = fixture_session()
q = s.query(a.c.data, A).select_from(A)
@profiling.function_call_count(warmup=1)
def test_no_bundle_w_annotations(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
q = s.query(A.data, A).select_from(A)
@profiling.function_call_count(warmup=1)
def test_bundle_wo_annotation(self):
A = self.classes.A
a = self.tables.a
- s = Session()
+ s = fixture_session()
q = s.query(Bundle("ASdf", a.c.data), A).select_from(A)
@profiling.function_call_count(warmup=1)
def test_bundle_w_annotation(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
q = s.query(Bundle("ASdf", A.data), A).select_from(A)
@profiling.function_call_count(warmup=1)
# seem to be handling this for a profile that skips
result.close()
- def test_contains_doesnt_compile(self):
+ def test_contains_doesnt_compile(self, connection):
t, t2 = self.tables("table1", "table2")
- row = t.select().execute().first()
+ row = connection.execute(t.select()).first()
c1 = Column("some column", Integer) + Column(
"some other column", Integer
)
)
).fetchall()
eq_([5], [r.id for r in results1])
- results2 = (
- matchtable.select()
- .where(matchtable.c.title.match("python AND nutshell"))
- .execute()
- .fetchall()
- )
+ results2 = connection.execute(
+ matchtable.select().where(
+ matchtable.c.title.match("python AND nutshell")
+ )
+ ).fetchall()
eq_([5], [r.id for r in results2])
def test_match_across_joins(self, connection):
self.data,
)
- def test_large_stream(self):
+ def test_large_stream(self, connection):
binary_table = self.tables.binary_table
- result = (
- binary_table.select()
- .order_by(binary_table.c.id)
- .execute()
- .fetchall()
- )
+ result = connection.execute(
+ binary_table.select().order_by(binary_table.c.id)
+ ).fetchall()
eq_(result, [(i, self.stream) for i in range(1, 11)])
def test_large_stream_single_arraysize(self):
binary_table = self.tables.binary_table
eng = testing_engine(options={"arraysize": 1})
- result = eng.execute(
- binary_table.select().order_by(binary_table.c.id)
- ).fetchall()
- eq_(result, [(i, self.stream) for i in range(1, 11)])
+ with eng.connect() as conn:
+ result = conn.execute(
+ binary_table.select().order_by(binary_table.c.id)
+ ).fetchall()
+ eq_(result, [(i, self.stream) for i in range(1, 11)])
class EuroNumericTest(fixtures.TestBase):
metadata = MetaData()
Table("test_table", metadata, Column("foo", Integer))
for meth in [metadata.create_all, metadata.drop_all]:
- assert_raises_message(
- exc.UnboundExecutionError,
- "MetaData object is not bound to an Engine or Connection.",
- meth,
- )
+ with testing.expect_deprecated_20(
+ "The ``bind`` argument for schema methods that invoke SQL"
+ ):
+ assert_raises_message(
+ exc.UnboundExecutionError,
+ "MetaData object is not bound to an Engine or Connection.",
+ meth,
+ )
def test_bind_create_drop_err_table(self):
metadata = MetaData()
table = Table("test_table", metadata, Column("foo", Integer))
for meth in [table.create, table.drop]:
- assert_raises_message(
- exc.UnboundExecutionError,
- (
- "Table object 'test_table' is not bound to an Engine or "
- "Connection."
- ),
- meth,
- )
+ with testing.expect_deprecated_20(
+ "The ``bind`` argument for schema methods that invoke SQL"
+ ):
+ assert_raises_message(
+ exc.UnboundExecutionError,
+ (
+ "Table object 'test_table' is not bound to an "
+ "Engine or Connection."
+ ),
+ meth,
+ )
def test_bind_create_drop_bound(self):
table = Table("test_table", metadata, Column("foo", Integer))
metadata.bind = bind
assert metadata.bind is table.bind is bind
- metadata.create_all()
+ with testing.expect_deprecated_20(
+ "The ``bind`` argument for schema methods that invoke SQL"
+ ):
+ metadata.create_all()
with testing.expect_deprecated(
r"The Table.exists\(\) method is deprecated and will "
"be removed in a future release."
):
assert table.exists()
- metadata.drop_all()
- table.create()
- table.drop()
+ with testing.expect_deprecated_20(
+ "The ``bind`` argument for schema methods that invoke SQL"
+ ):
+ metadata.drop_all()
+ with testing.expect_deprecated_20(
+ "The ``bind`` argument for schema methods that invoke SQL"
+ ):
+ table.create()
+ with testing.expect_deprecated_20(
+ "The ``bind`` argument for schema methods that invoke SQL"
+ ):
+ table.drop()
with testing.expect_deprecated(
r"The Table.exists\(\) method is deprecated and will "
"be removed in a future release."
metadata.bind = bind
assert metadata.bind is table.bind is bind
- metadata.create_all()
+ with testing.expect_deprecated_20(
+ "The ``bind`` argument for schema methods that invoke SQL"
+ ):
+ metadata.create_all()
with testing.expect_deprecated(
r"The Table.exists\(\) method is deprecated and will "
"be removed in a future release."
):
assert table.exists()
- metadata.drop_all()
- table.create()
- table.drop()
+ with testing.expect_deprecated_20(
+ "The ``bind`` argument for schema methods that invoke SQL"
+ ):
+ metadata.drop_all()
+ with testing.expect_deprecated_20(
+ "The ``bind`` argument for schema methods that invoke SQL"
+ ):
+ table.create()
+ with testing.expect_deprecated_20(
+ "The ``bind`` argument for schema methods that invoke SQL"
+ ):
+ table.drop()
with testing.expect_deprecated(
r"The Table.exists\(\) method is deprecated and will "
"be removed in a future release."
"test_table", metadata, Column("foo", Integer)
)
assert metadata.bind is table.bind is bind
- metadata.create_all()
+ with testing.expect_deprecated_20(
+ "The ``bind`` argument for schema methods "
+ "that invoke SQL"
+ ):
+ metadata.create_all()
is_true(inspect(bind).has_table(table.name))
- metadata.drop_all()
- table.create()
- table.drop()
+ with testing.expect_deprecated_20(
+ "The ``bind`` argument for schema methods "
+ "that invoke SQL"
+ ):
+ metadata.drop_all()
+ with testing.expect_deprecated_20(
+ "The ``bind`` argument for schema methods "
+ "that invoke SQL"
+ ):
+ table.create()
+ with testing.expect_deprecated_20(
+ "The ``bind`` argument for schema methods "
+ "that invoke SQL"
+ ):
+ table.drop()
is_false(inspect(bind).has_table(table.name))
finally:
if isinstance(bind, engine.Connection):
def test_cursor_iterable(self):
conn = testing.db.raw_connection()
cursor = conn.cursor()
- cursor.execute(str(select([1], bind=testing.db)))
+ cursor.execute(str(select(1).compile(testing.db)))
expected = [(1,)]
for row in cursor:
eq_(row, expected.pop(0))
from sqlalchemy.orm import clear_mappers
from sqlalchemy.orm import close_all_sessions
from sqlalchemy.orm import configure_mappers
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import exc as orm_exc
from sqlalchemy.orm import polymorphic_union
from sqlalchemy.orm import relationship
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import mock
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from test.orm.test_events import _RemoveListeners
def teardown(self):
close_all_sessions()
clear_mappers()
- Base.metadata.drop_all()
+ Base.metadata.drop_all(testing.db)
class ConcreteInhTest(
polymorphic=True,
explicit_type=False,
):
- Base.metadata.create_all()
- sess = create_session()
+ Base.metadata.create_all(testing.db)
+ sess = fixture_session()
e1 = Engineer(name="dilbert", primary_language="java")
e2 = Engineer(name="wally", primary_language="c++")
m1 = Manager(name="dogbert", golf_swing="fore!")
"concrete": True,
}
- Base.metadata.create_all()
+ Base.metadata.create_all(testing.db)
sess = Session()
sess.add(Engineer(name="d"))
sess.commit()
c_data = Column(String(50))
__mapper_args__ = {"polymorphic_identity": "c", "concrete": True}
- Base.metadata.create_all()
+ Base.metadata.create_all(testing.db)
sess = Session()
sess.add_all(
[
from sqlalchemy.orm import collections
from sqlalchemy.orm import composite
from sqlalchemy.orm import configure_mappers
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import is_
from sqlalchemy.testing.assertions import expect_warnings
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.mock import call
from sqlalchemy.testing.mock import Mock
from sqlalchemy.testing.schema import Column
metadata.create_all(testing.db)
self.metadata = metadata
- self.session = create_session(testing.db)
+ self.session = fixture_session()
self.Parent, self.Child = Parent, Child
def teardown(self):
metadata.create_all(testing.db)
self.metadata = metadata
- self.session = create_session(testing.db)
+ self.session = fixture_session()
self.Parent, self.Child = Parent, Child
def test_sequence_ops(self):
mapper(Child, children_table)
metadata.create_all(testing.db)
- session = create_session(testing.db)
+ session = fixture_session()
def roundtrip(obj):
if obj not in session:
metadata.create_all(testing.db)
self.metadata = metadata
- self.session = create_session(testing.db)
+ self.session = fixture_session()
self.Parent, self.Child = Parent, Child
self.table = parents_table
properties=dict(children=relationship(Child)),
)
mapper(Child, self.tables.children)
- session = create_session()
+ session = fixture_session()
def add_child(parent_name, child_name):
parent = session.query(Parent).filter_by(name=parent_name).one()
def test_comparator_ambiguous(self):
A, B = self.classes("A", "B")
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(A).filter(A.b_data.any()),
"SELECT a.id AS a_id FROM a WHERE EXISTS "
def test_explicit_expr(self):
(C,) = self.classes("C")
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(C).filter_by(attr=5),
"SELECT c.id AS c_id, c.b_id AS c_b_id FROM c WHERE EXISTS "
from sqlalchemy.testing import is_
from sqlalchemy.testing import is_not
from sqlalchemy.testing import mock
+from sqlalchemy.testing.fixtures import fixture_session
from test.orm import _fixtures
def test_initial_key(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
def l1():
return session.query(User)
def test_inplace_add(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
def l1():
return session.query(User)
def test_inplace_add_operator(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
def l1():
return session.query(User)
def test_chained_add(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
def l1():
return session.query(User)
def test_chained_add_operator(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
def l1():
return session.query(User)
bq = self.bakery(lambda s: s.query(User))
bq += lambda q: q.filter(User.name == "asdf")
- eq_(bq(Session()).first(), None)
+ eq_(bq(fixture_session()).first(), None)
def test_first_multiple_result(self):
User = self.classes.User
bq = self.bakery(lambda s: s.query(User.id))
bq += lambda q: q.filter(User.name.like("%ed%")).order_by(User.id)
- eq_(bq(Session()).first(), (8,))
+ eq_(bq(fixture_session()).first(), (8,))
def test_one_or_none_no_result(self):
User = self.classes.User
bq = self.bakery(lambda s: s.query(User))
bq += lambda q: q.filter(User.name == "asdf")
- eq_(bq(Session()).one_or_none(), None)
+ eq_(bq(fixture_session()).one_or_none(), None)
def test_one_or_none_result(self):
User = self.classes.User
bq = self.bakery(lambda s: s.query(User))
bq += lambda q: q.filter(User.name == "ed")
- u1 = bq(Session()).one_or_none()
+ u1 = bq(fixture_session()).one_or_none()
eq_(u1.name, "ed")
def test_one_or_none_multiple_result(self):
assert_raises_message(
orm_exc.MultipleResultsFound,
"Multiple rows were found when one or none was required",
- bq(Session()).one_or_none,
+ bq(fixture_session()).one_or_none,
)
def test_one_no_result(self):
assert_raises_message(
orm_exc.NoResultFound,
"No row was found when one was required",
- bq(Session()).one,
+ bq(fixture_session()).one,
)
def test_one_result(self):
bq = self.bakery(lambda s: s.query(User))
bq += lambda q: q.filter(User.name == "ed")
- u1 = bq(Session()).one()
+ u1 = bq(fixture_session()).one()
eq_(u1.name, "ed")
def test_one_multiple_result(self):
assert_raises_message(
orm_exc.MultipleResultsFound,
"Multiple rows were found when exactly one was required",
- bq(Session()).one,
+ bq(fixture_session()).one,
)
def test_get(self):
bq = self.bakery(lambda s: s.query(User))
- sess = Session()
+ sess = fixture_session()
def go():
u1 = bq(sess).get(7)
bq = self.bakery(lambda s: s.query(User.id))
- sess = Session()
+ sess = fixture_session()
bq += lambda q: q.filter(User.id == 7)
bq = self.bakery(lambda s: s.query(User))
- sess = Session()
+ sess = fixture_session()
eq_(bq(sess).count(), 4)
bq = self.bakery(lambda s: s.query(User))
- sess = Session()
+ sess = fixture_session()
eq_(bq(sess).count(), 4)
bq = self.bakery(lambda s: s.query(AddressUser))
- sess = Session()
+ sess = fixture_session()
def go():
u1 = bq(sess).get((10, None))
bq = self.bakery(lambda s: s.query(User))
for i in range(5):
- sess = Session()
+ sess = fixture_session()
u1 = bq(sess).get(7)
eq_(u1.name, "jack")
sess.close()
del inspect(User).__dict__["_get_clause"]
for i in range(5):
- sess = Session()
+ sess = fixture_session()
u1 = bq(sess).get(7)
eq_(u1.name, "jack")
sess.close()
bq2 = self.bakery(fn, 8)
for i in range(3):
- session = Session(autocommit=True)
+ session = fixture_session()
eq_(bq1(session).all(), [(7,)])
eq_(bq2(session).all(), [(8,)])
)
for i in range(3):
- session = Session(autocommit=True)
+ session = fixture_session()
eq_(
bq(session).all(),
[(7, "jack"), (8, "ed"), (9, "fred"), (10, "chuck")],
)
bq += lambda q: q.limit(bindparam("limit")).offset(bindparam("offset"))
- session = Session(autocommit=True)
+ session = fixture_session()
for i in range(4):
for limit, offset, exp in [
bq += fn2
- sess = Session(autocommit=True, enable_baked_queries=False)
+ sess = fixture_session(autocommit=True, enable_baked_queries=False)
eq_(bq.add_criteria(fn3)(sess).params(id=7).all(), [(7, "jack")])
eq_(
bq += fn2
- sess = Session(autocommit=True)
+ sess = fixture_session()
eq_(
bq.spoil(full=True).add_criteria(fn3)(sess).params(id=7).all(),
[(7, "jack")],
bq += fn2
- sess = Session(autocommit=True)
+ sess = fixture_session()
eq_(
bq.spoil().add_criteria(fn3)(sess).params(id=7).all(),
[(7, "jack")],
bq += lambda q: q._from_self().with_entities(func.count(User.id))
for i in range(3):
- session = Session(autocommit=True)
+ session = fixture_session()
eq_(bq(session).all(), [(4,)])
def test_conditional_step(self):
bq += lambda q: q._from_self().with_entities(
func.count(User.id)
)
- sess = Session(autocommit=True)
+ sess = fixture_session()
result = bq(sess).all()
if cond4:
if cond1:
if cond1
else (lambda q: q.filter(User.name == "jack"))
) # noqa
- sess = Session(autocommit=True)
+ sess = fixture_session()
result = bq(sess).all()
if cond1:
main_bq += lambda q: q.filter(sub_bq.to_query(q).exists())
main_bq += lambda q: q.order_by(Address.id)
- sess = Session()
+ sess = fixture_session()
result = main_bq(sess).all()
eq_(result, [(2,), (3,), (4,)])
)
main_bq += lambda q: q.order_by(Address.id)
- sess = Session()
+ sess = fixture_session()
result = main_bq(sess).all()
eq_(result, [(2, "ed"), (3, "ed"), (4, "ed")])
print("HI----")
bq = base_bq._clone()
- sess = Session()
+ sess = fixture_session()
if cond1:
bq += lambda q: q.filter(User.name == "jack")
bq += lambda q: q.options(subqueryload(User.addresses))
bq += lambda q: q.order_by(User.id)
bq += lambda q: q.filter(User.name == bindparam("name"))
- sess = Session()
+ sess = fixture_session()
def set_params(q):
return q.params(name="jack")
bq += lambda q: q.options(subqueryload(User.addresses))
bq += lambda q: q.order_by(User.id)
bq += lambda q: q.filter(User.name == bindparam("name"))
- sess = Session()
+ sess = fixture_session()
def set_params(q):
return q.params(name="jack")
cache[cache_key] = retval = createfunc().freeze()
return retval()
- s1 = Session(query_cls=CachingQuery)
+ s1 = fixture_session(query_cls=CachingQuery)
@event.listens_for(s1, "do_orm_execute", retval=True)
def do_orm_execute(orm_context):
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import is_
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
def test_query(self):
A = self._fixture()
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(A.value), "SELECT a.value AS a_value FROM a"
)
def test_aliased_query(self):
A = self._fixture()
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(aliased(A).value),
"SELECT a_1.value AS a_1_value FROM a AS a_1",
def test_aliased_filter(self):
A = self._fixture()
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(aliased(A)).filter_by(value="foo"),
"SELECT a_1.value AS a_1_value, a_1.id AS a_1_id "
def test_any(self):
A, B = self._relationship_fixture()
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(B).filter(B.as_.any(value=5)),
"SELECT b.id AS b_id FROM b WHERE EXISTS "
def test_query(self):
A = self._fixture()
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(A).filter_by(value="foo"),
"SELECT a.value AS a_value, a.id AS a_id "
def test_aliased_query(self):
A = self._fixture()
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(aliased(A)).filter_by(value="foo"),
"SELECT a_1.value AS a_1_value, a_1.id AS a_1_id "
def test_query(self):
A = self._fixture()
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(A).filter(A.value(5) == "foo"),
"SELECT a.value AS a_value, a.id AS a_id "
def test_aliased_query(self):
A = self._fixture()
- sess = Session()
+ sess = fixture_session()
a1 = aliased(A)
self.assert_compile(
sess.query(a1).filter(a1.value(5) == "foo"),
def test_query_col(self):
A = self._fixture()
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(A.value(5)),
"SELECT foo(a.value, :foo_1) + :foo_2 AS anon_1 FROM a",
def test_aliased_query_col(self):
A = self._fixture()
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(aliased(A).value(5)),
"SELECT foo(a_1.value, :foo_1) + :foo_2 AS anon_1 FROM a AS a_1",
def test_evaluate_hybrid_attr_indirect(self):
Person = self.classes.Person
- s = Session()
+ s = fixture_session()
jill = s.query(Person).get(3)
s.query(Person).update(
def test_evaluate_hybrid_attr_plain(self):
Person = self.classes.Person
- s = Session()
+ s = fixture_session()
jill = s.query(Person).get(3)
s.query(Person).update(
def test_fetch_hybrid_attr_indirect(self):
Person = self.classes.Person
- s = Session()
+ s = fixture_session()
jill = s.query(Person).get(3)
s.query(Person).update(
def test_fetch_hybrid_attr_plain(self):
Person = self.classes.Person
- s = Session()
+ s = fixture_session()
jill = s.query(Person).get(3)
s.query(Person).update(
def test_evaluate_hybrid_attr_w_update_expr(self):
Person = self.classes.Person
- s = Session()
+ s = fixture_session()
jill = s.query(Person).get(3)
s.query(Person).update(
def test_fetch_hybrid_attr_w_update_expr(self):
Person = self.classes.Person
- s = Session()
+ s = fixture_session()
jill = s.query(Person).get(3)
s.query(Person).update(
def test_evaluate_hybrid_attr_indirect_w_update_expr(self):
Person = self.classes.Person
- s = Session()
+ s = fixture_session()
jill = s.query(Person).get(3)
s.query(Person).update(
def test_query_one(self):
BankAccount, Amount = self.BankAccount, self.Amount
- session = Session()
+ session = fixture_session()
query = session.query(BankAccount).filter(
BankAccount.balance == Amount(10000, "cad")
def test_query_two(self):
BankAccount, Amount = self.BankAccount, self.Amount
- session = Session()
+ session = fixture_session()
# alternatively we can do the calc on the DB side.
query = (
def test_query_three(self):
BankAccount = self.BankAccount
- session = Session()
+ session = fixture_session()
query = session.query(BankAccount).filter(
BankAccount.balance.as_currency("cad")
def test_query_four(self):
BankAccount = self.BankAccount
- session = Session()
+ session = fixture_session()
# 4c. query all amounts, converting to "CAD" on the DB side
query = session.query(BankAccount.balance.as_currency("cad").amount)
def test_query_five(self):
BankAccount = self.BankAccount
- session = Session()
+ session = fixture_session()
# 4d. average balance in EUR
query = session.query(func.avg(BankAccount.balance.as_currency("eur")))
from sqlalchemy.orm import column_property
from sqlalchemy.orm import composite
from sqlalchemy.orm import mapper
-from sqlalchemy.orm import Session
from sqlalchemy.orm.instrumentation import ClassManager
from sqlalchemy.orm.mapper import Mapper
from sqlalchemy.testing import assert_raises
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import mock
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from sqlalchemy.testing.util import picklers
mapper(Foo, foo)
def test_coerce_none(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=None)
sess.add(f1)
sess.commit()
)
def test_in_place_mutation(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data={"a": "b"})
sess.add(f1)
)
def test_clear(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data={"a": "b"})
sess.add(f1)
eq_(f1.data, {})
def test_update(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data={"a": "b"})
sess.add(f1)
eq_(f1.data, {"a": "z"})
def test_pop(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data={"a": "b", "c": "d"})
sess.add(f1)
eq_(f1.data, {"c": "d"})
def test_pop_default(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data={"a": "b", "c": "d"})
sess.add(f1)
eq_(f1.data, {"c": "d"})
def test_popitem(self):
- sess = Session()
+ sess = fixture_session()
orig = {"a": "b", "c": "d"}
eq_(f1.data, orig)
def test_setdefault(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data={"a": "b"})
sess.add(f1)
eq_(f1.data, {"a": "b", "c": "d"})
def test_replace(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data={"a": "b"})
sess.add(f1)
sess.flush()
eq_(f1.data, {"b": "c"})
def test_replace_itself_still_ok(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data={"a": "b"})
sess.add(f1)
sess.flush()
eq_(f1.data, {"a": "b", "b": "c"})
def test_pickle_parent(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data={"a": "b"})
sess.add(f1)
sess.close()
for loads, dumps in picklers():
- sess = Session()
+ sess = fixture_session()
f2 = loads(dumps(f1))
sess.add(f2)
f2.data["a"] = "c"
assert f2 in sess.dirty
def test_unrelated_flush(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data={"a": "b"}, unrelated_data="unrelated")
sess.add(f1)
sess.flush()
eq_(f1.data["a"], "c")
def _test_non_mutable(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(non_mutable_data={"a": "b"})
sess.add(f1)
mapper(Foo, foo)
def test_coerce_none(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=None)
sess.add(f1)
sess.commit()
)
def test_in_place_mutation(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=[1, 2])
sess.add(f1)
eq_(f1.data, [3, 2])
def test_in_place_slice_mutation(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=[1, 2, 3, 4])
sess.add(f1)
eq_(f1.data, [1, 5, 6, 4])
def test_del_slice(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=[1, 2, 3, 4])
sess.add(f1)
if not hasattr(list, "clear"):
# py2 list doesn't have 'clear'
return
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=[1, 2])
sess.add(f1)
eq_(f1.data, [])
def test_pop(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=[1, 2, 3])
sess.add(f1)
eq_(f1.data, [2])
def test_append(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=[1, 2])
sess.add(f1)
eq_(f1.data, [1, 2, 5])
def test_extend(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=[1, 2])
sess.add(f1)
eq_(f1.data, [1, 2, 5])
def test_operator_extend(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=[1, 2])
sess.add(f1)
eq_(f1.data, [1, 2, 5])
def test_insert(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=[1, 2])
sess.add(f1)
eq_(f1.data, [1, 5, 2])
def test_remove(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=[1, 2, 3])
sess.add(f1)
eq_(f1.data, [1, 3])
def test_sort(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=[1, 3, 2])
sess.add(f1)
eq_(f1.data, [1, 2, 3])
def test_sort_w_key(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=[1, 3, 2])
sess.add(f1)
eq_(f1.data, [3, 2, 1])
def test_sort_w_reverse_kwarg(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=[1, 3, 2])
sess.add(f1)
eq_(f1.data, [3, 2, 1])
def test_reverse(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=[1, 3, 2])
sess.add(f1)
eq_(f1.data, [2, 3, 1])
def test_pickle_parent(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=[1, 2])
sess.add(f1)
sess.close()
for loads, dumps in picklers():
- sess = Session()
+ sess = fixture_session()
f2 = loads(dumps(f1))
sess.add(f2)
f2.data[0] = 3
assert f2 in sess.dirty
def test_unrelated_flush(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=[1, 2], unrelated_data="unrelated")
sess.add(f1)
sess.flush()
mapper(Foo, foo)
def test_coerce_none(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=None)
sess.add(f1)
sess.commit()
)
def test_clear(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=set([1, 2]))
sess.add(f1)
eq_(f1.data, set())
def test_pop(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=set([1]))
sess.add(f1)
eq_(f1.data, set())
def test_add(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=set([1, 2]))
sess.add(f1)
eq_(f1.data, set([1, 2, 5]))
def test_update(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=set([1, 2]))
sess.add(f1)
eq_(f1.data, set([1, 2, 5]))
def test_binary_update(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=set([1, 2]))
sess.add(f1)
eq_(f1.data, set([1, 2, 5]))
def test_intersection_update(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=set([1, 2]))
sess.add(f1)
eq_(f1.data, set([2]))
def test_binary_intersection_update(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=set([1, 2]))
sess.add(f1)
eq_(f1.data, set([2]))
def test_difference_update(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=set([1, 2]))
sess.add(f1)
eq_(f1.data, set([1]))
def test_operator_difference_update(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=set([1, 2]))
sess.add(f1)
eq_(f1.data, set([1]))
def test_symmetric_difference_update(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=set([1, 2]))
sess.add(f1)
eq_(f1.data, set([1, 5]))
def test_binary_symmetric_difference_update(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=set([1, 2]))
sess.add(f1)
eq_(f1.data, set([1, 5]))
def test_remove(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=set([1, 2, 3]))
sess.add(f1)
eq_(f1.data, set([1, 3]))
def test_discard(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=set([1, 2, 3]))
sess.add(f1)
eq_(f1.data, set([1, 3]))
def test_pickle_parent(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=set([1, 2]))
sess.add(f1)
sess.close()
for loads, dumps in picklers():
- sess = Session()
+ sess = fixture_session()
f2 = loads(dumps(f1))
sess.add(f2)
f2.data.add(3)
assert f2 in sess.dirty
def test_unrelated_flush(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=set([1, 2]), unrelated_data="unrelated")
sess.add(f1)
sess.flush()
def test_evt_on_flush_refresh(self):
# test for #3427
- sess = Session()
+ sess = fixture_session()
f1 = Foo()
sess.add(f1)
MutableDict.associate_with_attribute(Foo.data)
def test_in_place_mutation(self):
- sess = Session()
+ sess = fixture_session()
f1 = SubFoo(data={"a": "b"})
sess.add(f1)
eq_(f1.data, {"a": "c"})
def test_replace(self):
- sess = Session()
+ sess = fixture_session()
f1 = SubFoo(data={"a": "b"})
sess.add(f1)
sess.flush()
pass
def test_coerce(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data={"a": "b"})
sess.add(f1)
sess.flush()
def test_evt_on_flush_refresh(self):
# this still worked prior to #3427 being fixed in any case
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=self.Point(None, None))
sess.add(f1)
)
def test_in_place_mutation(self):
- sess = Session()
+ sess = fixture_session()
d = Point(3, 4)
f1 = Foo(data=d)
sess.add(f1)
eq_(f1.data, Point(3, 5))
def test_pickle_of_parent(self):
- sess = Session()
+ sess = fixture_session()
d = Point(3, 4)
f1 = Foo(data=d)
sess.add(f1)
sess.close()
for loads, dumps in picklers():
- sess = Session()
+ sess = fixture_session()
f2 = loads(dumps(f1))
sess.add(f2)
f2.data.y = 12
assert f2 in sess.dirty
def test_set_none(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=None)
sess.add(f1)
sess.commit()
)
def test_unrelated_flush(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=Point(3, 4), unrelated_data="unrelated")
sess.add(f1)
sess.flush()
)
def test_basic(self):
- sess = Session()
+ sess = fixture_session()
f1 = Foo(data=Point(3, 4))
sess.add(f1)
sess.flush()
eq_(f.data, Point(3, 4))
def test_round_trip_ok(self):
- sess = Session()
+ sess = fixture_session()
f = Foo()
f.data = (3, 4)
mapper(SubFoo, subfoo, inherits=Foo)
def test_in_place_mutation_subclass(self):
- sess = Session()
+ sess = fixture_session()
d = Point(3, 4)
f1 = SubFoo(data=d)
sess.add(f1)
eq_(f1.data, Point(3, 5))
def test_pickle_of_parent_subclass(self):
- sess = Session()
+ sess = fixture_session()
d = Point(3, 4)
f1 = SubFoo(data=d)
sess.add(f1)
sess.close()
for loads, dumps in picklers():
- sess = Session()
+ sess = fixture_session()
f2 = loads(dumps(f1))
sess.add(f2)
f2.data.y = 12
@classmethod
def setup_mappers(cls):
global Session
- Session = scoped_session(sessionmaker())
+ Session = scoped_session(sessionmaker(testing.db))
mapper(
User,
users,
serializer.dumps(expr, -1), users.metadata, None
)
eq_(str(expr), str(re_expr))
- assert re_expr.bind is testing.db
eq_(
- re_expr.execute().fetchall(),
+ Session.connection().execute(re_expr).fetchall(),
[(7, "jack"), (8, "ed"), (8, "ed"), (8, "ed"), (9, "fred")],
)
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import is_
from sqlalchemy.testing import mock
-from sqlalchemy.testing.fixtures import create_session
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from sqlalchemy.util import with_metaclass
def teardown(self):
close_all_sessions()
clear_mappers()
- Base.metadata.drop_all()
+ Base.metadata.drop_all(testing.db)
class DeclarativeTest(DeclarativeTestBase):
"user_id", Integer, ForeignKey("users.id"), key="_user_id"
)
- Base.metadata.create_all()
+ Base.metadata.create_all(testing.db)
eq_(Address.__table__.c["id"].name, "id")
eq_(Address.__table__.c["_email"].name, "email")
u1 = User(
name="u1", addresses=[Address(email="one"), Address(email="two")]
)
- sess = create_session()
+ sess = fixture_session()
sess.add(u1)
sess.flush()
sess.expunge_all()
orm_exc.UnmappedClassError,
"Class .*User has a deferred "
"mapping on it. It is not yet usable as a mapped class.",
- Session().query,
+ fixture_session().query,
User,
)
User.prepare()
self.assert_compile(
- Session().query(User), 'SELECT "user".id AS user_id FROM "user"'
+ fixture_session().query(User),
+ 'SELECT "user".id AS user_id FROM "user"',
)
def test_unicode_string_resolve(self):
email = Column(String(50))
user_id = Column(Integer) # note no foreign key
- Base.metadata.create_all()
- sess = create_session()
+ Base.metadata.create_all(testing.db)
+ sess = fixture_session()
u1 = User(
name="ed",
addresses=[
)
name = Column(String(50))
- Base.metadata.create_all()
- sess = create_session()
+ Base.metadata.create_all(testing.db)
+ sess = fixture_session()
u1 = User(name="ed")
sess.add(u1)
sess.flush()
name = Column(String(50))
users = relationship("User", order_by="User.fullname")
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(Game).options(joinedload(Game.users)),
"SELECT game.id AS game_id, game.name AS game_name, "
id = Column(Integer, primary_key=True)
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(A).join(A.d),
"SELECT a.id AS a_id, a.b_id AS a_b_id FROM a JOIN "
# generally go downhill from there.
class_mapper(User)
- Base.metadata.create_all()
- sess = create_session()
+ Base.metadata.create_all(testing.db)
+ sess = fixture_session()
u1 = User(
name="ed",
addresses=[
master_id = Column(None, ForeignKey(Master.id))
master = relationship(Master)
- Base.metadata.create_all()
+ Base.metadata.create_all(testing.db)
configure_mappers()
assert class_mapper(Detail).get_property("master").strategy.use_get
m1 = Master()
d1 = Detail(master=m1)
- sess = create_session()
+ sess = fixture_session()
sess.add(d1)
sess.flush()
sess.expunge_all()
assert User.__table__.c.name in set(i.columns)
# tables create fine
- Base.metadata.create_all()
+ Base.metadata.create_all(testing.db)
def test_add_prop(self):
class User(Base, fixtures.ComparableEntity):
Address.user_id = Column(
"user_id", Integer, ForeignKey("users.id"), key="_user_id"
)
- Base.metadata.create_all()
+ Base.metadata.create_all(testing.db)
eq_(Address.__table__.c["id"].name, "id")
eq_(Address.__table__.c["_email"].name, "email")
eq_(Address.__table__.c["_user_id"].name, "user_id")
u1 = User(
name="u1", addresses=[Address(email="one"), Address(email="two")]
)
- sess = create_session()
+ sess = fixture_session()
sess.add(u1)
sess.flush()
sess.expunge_all()
name = Column("name", String(50))
addresses = relationship("Address", order_by=Address.email)
- Base.metadata.create_all()
+ Base.metadata.create_all(testing.db)
u1 = User(
name="u1", addresses=[Address(email="two"), Address(email="one")]
)
- sess = create_session()
+ sess = fixture_session()
sess.add(u1)
sess.flush()
sess.expunge_all()
"Address", order_by=(Address.email, Address.id)
)
- Base.metadata.create_all()
+ Base.metadata.create_all(testing.db)
u1 = User(
name="u1", addresses=[Address(email="two"), Address(email="one")]
)
- sess = create_session()
+ sess = fixture_session()
sess.add(u1)
sess.flush()
sess.expunge_all()
reg = registry(metadata=Base.metadata)
reg.mapped(User)
reg.mapped(Address)
- reg.metadata.create_all()
+ reg.metadata.create_all(testing.db)
u1 = User(
name="u1", addresses=[Address(email="one"), Address(email="two")]
)
.where(Address.user_id == User.id)
.scalar_subquery()
)
- Base.metadata.create_all()
+ Base.metadata.create_all(testing.db)
u1 = User(
name="u1", addresses=[Address(email="one"), Address(email="two")]
)
- sess = create_session()
+ sess = fixture_session()
sess.add(u1)
sess.flush()
sess.expunge_all()
.scalar_subquery()
)
- Base.metadata.create_all()
+ Base.metadata.create_all(testing.db)
u1 = User(
name="u1", addresses=[Address(email="one"), Address(email="two")]
)
- sess = create_session()
+ sess = fixture_session()
sess.add(u1)
sess.flush()
sess.expunge_all()
User.a = Column("a", String(10))
User.b = Column(String(10))
- Base.metadata.create_all()
+ Base.metadata.create_all(testing.db)
u1 = User(name="u1", a="a", b="b")
eq_(u1.a, "a")
eq_(User.a.get_history(u1), (["a"], (), ()))
- sess = create_session()
+ sess = fixture_session()
sess.add(u1)
sess.flush()
sess.expunge_all()
)
addresses = relationship(Address)
- Base.metadata.create_all()
+ Base.metadata.create_all(testing.db)
u1 = User(
name="u1", addresses=[Address(email="one"), Address(email="two")]
)
- sess = create_session()
+ sess = fixture_session()
sess.add(u1)
sess.flush()
sess.expunge_all()
)
name = sa.orm.deferred(Column(String(50)))
- Base.metadata.create_all()
- sess = create_session()
+ Base.metadata.create_all(testing.db)
+ sess = fixture_session()
sess.add(User(name="u1"))
sess.flush()
sess.expunge_all()
Column("state", String(2)),
)
- Base.metadata.create_all()
- sess = Session()
+ Base.metadata.create_all(testing.db)
+ sess = fixture_session()
sess.add(User(address=AddressComposite("123 anywhere street", "MD")))
sess.commit()
eq_(
state = Column(String(2))
address = composite(AddressComposite, street, state)
- Base.metadata.create_all()
- sess = Session()
+ Base.metadata.create_all(testing.db)
+ sess = fixture_session()
sess.add(User(address=AddressComposite("123 anywhere street", "MD")))
sess.commit()
eq_(
"_name", descriptor=property(_get_name, _set_name)
)
- Base.metadata.create_all()
- sess = create_session()
+ Base.metadata.create_all(testing.db)
+ sess = fixture_session()
u1 = User(name="someuser")
eq_(u1.name, "SOMENAME someuser")
sess.add(u1)
_name = Column("name", String(50))
name = sa.orm.synonym("_name", comparator_factory=CustomCompare)
- Base.metadata.create_all()
- sess = create_session()
+ Base.metadata.create_all(testing.db)
+ sess = fixture_session()
u1 = User(name="someuser FOO")
sess.add(u1)
sess.flush()
name = property(_get_name, _set_name)
User.name = sa.orm.synonym("_name", descriptor=User.name)
- Base.metadata.create_all()
- sess = create_session()
+ Base.metadata.create_all(testing.db)
+ sess = fixture_session()
u1 = User(name="someuser")
eq_(u1.name, "SOMENAME someuser")
sess.add(u1)
list(Address.user_id.property.columns[0].foreign_keys)[0].column,
User.__table__.c.id,
)
- Base.metadata.create_all()
+ Base.metadata.create_all(testing.db)
u1 = User(
name="u1", addresses=[Address(email="one"), Address(email="two")]
)
- sess = create_session()
+ sess = fixture_session()
sess.add(u1)
sess.flush()
sess.expunge_all()
.where(Address.user_id == User.id)
.scalar_subquery()
)
- Base.metadata.create_all()
+ Base.metadata.create_all(testing.db)
u1 = User(
name="u1", addresses=[Address(email="one"), Address(email="two")]
)
- sess = create_session()
+ sess = fixture_session()
sess.add(u1)
sess.flush()
sess.expunge_all()
__table__ = Table("t1", Base.metadata, autoload_with=testing.db)
- sess = create_session()
+ sess = fixture_session()
m = MyObj(id="someid", data="somedata")
sess.add(m)
sess.flush()
def namesyn(self):
return self.name
- Base.metadata.create_all()
- sess = create_session()
+ Base.metadata.create_all(testing.db)
+ sess = fixture_session()
u1 = User(name="someuser")
eq_(u1.name, "someuser")
eq_(u1.namesyn, "someuser")
# PropertyLoader.Comparator will annotate the left side with
# _orm_adapt, though.
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(User)
.join(User.addresses, aliased=True)
from sqlalchemy.orm import declared_attr
from sqlalchemy.orm import exc as orm_exc
from sqlalchemy.orm import relationship
-from sqlalchemy.orm import Session
from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.fixtures import fixture_session
class ConcurrentUseDeclMappingTest(fixtures.TestBase):
@classmethod
def query_a(cls, Base, result):
- s = Session()
+ s = fixture_session()
time.sleep(random.random() / 100)
A = cls.A
try:
from sqlalchemy.orm import clear_mappers
from sqlalchemy.orm import close_all_sessions
from sqlalchemy.orm import configure_mappers
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import deferred
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
-from sqlalchemy.orm import Session
from sqlalchemy.testing import assert_raises
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import eq_
from sqlalchemy.testing import is_
from sqlalchemy.testing import is_false
from sqlalchemy.testing import is_true
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
def teardown(self):
close_all_sessions()
clear_mappers()
- Base.metadata.drop_all()
+ Base.metadata.drop_all(testing.db)
class DeclarativeInheritanceTest(DeclarativeTestBase):
)
golf_swing = Column("golf_swing", String(50))
- Base.metadata.create_all()
- sess = create_session()
+ Base.metadata.create_all(testing.db)
+ sess = fixture_session()
c1 = Company(
name="MegaCorp, Inc.",
employees=[
)
Engineer.primary_language = Column("primary_language", String(50))
- Base.metadata.create_all()
- sess = create_session()
+ Base.metadata.create_all(testing.db)
+ sess = fixture_session()
e1 = Engineer(primary_language="java", name="dilbert")
sess.add(e1)
sess.flush()
)
Person.name = Column("name", String(50))
- Base.metadata.create_all()
- sess = create_session()
+ Base.metadata.create_all(testing.db)
+ sess = fixture_session()
e1 = Engineer(primary_language="java", name="dilbert")
sess.add(e1)
sess.flush()
)
Person.name = Column("name", String(50))
- Base.metadata.create_all()
- sess = create_session()
+ Base.metadata.create_all(testing.db)
+ sess = fixture_session()
e1 = Admin(primary_language="java", name="dilbert", workstation="foo")
sess.add(e1)
sess.flush()
__mapper_args__ = {"polymorphic_identity": "manager"}
- Base.metadata.create_all()
- sess = create_session()
+ Base.metadata.create_all(testing.db)
+ sess = fixture_session()
c1 = Company(
name="MegaCorp, Inc.",
employees=[
assert not hasattr(Person, "golf_swing")
assert not hasattr(Engineer, "golf_swing")
assert not hasattr(Manager, "primary_language")
- Base.metadata.create_all()
- sess = create_session()
+ Base.metadata.create_all(testing.db)
+ sess = fixture_session()
e1 = Engineer(name="dilbert", primary_language="java")
e2 = Engineer(name="wally", primary_language="c++")
m1 = Manager(name="dogbert", golf_swing="fore!")
Manager.target_id.property.columns[0], Person.__table__.c.target_id
)
# do a brief round trip on this
- Base.metadata.create_all()
- session = Session()
+ Base.metadata.create_all(testing.db)
+ session = fixture_session()
o1, o2 = Other(), Other()
session.add_all(
[Engineer(target=o1), Manager(target=o2), Manager(target=o1)]
assert not hasattr(Person, "golf_swing")
assert not hasattr(Engineer, "golf_swing")
assert not hasattr(Manager, "primary_language")
- Base.metadata.create_all()
- sess = create_session()
+ Base.metadata.create_all(testing.db)
+ sess = fixture_session()
e1 = Engineer(name="dilbert", primary_language="java")
e2 = Engineer(name="wally", primary_language="c++")
m1 = Manager(name="dogbert", golf_swing="fore!")
)
Person.name = deferred(Column(String(10)))
- Base.metadata.create_all()
- sess = create_session()
+ Base.metadata.create_all(testing.db)
+ sess = fixture_session()
p = Person(name="ratbert")
sess.add(p)
sess.flush()
name = Column(String(50))
assert not hasattr(Person, "primary_language_id")
- Base.metadata.create_all()
- sess = create_session()
+ Base.metadata.create_all(testing.db)
+ sess = fixture_session()
java, cpp, cobol = (
Language(name="java"),
Language(name="cpp"),
from sqlalchemy.orm import has_inherited_table
from sqlalchemy.orm import registry
from sqlalchemy.orm import relationship
-from sqlalchemy.orm import Session
from sqlalchemy.orm import synonym
from sqlalchemy.testing import assert_raises
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import is_
from sqlalchemy.testing import mock
-from sqlalchemy.testing.fixtures import create_session
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from sqlalchemy.testing.util import gc_collect
name = Column(String(100), nullable=False, index=True)
Base.metadata.create_all(testing.db)
- session = create_session()
+ session = fixture_session()
session.add(MyModel(name="testing"))
session.flush()
session.expunge_all()
name = Column(String(100), nullable=False, index=True)
Base.metadata.create_all(testing.db)
- session = create_session()
+ session = fixture_session()
session.add(MyModel(name="testing"))
session.flush()
session.expunge_all()
name = Column(String(100), nullable=False, index=True)
Base.metadata.create_all(testing.db)
- session = create_session()
+ session = fixture_session()
session.add(MyModel(name="testing", baz="fu"))
session.flush()
session.expunge_all()
name = Column(String(100), nullable=False, index=True)
Base.metadata.create_all(testing.db)
- session = create_session()
+ session = fixture_session()
session.add(MyModel(name="testing", baz="fu"))
session.flush()
session.expunge_all()
)
# do a brief round trip on this
Base.metadata.create_all(testing.db)
- session = create_session()
+ session = fixture_session()
o1, o2 = Other(), Other()
session.add_all(
[Engineer(target=o1), Manager(target=o2), Manager(target=o1)]
MyModel.prop_hoho.property is not MyOtherModel.prop_hoho.property
)
Base.metadata.create_all(testing.db)
- sess = create_session()
+ sess = fixture_session()
m1, m2 = MyModel(prop_hoho="foo"), MyOtherModel(prop_hoho="bar")
sess.add_all([m1, m2])
sess.flush()
d1 = inspect(Derived)
is_(b1.attrs["data_syn"], d1.attrs["data_syn"])
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(Base.data_syn).filter(Base.data_syn == "foo"),
"SELECT test.data AS test_data FROM test "
)
Base.metadata.create_all(testing.db)
- sess = create_session()
+ sess = fixture_session()
sess.add_all([MyModel(data="d1"), MyModel(data="d2")])
sess.flush()
sess.expunge_all()
)
Base.metadata.create_all(testing.db)
- sess = create_session()
+ sess = fixture_session()
t1, t2 = Target(), Target()
f1, f2, b1 = Foo(target=t1), Foo(target=t2), Bar(target=t1)
sess.add_all([f1, f2, b1])
is_(a_col, A.__table__.c.x)
is_(b_col, B.__table__.c.x)
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(A),
"SELECT a.x AS a_x, a.x + :x_1 AS anon_1, a.id AS a_id FROM a",
eq_(counter.mock_calls, [mock.call(User.id)])
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User).having(User.address_count > 5),
"SELECT (SELECT count(address.id) AS "
from sqlalchemy.testing import assert_raises
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
-from sqlalchemy.testing.fixtures import create_session
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
u1 = User(
name="u1", addresses=[Address(email="one"), Address(email="two")]
)
- sess = create_session()
+ sess = fixture_session()
sess.add(u1)
sess.flush()
sess.expunge_all()
u1 = User(
nom="u1", addresses=[Address(email="one"), Address(email="two")]
)
- sess = create_session()
+ sess = fixture_session()
sess.add(u1)
sess.flush()
sess.expunge_all()
u1 = User(
nom="u1", addresses=[Address(email="one"), Address(email="two")]
)
- sess = create_session()
+ sess = fixture_session()
sess.add(u1)
sess.flush()
sess.expunge_all()
IMHandle(network="lol", handle="zomg"),
],
)
- sess = create_session()
+ sess = fixture_session()
sess.add(u1)
sess.flush()
sess.expunge_all()
from sqlalchemy.orm.interfaces import MANYTOONE
from sqlalchemy.orm.interfaces import ONETOMANY
from sqlalchemy.testing import fixtures
-from sqlalchemy.testing.fixtures import create_session
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
parent_class = {"a": A, "b": B, "c": C}[parent]
child_class = {"a": A, "b": B, "c": C}[child]
- sess = create_session()
+ sess = fixture_session(autoflush=False, expire_on_commit=False)
parent_obj = parent_class("parent1")
child_obj = child_class("child1")
from sqlalchemy.orm import mapper
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
-from sqlalchemy.testing.fixtures import create_session
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
c2 = C(cdata="c2", bdata="c2", adata="c2")
c3 = C(cdata="c2", bdata="c2", adata="c2")
- sess = create_session()
+ sess = fixture_session()
for x in (a1, b1, b2, b3, c1, c2, c3):
sess.add(x)
sess.flush()
from sqlalchemy.orm import mapper
from sqlalchemy.orm import polymorphic_union
from sqlalchemy.orm import relationship
-from sqlalchemy.orm import Session
from sqlalchemy.orm import sessionmaker
from sqlalchemy.orm import with_polymorphic
from sqlalchemy.orm.interfaces import MANYTOONE
from sqlalchemy.testing import AssertsExecutionResults
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
-from sqlalchemy.testing.fixtures import create_session
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
[(managers.c.person_id, people.c.manager_id)],
)
- session = create_session()
+ session = fixture_session()
p = Person(name="some person")
m = Manager(name="some manager")
p.manager = m
},
)
- session = create_session()
+ session = fixture_session()
p = Person(name="some person")
m = Manager(name="some manager")
m.employee = p
},
)
- sess = create_session()
+ sess = fixture_session()
p = Person(name="person1")
m = Manager(name="manager1")
m.colleague = p
self._setup_mappings(jointype, usedata)
Person, Manager, Data = self.classes("Person", "Manager", "Data")
- sess = create_session()
+ sess = fixture_session()
p = Person(name="person1")
p2 = Person(name="person2")
p3 = Person(name="person3")
)
mapper(Car, cars, properties={"employee": relationship(person_mapper)})
- session = create_session()
+ session = fixture_session()
# creating 5 managers named from M1 to E5
for i in range(1, 5):
},
)
- sess = create_session()
+ sess = fixture_session()
car1 = Car()
car2 = Car()
car2.manager = Manager()
},
)
- sess = create_session()
+ sess = fixture_session()
m = Manager(name="manager1")
m2 = Manager(name="manager2")
m.colleague = m2
polymorphic_identity="manager",
)
- session = create_session()
+ session = fixture_session()
for i in range(1, 4):
if i % 2:
u1 = User(data="u1")
t1 = Taggable(owner=u1)
- sess = create_session()
+ sess = fixture_session()
sess.add(t1)
sess.flush()
Status, Person, Engineer, Manager, Car = self.classes(
"Status", "Person", "Engineer", "Manager", "Car"
)
- session = create_session()
+ session = fixture_session()
r = (
session.query(Person)
Status, Person, Engineer, Manager, Car = self.classes(
"Status", "Person", "Engineer", "Manager", "Car"
)
- session = create_session()
+ session = fixture_session()
r = (
session.query(Engineer)
.join("status")
Status, Person, Engineer, Manager, Car = self.classes(
"Status", "Person", "Engineer", "Manager", "Car"
)
- session = create_session()
+ session = fixture_session()
r = session.query(Person).filter(
exists().where(Car.owner == Person.person_id)
)
b = Engineer().set(egn="two", machine="any")
c = Manager().set(name="head", machine="fast", duties="many")
- session = create_session()
+ session = fixture_session()
session.add(a)
session.add(b)
session.add(c)
mapper(T2, t2, inherits=T1, polymorphic_identity="t2")
ot1 = T1()
ot2 = T2()
- sess = create_session()
+ sess = fixture_session()
sess.add(ot1)
sess.add(ot2)
sess.flush()
ot1 = T1()
ot2 = T2()
- sess = create_session()
+ sess = fixture_session()
sess.add(ot1)
sess.add(ot2)
sess.flush()
)
mapper(Tag, tags)
- session = create_session()
+ session = fixture_session()
bob = Employee()
session.add(bob)
c = C(cdata="c1", adata="a1", b=B(data="c"))
d = D(cdata="c2", adata="a2", ddata="d2", b=B(data="d"))
- sess = create_session()
+ sess = fixture_session()
sess.add(c)
sess.add(d)
sess.flush()
def _roundtrip(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
u1 = User()
u2 = User()
u2.supervisor = u1
def _dude_roundtrip(self):
Dude, User = self.classes.Dude, self.classes.User
- sess = Session()
+ sess = fixture_session()
u1 = User()
d1 = Dude()
d1.supervisor = u1
)
def test_join_w_eager_w_any(self):
B, C, D = (self.classes.B, self.classes.C, self.classes.D)
- s = Session(testing.db)
+ s = fixture_session()
b = B(ds=[D()])
s.add_all([C(b=b)])
def test_polymorphic_adaptation(self):
A, B = self.classes.A, self.classes.B
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(A).join(B).filter(B.x == "test"),
"SELECT a.id AS a_id FROM a JOIN "
poly = with_polymorphic(Superclass, "*")
- s = Session()
+ s = fixture_session()
q = (
s.query(poly)
.options(contains_eager(poly.common_relationship))
poly = with_polymorphic(Superclass, "*")
- s = Session()
+ s = fixture_session()
q = (
s.query(poly)
.options(contains_eager(poly.common_relationship))
from sqlalchemy.orm import polymorphic_union
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
-from sqlalchemy.orm import sessionmaker
from sqlalchemy.orm import synonym
from sqlalchemy.orm.util import instance_str
from sqlalchemy.testing import assert_raises
from sqlalchemy.testing.assertsql import Conditional
from sqlalchemy.testing.assertsql import Or
from sqlalchemy.testing.assertsql import RegexSQL
-from sqlalchemy.testing.fixtures import create_session
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
properties={"parent_foo": relationship(Foo)},
)
- sess = create_session()
+ sess = fixture_session()
b1 = Blub("blub #1")
b2 = Blub("blub #2")
f = Foo("foo #1")
def test_group_by(self):
B = self.classes.B
- s = Session()
+ s = fixture_session()
rows = (
s.query(B.id.expressions[0], B.id.expressions[1], func.sum(B.data))
A = self.classes.A
B = self.classes.B
- session = Session(testing.db)
+ session = fixture_session()
result = (
session.query(A)
.filter_by(child_id=None)
else:
assert False, "Got unexpected identity %r" % ident
- s = Session(testing.db)
+ s = fixture_session()
s.add_all([Parent(q="p1"), Child(q="c1", y="c1"), Parent(q="p2")])
s.commit()
s.close()
cls.classes.B = B
def test_flush(self):
- s = Session(testing.db)
+ s = fixture_session()
s.add(self.classes.B())
s.flush()
mapper(Foo, t1, polymorphic_on=t1.c.type, polymorphic_identity=True)
mapper(Bar, inherits=Foo, polymorphic_identity=False)
- sess = create_session()
+ sess = fixture_session()
b1 = Bar()
sess.add(b1)
sess.flush()
mapper(Ding, t1, polymorphic_on=t1.c.type, polymorphic_identity=False)
mapper(Bat, inherits=Ding, polymorphic_identity=True)
- sess = create_session()
+ sess = fixture_session()
d1 = Ding()
sess.add(d1)
sess.flush()
properties={"info": synonym("_info", map_column=True)},
)
mapper(T2, t2, inherits=T1, polymorphic_identity="t2")
- sess = create_session()
+ sess = fixture_session()
at1 = T1(info="at1")
at2 = T2(info="at2", data="t2 data")
sess.add(at1)
def test_base_class(self):
A, C, B = (self.classes.A, self.classes.C, self.classes.B)
- sess = Session()
+ sess = fixture_session()
c1 = C()
sess.add(c1)
sess.commit()
"""
D, B = self.classes.D, self.classes.B
- sess = Session()
+ sess = fixture_session()
b1 = B()
b1.class_name = "d"
sess.add(b1)
"""
C = self.classes.C
- sess = Session()
+ sess = fixture_session()
c1 = C()
c1.class_name = "b"
sess.add(c1)
"""
B = self.classes.B
- sess = Session()
+ sess = fixture_session()
b1 = B()
b1.class_name = "c"
sess.add(b1)
"""test warn on an unknown polymorphic identity."""
B = self.classes.B
- sess = Session()
+ sess = fixture_session()
b1 = B()
b1.class_name = "xyz"
sess.add(b1)
def test_not_set_on_upate(self):
C = self.classes.C
- sess = Session()
+ sess = fixture_session()
c1 = C()
sess.add(c1)
sess.commit()
def test_validate_on_upate(self):
C = self.classes.C
- sess = Session()
+ sess = fixture_session()
c1 = C()
sess.add(c1)
sess.commit()
)
mapper(T4, t4)
- sess = create_session()
+ sess = fixture_session()
t1_1 = T1(data="t1")
t3_1 = T3(data="t3", moredata="t3")
assert class_mapper(Related).get_property("sub").strategy.use_get
- sess = create_session()
+ sess = fixture_session()
s1 = Sub()
r1 = Related(sub=s1)
sess.add(r1)
mapper(Bar, bar, inherits=Foo)
mapper(Blub, blub, inherits=Bar)
- sess = create_session()
+ sess = fixture_session()
f = Foo()
b = Bar()
bl = Blub()
def test_basic(self):
Bar = self.classes.Bar
- sess = create_session()
+ sess = fixture_session()
q = sess.query(Bar)
self.assert_(len(q.first().lazy) == 1)
self.assert_(len(q.first().eager) == 1)
},
)
- sess = create_session()
+ sess = fixture_session()
b1 = B(id=1, name="b1", b_data="i")
sess.add(b1)
},
)
mapper(Admin, admins, inherits=user_mapper)
- sess = create_session()
+ sess = fixture_session()
adminrole = Role()
sess.add(adminrole)
sess.flush()
# create roles
adminrole = Role("admin")
- sess = create_session()
+ sess = fixture_session()
sess.add(adminrole)
sess.flush()
A, B, C = self.classes("A", "B", "C")
self._fixture()
- s = Session()
+ s = fixture_session()
a1, b1, c1 = A(id=1), B(id=2), C(cid=1, id=3)
s.add_all([a1, b1, c1])
s.commit()
A, B, C = self.classes("A", "B", "C")
self._fixture(c_p=True)
- s = Session()
+ s = fixture_session()
a1, b1, c1 = A(id=1), B(id=2), C(cid=1, id=3)
s.add_all([a1, b1, c1])
s.commit()
A, B, C = self.classes("A", "B", "C")
self._fixture(b_p=True)
- s = Session()
+ s = fixture_session()
a1, b1, c1 = A(id=1), B(id=2), C(cid=1, id=3)
s.add_all([a1, b1, c1])
s.commit()
A, B, C = self.classes("A", "B", "C")
self._fixture(a_p=True)
- s = Session()
+ s = fixture_session()
a1, b1, c1 = A(id=1), B(id=2), C(cid=1, id=3)
s.add_all([a1, b1, c1])
s.commit()
def test_column_property(self):
A, B = self.classes("A", "B")
- sess = Session()
+ sess = fixture_session()
b1 = B(data="x")
sess.add(b1)
sess.flush()
def test_expired_column(self):
A, B = self.classes("A", "B")
- sess = Session()
+ sess = fixture_session()
b1 = B(data="x")
sess.add(b1)
sess.flush()
def test_ordering(self):
B, C = self.classes.B, self.classes.C
- sess = Session()
+ sess = fixture_session()
sess.add_all([B(), C(), B(), C()])
self.assert_sql_execution(
testing.db,
)
mapper(Sub, subtable, inherits=Base, polymorphic_identity=2)
- sess = Session(autoflush=False)
+ sess = fixture_session(autoflush=False)
b1 = Base(value="b1")
s1 = Sub(value="sub1", subdata="some subdata")
sess.commit()
- sess2 = Session(autoflush=False)
+ sess2 = fixture_session(autoflush=False)
s2 = sess2.get(Base, s1.id)
s2.subdata = "sess2 subdata"
)
mapper(Sub, subtable, inherits=Base, polymorphic_identity=2)
- sess = Session(autoflush=False, expire_on_commit=False)
+ sess = fixture_session(autoflush=False, expire_on_commit=False)
b1 = Base(value="b1")
s1 = Sub(value="sub1", subdata="some subdata")
sess.commit()
- sess2 = Session(autoflush=False, expire_on_commit=False)
+ sess2 = fixture_session(autoflush=False, expire_on_commit=False)
s3 = sess2.get(Base, s1.id)
sess2.delete(s3)
sess2.commit()
self._do_test(False)
def _do_test(self, composite):
- session = create_session()
+ session = fixture_session()
if composite:
alice1 = session.get(Employee, [1, 2])
mapper(B, _b_table, inherits=A, inherit_condition=j1)
mapper(C, _c_table, inherits=B, inherit_condition=j2)
- session = create_session()
+ session = fixture_session()
a = A(data1="a1")
session.add(a)
s1 = Sub()
s1.id = 10
- sess = create_session()
+ sess = fixture_session()
sess.add(s1)
sess.flush()
assert sess.get(Sub, 10) is s1
s2 = Sub()
s2.base_id = 15
- sess = create_session()
+ sess = fixture_session()
sess.add_all([s1, s2])
sess.flush()
mapper(Sub, subtable, inherits=Base)
s1 = Sub()
- sess = create_session()
+ sess = fixture_session()
sess.add(s1)
sess.flush()
assert sess.query(Sub).one().data == "im the data"
mapper(Sub, subtable, inherits=Base)
s1 = Sub()
- sess = create_session()
+ sess = fixture_session()
sess.add(s1)
sess.flush()
assert sess.query(Sub).one().data == "im the data"
mapper(Base, base)
mapper(Sub, subtable, inherits=Base)
- sess = create_session()
+ sess = fixture_session()
b1 = Base()
assert b1.subdata == "this is base"
s1 = Sub()
mapper(Base, base)
mapper(Sub, subtable, inherits=Base)
- sess = create_session()
+ sess = fixture_session()
b1 = Base()
assert b1.data == "this is base"
s1 = Sub()
)
mapper(SubJoinBase, inherits=JoinBase)
- sess = Session()
+ sess = fixture_session()
sess.add(Base(data="data"))
sess.commit()
base.outerjoin(sub).select().apply_labels().alias("foo"),
),
)
- sess = Session()
+ sess = fixture_session()
s1 = Sub(
data="s1data", sub="s1sub", subcounter=1, counter=1, subcounter2=1
)
polymorphic_identity="sub",
properties={"id": [sub.c.id, base.c.id]},
)
- sess = sessionmaker()()
+ sess = fixture_session()
s1 = Sub(data="s1data", sub="s1sub")
sess.add(s1)
sess.commit()
"concat": column_property(sub.c.sub + "|" + sub.c.sub)
},
)
- sess = sessionmaker()()
+ sess = fixture_session()
s1 = Sub(data="s1data", sub="s1sub")
sess.add(s1)
sess.commit()
"concat": column_property(base.c.data + "|" + sub.c.sub)
},
)
- sess = sessionmaker()()
+ sess = fixture_session()
s1 = Sub(data="s1data", sub="s1sub")
s2 = Sub(data="s2data", sub="s2sub")
s3 = Sub(data="s3data", sub="s3sub")
polymorphic_identity="wc",
properties={"comp": composite(Comp, with_comp.c.a, with_comp.c.b)},
)
- sess = sessionmaker()()
+ sess = fixture_session()
s1 = WithComp(data="s1data", comp=Comp("ham", "cheese"))
s2 = WithComp(data="s2data", comp=Comp("bacon", "eggs"))
sess.add_all([s1, s2])
Base, base, polymorphic_on=base.c.type, polymorphic_identity="base"
)
mapper(Sub, sub, inherits=Base, polymorphic_identity="sub")
- sess = Session()
+ sess = fixture_session()
s1 = Sub(data="s1")
sess.add(s1)
self.assert_sql_execution(
)
mapper(Sub, sub, inherits=Base, polymorphic_identity="sub")
mapper(SubSub, subsub, inherits=Sub, polymorphic_identity="subsub")
- sess = Session()
+ sess = fixture_session()
s1 = SubSub(data="s1", counter=1, subcounter=2)
sess.add(s1)
self.assert_sql_execution(
mapper(A, inherits=Child, polymorphic_identity=2)
- s = create_session()
+ s = fixture_session()
p = Parent("p1")
a = A("a1")
p.children.append(a)
def test_load_from_middle(self):
C, B = self.classes.C, self.classes.B
- s = Session()
+ s = fixture_session()
s.add(C())
o = s.query(B).first()
eq_(o.type, "c")
def test_load_from_base(self):
A, C = self.classes.A, self.classes.C
- s = Session()
+ s = fixture_session()
s.add(C())
o = s.query(A).first()
eq_(o.type, "c")
self.tables.base,
)
- s = Session()
+ s = fixture_session()
s.add_all([C(), D(), E()])
eq_(s.query(B).order_by(base.c.type).all(), [C(), D()])
},
)
- sess = create_session()
+ sess = fixture_session()
s1 = SubClass(data="s1")
sess.add(s1)
assert_raises(sa_exc.DBAPIError, sess.flush)
@classmethod
def insert_data(cls, connection):
Parent, A, B = cls.classes("Parent", "A", "B")
- s = Session()
+ s = fixture_session()
p1 = Parent(id=1)
p2 = Parent(id=2)
def test_pk_is_null(self):
Parent, A = self.classes("Parent", "A")
- sess = Session()
+ sess = fixture_session()
q = (
sess.query(Parent, A)
.select_from(Parent)
def test_pk_not_null_discriminator_null_from_base(self):
(A,) = self.classes("A")
- sess = Session()
+ sess = fixture_session()
q = sess.query(A).filter(A.id == 3)
assert_raises_message(
sa_exc.InvalidRequestError,
def test_pk_not_null_discriminator_null_from_sub(self):
(B,) = self.classes("B")
- sess = Session()
+ sess = fixture_session()
q = sess.query(B).filter(B.id == 4)
assert_raises_message(
sa_exc.InvalidRequestError,
ASingleSubA, ASingleSubB, AJoinedSubA, AJoinedSubB = cls.classes(
"ASingleSubA", "ASingleSubB", "AJoinedSubA", "AJoinedSubB"
)
- s = Session()
+ s = fixture_session()
s.add_all([ASingleSubA(), ASingleSubB(), AJoinedSubA(), AJoinedSubB()])
s.commit()
def test_single_invalid_ident(self):
ASingle, ASingleSubA = self.classes("ASingle", "ASingleSubA")
- s = Session()
+ s = fixture_session()
q = s.query(ASingleSubA).select_entity_from(select(ASingle).subquery())
def test_joined_invalid_ident(self):
AJoined, AJoinedSubA = self.classes("AJoined", "AJoinedSubA")
- s = Session()
+ s = fixture_session()
q = s.query(AJoinedSubA).select_entity_from(select(AJoined).subquery())
mapper(
Foo, self.tables.foo, inherits=Content, polymorphic_identity="foo"
)
- sess = create_session()
+ sess = fixture_session()
f = Foo()
f.content_type = "bar"
sess.add(f)
from sqlalchemy.orm import mapper
from sqlalchemy.orm import polymorphic_union
from sqlalchemy.orm import relationship
-from sqlalchemy.orm import sessionmaker
from sqlalchemy.testing import assert_raises
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import mock
-from sqlalchemy.testing.fixtures import create_session
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
concrete=True,
polymorphic_identity="engineer",
)
- session = create_session()
+ session = fixture_session()
session.add(Manager("Tom", "knows how to manage things"))
session.add(Engineer("Kurt", "knows how to hack"))
session.flush()
concrete=True,
polymorphic_identity="hacker",
)
- session = create_session()
+ session = fixture_session()
tom = Manager("Tom", "knows how to manage things")
assert_raises_message(
polymorphic_identity="engineer",
)
- session = create_session()
+ session = fixture_session()
tom = ManagerWHybrid("Tom", "mgrdata")
# mapping did not impact the engineer_info
concrete=True,
polymorphic_identity="hacker",
)
- session = create_session()
+ session = fixture_session()
tom = Manager("Tom", "knows how to manage things")
jerry = Engineer("Jerry", "knows how to program")
hacker = Hacker("Kurt", "Badass", "knows how to hack")
concrete=True,
polymorphic_identity="hacker",
)
- session = create_session()
+ session = fixture_session()
jdoe = Employee("Jdoe")
tom = Manager("Tom", "knows how to manage things")
jerry = Engineer("Jerry", "knows how to program")
concrete=True,
polymorphic_identity="engineer",
)
- session = create_session()
+ session = fixture_session()
c = Company()
c.employees.append(Manager("Tom", "knows how to manage things"))
c.employees.append(Engineer("Kurt", "knows how to hack"))
"many_b": relationship(B, back_populates="some_dest"),
},
)
- sess = sessionmaker()()
+ sess = fixture_session()
dest1 = Dest(name="c1")
dest2 = Dest(name="c2")
a1 = A(some_dest=dest1, aname="a1")
},
)
- sess = sessionmaker()()
+ sess = fixture_session()
dest1 = Dest(name="c1")
dest2 = Dest(name="c2")
a1 = A(some_dest=dest1, aname="a1", id=1)
assert B.some_dest.property.parent is class_mapper(B)
assert A.some_dest.property.parent is class_mapper(A)
- sess = sessionmaker()()
+ sess = fixture_session()
dest1 = Dest(name="d1")
dest2 = Dest(name="d2")
a1 = A(some_dest=dest2, aname="a1")
sess.add_all([dest1, dest2, c1, a1, b1])
sess.commit()
- sess2 = sessionmaker()()
+ sess2 = fixture_session()
merged_c1 = sess2.merge(c1)
eq_(merged_c1.some_dest.name, "d2")
eq_(merged_c1.some_dest_id, c1.some_dest_id)
},
)
mapper(Related, related)
- sess = sessionmaker()()
+ sess = fixture_session()
b1, s1, r1, r2, r3 = Base(), Sub(), Related(), Related(), Related()
b1.related.append(r1)
b1.related.append(r2)
concrete=True,
polymorphic_identity="refugee",
)
- sess = create_session()
+ sess = fixture_session()
eq_(sess.get(Refugee, 1).name, "refugee1")
eq_(sess.get(Refugee, 2).name, "refugee2")
eq_(sess.get(Office, 1).name, "office1")
from sqlalchemy.orm import mapper
from sqlalchemy.orm import polymorphic_union
from sqlalchemy.orm import relationship
-from sqlalchemy.orm import Session
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
Publication = self.classes.Publication
- session = Session()
+ session = fixture_session()
pub = self._generate_data()
session.add(pub)
from sqlalchemy.orm import relationship
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
-from sqlalchemy.testing.fixtures import create_session
+from sqlalchemy.testing.fixtures import fixture_session
class InheritTest(fixtures.MappedTest):
login_id="lg1",
)
)
- sess = create_session()
+ sess = fixture_session()
sess.add(g)
sess.flush()
# TODO: put an assertion
print(foo.join(bar).primary_key)
print(class_mapper(Bar).primary_key)
b = Bar("somedata")
- sess = create_session()
+ sess = fixture_session()
sess.add(b)
sess.flush()
sess.expunge_all()
},
)
- sess = create_session()
+ sess = fixture_session()
b = Bar("barfoo")
sess.add(b)
sess.flush()
},
)
- sess = create_session()
+ sess = fixture_session()
b = Bar("bar #1")
sess.add(b)
b.foos.append(Foo("foo #1"))
},
)
- sess = create_session()
+ sess = fixture_session()
f1 = Foo("foo #1")
b1 = Bar("bar #1")
b2 = Bar("bar #2")
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import fixtures
-from sqlalchemy.testing.fixtures import create_session
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
)
def _testlist(self, classes):
- sess = create_session()
+ sess = fixture_session()
# create objects in a linked list
count = 1
from sqlalchemy.testing.assertsql import CompiledSQL
from sqlalchemy.testing.assertsql import EachOf
from sqlalchemy.testing.assertsql import Or
+from sqlalchemy.testing.fixtures import fixture_session
from ._poly_fixtures import _Polymorphic
from ._poly_fixtures import Company
from ._poly_fixtures import Engineer
def test_load(self):
A, B, ASub, C = self.classes("A", "B", "ASub", "C")
- s = Session()
+ s = fixture_session()
q = (
s.query(A)
def test_load(self):
A, B, ASub, C = self.classes("A", "B", "ASub", "C")
- s = Session()
+ s = fixture_session()
q = (
s.query(A)
class FixtureLoadTest(_Polymorphic, testing.AssertsExecutionResults):
def test_person_selectin_subclasses(self):
- s = Session()
+ s = fixture_session()
q = s.query(Person).options(
selectin_polymorphic(Person, [Engineer, Manager])
)
eq_(result, self.all_employees)
def test_load_company_plus_employees(self):
- s = Session()
+ s = fixture_session()
q = (
s.query(Company)
.options(
)
a, b, c, d, e = self.classes("a", "b", "c", "d", "e")
- sess = Session()
+ sess = fixture_session()
sess.add_all([d(d_data="d1"), e(e_data="e1")])
sess.commit()
)
a, b, c, d, e = self.classes("a", "b", "c", "d", "e")
- sess = Session()
+ sess = fixture_session()
sess.add_all([d(d_data="d1"), e(e_data="e1")])
sess.commit()
)
a, b, c, d, e = self.classes("a", "b", "c", "d", "e")
- sess = Session()
+ sess = fixture_session()
sess.add_all([d(d_data="d1"), e(e_data="e1")])
sess.commit()
)
a, a1, a2 = self.classes("a", "a1", "a2")
- sess = Session()
+ sess = fixture_session()
a1_obj = a1()
a2_obj = a2()
Parent, ChildSubclass1, Other = self.classes(
"Parent", "ChildSubclass1", "Other"
)
- session = Session(enable_baked_queries=enable_baked)
+ session = fixture_session(enable_baked_queries=enable_baked)
def no_opt():
q = session.query(Parent).options(
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import is_
-from sqlalchemy.testing.fixtures import create_session
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
},
)
- session = create_session()
+ session = fixture_session()
c = Company(name="company1")
c.employees.append(
Manager(
else:
person_attribute_name = "name"
- session = create_session()
+ session = fixture_session()
dilbert = (
session.query(Engineer)
self.assert_sql_count(testing.db, go, 3)
def test_baseclass_lookup(self, get_dilbert):
- session = Session()
+ session = fixture_session()
dilbert = get_dilbert(session)
if self.redefine_colprop:
)
def test_subclass_lookup(self, get_dilbert):
- session = Session()
+ session = fixture_session()
dilbert = get_dilbert(session)
if self.redefine_colprop:
)
def test_baseclass_base_alias_filter(self, get_dilbert):
- session = Session()
+ session = fixture_session()
dilbert = get_dilbert(session)
# test selecting from the query, joining against
)
def test_subclass_base_alias_filter(self, get_dilbert):
- session = Session()
+ session = fixture_session()
dilbert = get_dilbert(session)
palias = people.alias("palias")
)
def test_baseclass_sub_table_filter(self, get_dilbert):
- session = Session()
+ session = fixture_session()
dilbert = get_dilbert(session)
# this unusual test is selecting from the plain people/engineers
)
def test_subclass_getitem(self, get_dilbert):
- session = Session()
+ session = fixture_session()
dilbert = get_dilbert(session)
is_(
def test_primary_table_only_for_requery(self):
- session = Session()
+ session = fixture_session()
if self.redefine_colprop:
person_attribute_name = "person_name"
else:
person_attribute_name = "name"
- session = Session()
+ session = fixture_session()
daboss = Boss(
status="BBB",
from sqlalchemy.testing import assert_raises
from sqlalchemy.testing import eq_
from sqlalchemy.testing.assertsql import CompiledSQL
-from sqlalchemy.testing.fixtures import create_session
+from sqlalchemy.testing.fixtures import fixture_session
from ._poly_fixtures import _Polymorphic
from ._poly_fixtures import _PolymorphicAliasedJoins
from ._poly_fixtures import _PolymorphicJoins
with_polymorphic is used.
"""
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
# For both joinedload() and subqueryload(), if the original q is
# not loading the subclass table, the joinedload doesn't happen.
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
def test_primary_eager_aliasing_subqueryload(self):
# test that subqueryload does not occur because the parent
# row cannot support it
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
def test_primary_eager_aliasing_selectinload(self):
# test that selectinload does not occur because the parent
# row cannot support it
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
# assert the JOINs don't over JOIN
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
For all mappers, ensure the primary key has been calculated as
just the "person_id" column.
"""
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.get(Person, e1.person_id),
Engineer(name="dilbert", primary_language="java"),
)
def test_get_two(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.get(Engineer, e1.person_id),
Engineer(name="dilbert", primary_language="java"),
)
def test_get_three(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.get(Manager, b1.person_id),
Boss(name="pointy haired boss", golf_swing="fore"),
)
def test_multi_join(self):
- sess = create_session()
+ sess = fixture_session()
e = aliased(Person)
c = aliased(Company)
q = (
)
def test_multi_join_future(self):
- sess = create_session(future=True)
+ sess = fixture_session(future=True)
e = aliased(Person)
c = aliased(Company)
)
def test_filter_on_subclass_one(self):
- sess = create_session()
+ sess = fixture_session()
eq_(sess.query(Engineer).all()[0], Engineer(name="dilbert"))
def test_filter_on_subclass_one_future(self):
- sess = create_session(future=True)
+ sess = fixture_session(future=True)
eq_(
sess.execute(select(Engineer)).scalar(),
Engineer(name="dilbert"),
)
def test_filter_on_subclass_two(self):
- sess = create_session()
+ sess = fixture_session()
eq_(sess.query(Engineer).first(), Engineer(name="dilbert"))
def test_filter_on_subclass_three(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Engineer)
.filter(Engineer.person_id == e1.person_id)
)
def test_filter_on_subclass_four(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Manager)
.filter(Manager.person_id == m1.person_id)
)
def test_filter_on_subclass_five(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Manager)
.filter(Manager.person_id == b1.person_id)
)
def test_filter_on_subclass_six(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Boss).filter(Boss.person_id == b1.person_id).one(),
Boss(name="pointy haired boss"),
)
def test_join_from_polymorphic_nonaliased_one(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Person)
.join("paperwork")
)
def test_join_from_polymorphic_nonaliased_one_future(self):
- sess = create_session(future=True)
+ sess = fixture_session(future=True)
eq_(
sess.execute(
select(Person)
)
def test_join_from_polymorphic_nonaliased_two(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Person)
.order_by(Person.person_id)
)
def test_join_from_polymorphic_nonaliased_three(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Engineer)
.order_by(Person.person_id)
)
def test_join_from_polymorphic_nonaliased_four(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Person)
.order_by(Person.person_id)
)
def test_join_from_polymorphic_flag_aliased_one(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Person)
.order_by(Person.person_id)
)
def test_join_from_polymorphic_flag_aliased_one_future(self):
- sess = create_session(future=True)
+ sess = fixture_session(future=True)
pa = aliased(Paperwork)
eq_(
)
def test_join_from_polymorphic_explicit_aliased_one(self):
- sess = create_session()
+ sess = fixture_session()
pa = aliased(Paperwork)
eq_(
sess.query(Person)
)
def test_join_from_polymorphic_flag_aliased_two(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Person)
.order_by(Person.person_id)
)
def test_join_from_polymorphic_explicit_aliased_two(self):
- sess = create_session()
+ sess = fixture_session()
pa = aliased(Paperwork)
eq_(
sess.query(Person)
)
def test_join_from_polymorphic_flag_aliased_three(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Engineer)
.order_by(Person.person_id)
)
def test_join_from_polymorphic_explicit_aliased_three(self):
- sess = create_session()
+ sess = fixture_session()
pa = aliased(Paperwork)
eq_(
sess.query(Engineer)
)
def test_join_from_polymorphic_aliased_four(self):
- sess = create_session()
+ sess = fixture_session()
pa = aliased(Paperwork)
eq_(
sess.query(Person)
)
def test_join_from_with_polymorphic_nonaliased_one(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Person)
.with_polymorphic(Manager)
)
def test_join_from_with_polymorphic_nonaliased_one_future(self):
- sess = create_session(future=True)
+ sess = fixture_session(future=True)
pm = with_polymorphic(Person, [Manager])
eq_(
)
def test_join_from_with_polymorphic_nonaliased_two(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Person)
.with_polymorphic([Manager, Engineer])
)
def test_join_from_with_polymorphic_nonaliased_three(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Person)
.with_polymorphic([Manager, Engineer])
)
def test_join_from_with_polymorphic_flag_aliased_one(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Person)
.with_polymorphic(Manager)
)
def test_join_from_with_polymorphic_explicit_aliased_one(self):
- sess = create_session()
+ sess = fixture_session()
pa = aliased(Paperwork)
eq_(
sess.query(Person)
)
def test_join_from_with_polymorphic_flag_aliased_two(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Person)
.with_polymorphic([Manager, Engineer])
)
def test_join_from_with_polymorphic_explicit_aliased_two(self):
- sess = create_session()
+ sess = fixture_session()
pa = aliased(Paperwork)
eq_(
sess.query(Person)
)
def test_join_from_with_polymorphic_aliased_three(self):
- sess = create_session()
+ sess = fixture_session()
pa = aliased(Paperwork)
eq_(
)
def test_join_to_polymorphic_nonaliased(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Company)
.join("employees")
)
def test_join_to_polymorphic_flag_aliased(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Company)
.join("employees", aliased=True)
)
def test_join_to_polymorphic_explicit_aliased(self):
- sess = create_session()
+ sess = fixture_session()
ea = aliased(Person)
eq_(
sess.query(Company)
)
def test_polymorphic_any_one(self):
- sess = create_session()
+ sess = fixture_session()
any_ = Company.employees.any(Person.name == "vlad")
eq_(sess.query(Company).filter(any_).all(), [c2])
def test_polymorphic_any_flag_alias_two(self):
- sess = create_session()
+ sess = fixture_session()
# test that the aliasing on "Person" does not bleed into the
# EXISTS clause generated by any()
any_ = Company.employees.any(Person.name == "wally")
)
def test_polymorphic_any_explicit_alias_two(self):
- sess = create_session()
+ sess = fixture_session()
# test that the aliasing on "Person" does not bleed into the
# EXISTS clause generated by any()
any_ = Company.employees.any(Person.name == "wally")
)
def test_polymorphic_any_three(self):
- sess = create_session()
+ sess = fixture_session()
any_ = Company.employees.any(Person.name == "vlad")
ea = aliased(Person)
eq_(
)
def test_polymorphic_any_eight(self):
- sess = create_session()
+ sess = fixture_session()
any_ = Engineer.machines.any(Machine.name == "Commodore 64")
eq_(
sess.query(Person).order_by(Person.person_id).filter(any_).all(),
)
def test_polymorphic_any_nine(self):
- sess = create_session()
+ sess = fixture_session()
any_ = Person.paperwork.any(Paperwork.description == "review #2")
eq_(
sess.query(Person).order_by(Person.person_id).filter(any_).all(),
)
def test_join_from_columns_or_subclass_one(self):
- sess = create_session()
+ sess = fixture_session()
expected = [("dogbert",), ("pointy haired boss",)]
eq_(sess.query(Manager.name).order_by(Manager.name).all(), expected)
def test_join_from_columns_or_subclass_two(self):
- sess = create_session()
+ sess = fixture_session()
expected = [("dogbert",), ("dogbert",), ("pointy haired boss",)]
eq_(
sess.query(Manager.name)
)
def test_join_from_columns_or_subclass_three(self):
- sess = create_session()
+ sess = fixture_session()
expected = [
("dilbert",),
("dilbert",),
)
def test_join_from_columns_or_subclass_four(self):
- sess = create_session()
+ sess = fixture_session()
# Load Person.name, joining from Person -> paperwork, get all
# the people.
expected = [
)
def test_join_from_columns_or_subclass_five(self):
- sess = create_session()
+ sess = fixture_session()
# same, on manager. get only managers.
expected = [("dogbert",), ("dogbert",), ("pointy haired boss",)]
eq_(
)
def test_join_from_columns_or_subclass_six(self):
- sess = create_session()
+ sess = fixture_session()
if self.select_type == "":
# this now raises, due to [ticket:1892]. Manager.person_id
# is now the "person_id" column on Manager. SQL is incorrect.
)
def test_join_from_columns_or_subclass_seven(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Manager)
.join(Paperwork, Manager.paperwork)
)
def test_join_from_columns_or_subclass_eight(self):
- sess = create_session()
+ sess = fixture_session()
expected = [("dogbert",), ("dogbert",), ("pointy haired boss",)]
eq_(
sess.query(Manager.name)
)
def test_join_from_columns_or_subclass_nine(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Manager.person_id)
.join(paperwork, Manager.person_id == paperwork.c.person_id)
)
def test_join_from_columns_or_subclass_ten(self):
- sess = create_session()
+ sess = fixture_session()
expected = [
("pointy haired boss", "review #1"),
("dogbert", "review #2"),
)
def test_join_from_columns_or_subclass_eleven(self):
- sess = create_session()
+ sess = fixture_session()
expected = [("pointy haired boss",), ("dogbert",), ("dogbert",)]
malias = aliased(Manager)
eq_(
)
def test_subclass_option_pathing(self):
- sess = create_session()
+ sess = fixture_session()
dilbert = (
sess.query(Person)
.options(defaultload(Engineer.machines).defer(Machine.name))
the select_table mapper.
"""
- sess = create_session()
+ sess = fixture_session()
name = "dogbert"
m1 = sess.query(Manager).filter(Manager.name == name).one()
assert m2.golf_swing == "fore"
def test_with_polymorphic_one(self):
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
self.assert_sql_count(testing.db, go, 1)
def test_with_polymorphic_two(self):
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
self.assert_sql_count(testing.db, go, 1)
def test_with_polymorphic_three(self):
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
self.assert_sql_count(testing.db, go, 3)
def test_with_polymorphic_four(self):
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
self.assert_sql_count(testing.db, go, 3)
def test_with_polymorphic_five(self):
- sess = create_session()
+ sess = fixture_session()
def go():
# limit the polymorphic join down to just "Person",
self.assert_sql_count(testing.db, go, 6)
def test_with_polymorphic_six(self):
- sess = create_session()
+ sess = fixture_session()
assert_raises(
sa_exc.InvalidRequestError,
)
def test_with_polymorphic_seven(self):
- sess = create_session()
+ sess = fixture_session()
# compare to entities without related collections to prevent
# additional lazy SQL from firing on loaded entities
eq_(
def test_relationship_to_polymorphic_one(self):
expected = self._company_with_emps_machines_fixture()
- sess = create_session()
+ sess = fixture_session()
def go():
# test load Companies with lazy load to 'employees'
def test_relationship_to_polymorphic_two(self):
expected = self._company_with_emps_machines_fixture()
- sess = create_session()
+ sess = fixture_session()
def go():
# with #2438, of_type() is recognized. This
def test_relationship_to_polymorphic_three(self):
expected = self._company_with_emps_machines_fixture()
- sess = create_session()
+ sess = fixture_session()
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
self.assert_sql_count(testing.db, go, count)
def test_joinedload_on_subclass(self):
- sess = create_session()
+ sess = fixture_session()
expected = [
Engineer(
name="dilbert",
self.assert_sql_count(testing.db, go, 1)
def test_subqueryload_on_subclass(self):
- sess = create_session()
+ sess = fixture_session()
expected = [
Engineer(
name="dilbert",
self.assert_sql_count(testing.db, go, 2)
def test_query_subclass_join_to_base_relationship(self):
- sess = create_session()
+ sess = fixture_session()
# non-polymorphic
eq_(sess.query(Engineer).join(Person.paperwork).all(), [e1, e2, e3])
def test_join_to_subclass(self):
- sess = create_session()
+ sess = fixture_session()
# TODO: these should all be deprecated (?) - these joins are on the
# core tables and should not be getting adapted, not sure why
)
def test_join_to_subclass_one(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Company)
.select_from(companies.join(people).join(engineers))
)
def test_join_to_subclass_two(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Company)
.join(people.join(engineers), "employees")
)
def test_join_to_subclass_three(self):
- sess = create_session()
+ sess = fixture_session()
ealias = aliased(Engineer)
eq_(
sess.query(Company)
)
def test_join_to_subclass_six(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Company)
.join(people.join(engineers), "employees")
)
def test_join_to_subclass_six_point_five(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Company)
.join(people.join(engineers), "employees")
)
def test_join_to_subclass_seven(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Company)
.join(people.join(engineers), "employees")
)
def test_join_to_subclass_eight(self):
- sess = create_session()
+ sess = fixture_session()
eq_(sess.query(Person).join(Engineer.machines).all(), [e1, e2, e3])
def test_join_to_subclass_nine(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Company)
.select_from(companies.join(people).join(engineers))
)
def test_join_to_subclass_ten(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Company)
.join("employees")
)
def test_join_to_subclass_eleven(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Company)
.select_from(companies.join(people).join(engineers))
)
def test_join_to_subclass_twelve(self):
- sess = create_session()
+ sess = fixture_session()
eq_(sess.query(Person).join(Engineer.machines).all(), [e1, e2, e3])
def test_join_to_subclass_thirteen(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Person)
.join(Engineer.machines)
)
def test_join_to_subclass_fourteen(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Company).join("employees", Engineer.machines).all(),
[c1, c2],
)
def test_join_to_subclass_fifteen(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Company)
.join("employees", Engineer.machines)
)
def test_join_to_subclass_sixteen(self):
- sess = create_session()
+ sess = fixture_session()
# non-polymorphic
eq_(sess.query(Engineer).join(Engineer.machines).all(), [e1, e2, e3])
def test_join_to_subclass_seventeen(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Engineer)
.join(Engineer.machines)
)
def test_join_and_thru_polymorphic_nonaliased_one(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Company)
.join(Company.employees)
)
def test_join_and_thru_polymorphic_aliased_one(self):
- sess = create_session()
+ sess = fixture_session()
ea = aliased(Person)
pa = aliased(Paperwork)
eq_(
)
def test_join_through_polymorphic_nonaliased_one(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Company)
.join(Company.employees)
)
def test_join_through_polymorphic_nonaliased_two(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Company)
.join(Company.employees)
)
def test_join_through_polymorphic_nonaliased_three(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Company)
.join(Company.employees)
)
def test_join_through_polymorphic_nonaliased_four(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Company)
.join(Company.employees)
)
def test_join_through_polymorphic_nonaliased_five(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Company)
.join("employees")
)
def test_join_through_polymorphic_nonaliased_six(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Company)
.join("employees")
)
def test_join_through_polymorphic_aliased_one(self):
- sess = create_session()
+ sess = fixture_session()
ea = aliased(Person)
pa = aliased(Paperwork)
eq_(
)
def test_join_through_polymorphic_aliased_two(self):
- sess = create_session()
+ sess = fixture_session()
ea = aliased(Person)
pa = aliased(Paperwork)
eq_(
)
def test_join_through_polymorphic_aliased_three(self):
- sess = create_session()
+ sess = fixture_session()
ea = aliased(Person)
pa = aliased(Paperwork)
eq_(
)
def test_join_through_polymorphic_aliased_four(self):
- sess = create_session()
+ sess = fixture_session()
ea = aliased(Person)
pa = aliased(Paperwork)
eq_(
)
def test_join_through_polymorphic_aliased_five(self):
- sess = create_session()
+ sess = fixture_session()
ea = aliased(Person)
pa = aliased(Paperwork)
eq_(
)
def test_join_through_polymorphic_aliased_six(self):
- sess = create_session()
+ sess = fixture_session()
pa = aliased(Paperwork)
ea = aliased(Person)
eq_(
)
def test_explicit_polymorphic_join_one(self):
- sess = create_session()
+ sess = fixture_session()
# join from Company to Engineer; join condition formulated by
# ORMJoin using regular table foreign key connections. Engineer
)
def test_explicit_polymorphic_join_two(self):
- sess = create_session()
+ sess = fixture_session()
# same, using explicit join condition. Query.join() must
# adapt the on clause here to match the subquery wrapped around
)
def test_filter_on_baseclass(self):
- sess = create_session()
+ sess = fixture_session()
eq_(sess.query(Person).order_by(Person.person_id).all(), all_employees)
eq_(
sess.query(Person).order_by(Person.person_id).first(),
)
def test_from_alias(self):
- sess = create_session()
+ sess = fixture_session()
palias = aliased(Person)
eq_(
sess.query(palias)
)
def test_self_referential_one(self):
- sess = create_session()
+ sess = fixture_session()
palias = aliased(Person)
expected = [(m1, e1), (m1, e2), (m1, b1)]
def test_self_referential_two(self):
- sess = create_session()
+ sess = fixture_session()
palias = aliased(Person)
expected = [(m1, e1), (m1, e2), (m1, b1)]
def test_self_referential_two_point_five(self):
"""Using two aliases, the above case works."""
- sess = create_session()
+ sess = fixture_session()
palias = aliased(Person)
palias2 = aliased(Person)
def test_self_referential_two_future(self):
# TODO: this is the SECOND test *EVER* of an aliased class of
# an aliased class.
- sess = create_session(future=True)
+ sess = fixture_session(future=True)
expected = [(m1, e1), (m1, e2), (m1, b1)]
# not aliasing the first class
# TODO: this is the first test *EVER* of an aliased class of
# an aliased class. we should add many more tests for this.
# new case added in Id810f485c5f7ed971529489b84694e02a3356d6d
- sess = create_session(future=True)
+ sess = fixture_session(future=True)
expected = [(m1, e1), (m1, e2), (m1, b1)]
# aliasing the first class
# second "filter" from hitting it, which would pollute the
# subquery and usually results in recursion overflow errors
# within the adaption.
- sess = create_session()
+ sess = fixture_session()
subq = (
sess.query(engineers.c.person_id)
.filter(Engineer.primary_language == "java")
eq_(sess.query(Person).filter(Person.person_id.in_(subq)).one(), e1)
def test_mixed_entities_one(self):
- sess = create_session()
+ sess = fixture_session()
expected = [
(
_join_to_poly_wp_three,
)
def test_mixed_entities_join_to_poly(self, q):
- sess = create_session()
+ sess = fixture_session()
expected = [
("dilbert", "MegaCorp, Inc."),
("wally", "MegaCorp, Inc."),
)
def test_mixed_entities_two(self):
- sess = create_session()
+ sess = fixture_session()
expected = [
("java", "MegaCorp, Inc."),
("cobol", "Elbonia, Inc."),
)
def test_mixed_entities_three(self):
- sess = create_session()
+ sess = fixture_session()
palias = aliased(Person)
expected = [
(
)
def test_mixed_entities_four(self):
- sess = create_session()
+ sess = fixture_session()
palias = aliased(Person)
expected = [
(
)
def test_mixed_entities_five(self):
- sess = create_session()
+ sess = fixture_session()
palias = aliased(Person)
expected = [("vlad", "Elbonia, Inc.", "dilbert")]
eq_(
)
def test_mixed_entities_six(self):
- sess = create_session()
+ sess = fixture_session()
palias = aliased(Person)
expected = [
("manager", "dogbert", "engineer", "dilbert"),
)
def test_mixed_entities_seven(self):
- sess = create_session()
+ sess = fixture_session()
expected = [
("dilbert", "tps report #1"),
("dilbert", "tps report #2"),
)
def test_mixed_entities_eight(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(func.count(Person.person_id))
.filter(Engineer.primary_language == "java")
)
def test_mixed_entities_nine(self):
- sess = create_session()
+ sess = fixture_session()
expected = [("Elbonia, Inc.", 1), ("MegaCorp, Inc.", 4)]
eq_(
sess.query(Company.name, func.count(Person.person_id))
)
def test_mixed_entities_ten(self):
- sess = create_session()
+ sess = fixture_session()
expected = [("Elbonia, Inc.", 1), ("MegaCorp, Inc.", 4)]
eq_(
sess.query(Company.name, func.count(Person.person_id))
)
# def test_mixed_entities(self):
- # sess = create_session()
+ # sess = fixture_session()
# TODO: I think raise error on these for now. different
# inheritance/loading schemes have different results here,
# all incorrect
# [])
# def test_mixed_entities(self):
- # sess = create_session()
+ # sess = fixture_session()
# eq_(sess.query(
# Person.name,
# Engineer.primary_language,
# [])
def test_mixed_entities_eleven(self):
- sess = create_session()
+ sess = fixture_session()
expected = [("java",), ("c++",), ("cobol",)]
eq_(
sess.query(Engineer.primary_language)
)
def test_mixed_entities_twelve(self):
- sess = create_session()
+ sess = fixture_session()
expected = [("vlad", "Elbonia, Inc.")]
eq_(
sess.query(Person.name, Company.name)
)
def test_mixed_entities_thirteen(self):
- sess = create_session()
+ sess = fixture_session()
expected = [("pointy haired boss", "fore")]
eq_(sess.query(Boss.name, Boss.golf_swing).all(), expected)
def test_mixed_entities_fourteen(self):
- sess = create_session()
+ sess = fixture_session()
expected = [("dilbert", "java"), ("wally", "c++"), ("vlad", "cobol")]
eq_(
sess.query(Engineer.name, Engineer.primary_language).all(),
)
def test_mixed_entities_fifteen(self):
- sess = create_session()
+ sess = fixture_session()
expected = [
(
)
def test_mixed_entities_sixteen(self):
- sess = create_session()
+ sess = fixture_session()
expected = [
(
Engineer(
)
def test_mixed_entities_seventeen(self):
- sess = create_session()
+ sess = fixture_session()
expected = [("pointy haired boss",), ("dogbert",)]
eq_(sess.query(Manager.name).all(), expected)
def test_mixed_entities_eighteen(self):
- sess = create_session()
+ sess = fixture_session()
expected = [("pointy haired boss foo",), ("dogbert foo",)]
eq_(sess.query(Manager.name + " foo").all(), expected)
def test_mixed_entities_nineteen(self):
- sess = create_session()
+ sess = fixture_session()
row = (
sess.query(Engineer.name, Engineer.primary_language)
.filter(Engineer.name == "dilbert")
assert row.primary_language == "java"
def test_correlation_one(self):
- sess = create_session()
+ sess = fixture_session()
# this for a long time did not work with PolymorphicAliased and
# PolymorphicUnions, which was due to the no_replacement_traverse
)
def test_correlation_two(self):
- sess = create_session()
+ sess = fixture_session()
paliased = aliased(Person)
)
def test_correlation_three(self):
- sess = create_session()
+ sess = fixture_session()
paliased = aliased(Person, flat=True)
class PolymorphicTest(_PolymorphicTestBase, _Polymorphic):
def test_join_to_subclass_four(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Person)
.select_from(people.join(engineers))
)
def test_join_to_subclass_five(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Person)
.select_from(people.join(engineers))
def test_correlation_w_polymorphic(self):
- sess = create_session()
+ sess = fixture_session()
p_poly = with_polymorphic(Person, "*")
def test_correlation_w_polymorphic_flat(self):
- sess = create_session()
+ sess = fixture_session()
p_poly = with_polymorphic(Person, "*", flat=True)
# aliased(polymorphic) will normally do the old-school
# "(SELECT * FROM a JOIN b ...) AS anon_1" thing.
# this is the safest
- sess = create_session()
+ sess = fixture_session()
palias = aliased(Person)
self.assert_compile(
sess.query(palias, Company.name)
)
def test_flat_aliased_w_select_from(self):
- sess = create_session()
+ sess = fixture_session()
palias = aliased(Person, flat=True)
self.assert_compile(
sess.query(palias, Company.name)
class PolymorphicUnionsTest(_PolymorphicTestBase, _PolymorphicUnions):
def test_subqueryload_on_subclass_uses_path_correctly(self):
- sess = create_session()
+ sess = fixture_session()
expected = [
Engineer(
name="dilbert",
class PolymorphicJoinsTest(_PolymorphicTestBase, _PolymorphicJoins):
def test_having_group_by(self):
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Person.name)
.group_by(Person.name)
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import fixtures
-from sqlalchemy.testing.fixtures import create_session
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
),
)
- session = create_session()
+ session = fixture_session()
a1 = Assembly(name="a1")
),
)
- session = create_session()
+ session = fixture_session()
s = SpecLine(follower=Product(name="p1"))
s2 = SpecLine(follower=Detail(name="d1"))
polymorphic_identity="raster_document",
)
- session = create_session()
+ session = fixture_session()
a1 = Assembly(name="a1")
a1.specification.append(SpecLine(follower=Detail(name="d1")))
polymorphic_identity="raster_document",
)
- session = create_session()
+ session = fixture_session()
a1 = Assembly(name="a1")
a1.documents.append(RasterDocument("doc2"))
mapper(Assembly, inherits=Product, polymorphic_identity="assembly")
- session = create_session()
+ session = fixture_session()
a1 = Assembly(name="a1")
a1.specification.append(SpecLine(follower=Detail(name="d1")))
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import is_
from sqlalchemy.testing.entities import ComparableEntity
-from sqlalchemy.testing.fixtures import create_session
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
def test_has(self):
p1 = Person(name="dogbert")
e1 = Engineer(name="dilbert", primary_language="java", reports_to=p1)
- sess = create_session()
+ sess = fixture_session()
sess.add(p1)
sess.add(e1)
sess.flush()
def test_oftype_aliases_in_exists(self):
e1 = Engineer(name="dilbert", primary_language="java")
e2 = Engineer(name="wally", primary_language="c++", reports_to=e1)
- sess = create_session()
+ sess = fixture_session()
sess.add_all([e1, e2])
sess.flush()
eq_(
def test_join(self):
p1 = Person(name="dogbert")
e1 = Engineer(name="dilbert", primary_language="java", reports_to=p1)
- sess = create_session()
+ sess = fixture_session()
sess.add(p1)
sess.add(e1)
sess.flush()
def test_has(self):
m1 = Manager(name="dogbert")
e1 = Engineer(name="dilbert", primary_language="java", reports_to=m1)
- sess = create_session()
+ sess = fixture_session()
sess.add(m1)
sess.add(e1)
sess.flush()
def test_join(self):
m1 = Manager(name="dogbert")
e1 = Engineer(name="dilbert", primary_language="java", reports_to=m1)
- sess = create_session()
+ sess = fixture_session()
sess.add(m1)
sess.add(e1)
sess.flush()
e2 = Engineer(name="dilbert", primary_language="c++", reports_to=m2)
e3 = Engineer(name="etc", primary_language="c++")
- sess = create_session()
+ sess = fixture_session()
sess.add_all([m1, m2, e1, e2, e3])
sess.flush()
sess.expunge_all()
e2 = Engineer(name="wally", primary_language="c++", reports_to=m2)
e3 = Engineer(name="etc", primary_language="c++")
- sess = create_session()
+ sess = fixture_session()
sess.add(m1)
sess.add(m2)
sess.add(e1)
def _two_obj_fixture(self):
e1 = Engineer(name="wally")
e2 = Engineer(name="dilbert", reports_to=e1)
- sess = Session()
+ sess = fixture_session()
sess.add_all([e1, e2])
sess.commit()
return sess
def _five_obj_fixture(self):
- sess = Session()
+ sess = fixture_session()
e1, e2, e3, e4, e5 = [Engineer(name="e%d" % (i + 1)) for i in range(5)]
e3.reports_to = e1
e4.reports_to = e2
def test_not_contains(self):
Organization = self.classes.Organization
- sess = create_session()
+ sess = fixture_session()
e1 = sess.query(Person).filter(Engineer.name == "e1").one()
eq_(
)
def test_any(self):
- sess = create_session()
+ sess = fixture_session()
Organization = self.classes.Organization
eq_(
def test_query_crit(self):
Child1, Child2 = self.classes.Child1, self.classes.Child2
- sess = create_session()
+ sess = fixture_session()
c11, c12, c13 = Child1(), Child1(), Child1()
c21, c22, c23 = Child2(), Child2(), Child2()
c11.left_child2 = c22
def test_eager_join(self):
Child1, Child2 = self.classes.Child1, self.classes.Child2
- sess = create_session()
+ sess = fixture_session()
c1 = Child1()
c1.left_child2 = Child2()
sess.add(c1)
def test_subquery_load(self):
Child1, Child2 = self.classes.Child1, self.classes.Child2
- sess = create_session()
+ sess = fixture_session()
c1 = Child1()
c1.left_child2 = Child2()
sess.add(c1)
def test_joinedload(self):
Parent = self.classes.Parent
- sess = Session()
+ sess = fixture_session()
def go():
eq_(
def test_contains_eager(self):
Parent = self.classes.Parent
Sub = self.classes.Sub
- sess = Session()
+ sess = fixture_session()
def go():
eq_(
def test_subq_through_related(self):
Parent = self.classes.Parent
Base = self.classes.Base
- sess = Session()
+ sess = fixture_session()
def go():
eq_(
Parent = self.classes.Parent
Base = self.classes.Base
pa = aliased(Parent)
- sess = Session()
+ sess = fixture_session()
def go():
eq_(
def test_joinedload(self):
Subparent = self.classes.Subparent
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
def test_contains_eager(self):
Subparent = self.classes.Subparent
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
def test_subqueryload(self):
Subparent = self.classes.Subparent
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
C = self.classes.C
D = self.classes.D
- session = Session()
+ session = fixture_session()
d = session.query(D).one()
a_poly = with_polymorphic(A, [B, C])
C = self.classes.C
D = self.classes.D
- session = Session()
+ session = fixture_session()
d = session.query(D).one()
def go():
C = self.classes.C
D = self.classes.D
- session = Session()
+ session = fixture_session()
d = session.query(D).one()
a_poly = with_polymorphic(A, [B, C])
C = self.classes.C
D = self.classes.D
- session = Session()
+ session = fixture_session()
d = session.query(D).one()
def go():
def test_2617(self):
A = self.classes.A
- session = Session()
+ session = fixture_session()
def go():
a1 = session.query(A).first()
def test_one(self):
Parent, Base1, Base2, Sub1, Sub2, EP1, EP2 = self._classes()
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(Parent)
.join(Parent.sub1, Sub1.sub2)
s2a = aliased(Sub2, flat=True)
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(Parent).join(Parent.sub1).join(s2a, Sub1.sub2),
"SELECT parent.id AS parent_id, parent.data AS parent_data "
def test_three(self):
Parent, Base1, Base2, Sub1, Sub2, EP1, EP2 = self._classes()
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(Base1).join(Base1.sub2).join(Sub2.ep1).join(Sub2.ep2),
"SELECT base1.id AS base1_id, base1.data AS base1_data "
def test_four(self):
Parent, Base1, Base2, Sub1, Sub2, EP1, EP2 = self._classes()
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(Sub2)
.join(Base1, Base1.id == Sub2.base1_id)
def test_five(self):
Parent, Base1, Base2, Sub1, Sub2, EP1, EP2 = self._classes()
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(Sub2)
.join(Sub1, Sub1.id == Sub2.base1_id)
def test_six_legacy(self):
Parent, Base1, Base2, Sub1, Sub2, EP1, EP2 = self._classes()
- s = Session()
+ s = fixture_session()
# as of from_self() changing in
# I3abfb45dd6e50f84f29d39434caa0b550ce27864,
def test_seven_legacy(self):
Parent, Base1, Base2, Sub1, Sub2, EP1, EP2 = self._classes()
- s = Session()
+ s = fixture_session()
# as of from_self() changing in
# I3abfb45dd6e50f84f29d39434caa0b550ce27864,
def test_joined_load_lastlink_subclass(self):
Foo, User, SubBar = self.classes("Foo", "User", "SubBar")
- s = Session()
+ s = fixture_session()
foo_polymorphic = with_polymorphic(Foo, "*", aliased=True)
def test_joined_load_lastlink_baseclass(self):
Foo, User, Bar = self.classes("Foo", "User", "Bar")
- s = Session()
+ s = fixture_session()
foo_polymorphic = with_polymorphic(Foo, "*", aliased=True)
def test_contains_eager_multi_alias(self):
X, B, A = self.classes("X", "B", "A")
- s = Session()
+ s = fixture_session()
a_b_alias = aliased(B, name="a_b")
b_x_alias = aliased(X, name="b_x")
def test_query(self):
Thing = self.classes.Thing
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Thing),
"SELECT things.id AS things_id, "
cls = fn()
Link = self.classes.Link
- session = Session()
+ session = fixture_session()
q = session.query(cls).options(
joinedload(cls.links).joinedload(Link.child).joinedload(cls.links)
)
parent_cls = fn()
Link = self.classes.Link
- session = Session()
+ session = fixture_session()
q = session.query(Link).options(
joinedload(Link.child).joinedload(parent_cls.owner)
)
poly = with_polymorphic(Parent, [Sub1])
- session = Session()
+ session = fixture_session()
q = session.query(poly).options(
joinedload(poly.Sub1.links)
.joinedload(Link.child.of_type(Sub1))
poly = with_polymorphic(Parent, [Sub1])
- session = Session()
+ session = fixture_session()
q = session.query(poly).options(
joinedload(poly.Sub1.links, innerjoin=True)
.joinedload(Link.child.of_type(Sub1), innerjoin=True)
Parent = self.classes.Parent
Link = self.classes.Link
- session = Session()
+ session = fixture_session()
session.add_all([Parent(), Parent()])
# represents "Parent" and "Sub1" rows
t1_alias = aliased(Target)
t2_alias = aliased(Target)
- sess = Session()
+ sess = fixture_session()
q = (
sess.query(Root)
.join(s1_alias, Root.sub1)
t1_alias = aliased(Target)
t2_alias = aliased(Target)
- sess = Session()
+ sess = fixture_session()
q = (
sess.query(Root)
.join(s1_alias, Root.sub1)
self.classes.Sub1,
)
- sess = Session()
+ sess = fixture_session()
q = sess.query(Root).options(
joinedload(Root.sub1).joinedload(Sub1.target),
joinedload(Root.intermediate)
def _two_join_fixture(self):
B, C, D = (self.classes.B, self.classes.C, self.classes.D)
- s = Session()
+ s = fixture_session()
return (
s.query(B.name, C.name, D.name)
.select_from(B)
def test_query(self):
Engineer, Manager = self.classes("Engineer", "Manager")
- sess = Session()
+ sess = fixture_session()
# eager join is both from Enginer->LastSeen as well as
# Manager->LastSeen. In the case of Manager->LastSeen,
def test_load_m2o_emit_query(self):
Other, Child1 = self.classes("Other", "Child1")
- s = Session()
+ s = fixture_session()
obj = s.query(Other).first()
def test_load_m2o_use_get(self):
Other, Child1 = self.classes("Other", "Child1")
- s = Session()
+ s = fixture_session()
obj = s.query(Other).first()
c1 = s.query(Child1).first()
from sqlalchemy.orm import Session
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
)
mapper(Child, child, inherits=Base, polymorphic_identity="child")
- sess = Session()
+ sess = fixture_session()
# 2. use an id other than "1" here so can't rely on
# the two inserts having the same id
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
-from sqlalchemy.orm import sessionmaker
from sqlalchemy.orm import subqueryload
from sqlalchemy.orm import with_polymorphic
from sqlalchemy.testing import AssertsCompiledSQL
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
from sqlalchemy.testing.assertsql import CompiledSQL
-from sqlalchemy.testing.fixtures import create_session
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
self.classes.Engineer,
)
- session = create_session()
+ session = fixture_session()
m1 = Manager(name="Tom", manager_data="knows how to manage things")
e1 = Engineer(name="Kurt", engineer_info="knows how to hack")
def test_from_self_legacy(self):
Engineer = self.classes.Engineer
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated(r"The Query.from_self\(\) method"):
self.assert_compile(
sess.query(Engineer).from_self(),
def test_select_from_aliased_w_subclass(self):
Engineer = self.classes.Engineer
- sess = create_session()
+ sess = fixture_session()
a1 = aliased(Engineer)
self.assert_compile(
def test_union_modifiers(self):
Engineer, Manager = self.classes("Engineer", "Manager")
- sess = create_session()
+ sess = fixture_session()
q1 = sess.query(Engineer).filter(Engineer.engineer_info == "foo")
q2 = sess.query(Manager).filter(Manager.manager_data == "bar")
Engineer, Manager = self.classes("Engineer", "Manager")
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Engineer)
def test_from_self_count(self):
Engineer = self.classes.Engineer
- sess = create_session()
+ sess = fixture_session()
col = func.count(literal_column("*"))
with testing.expect_deprecated(r"The Query.from_self\(\) method"):
self.assert_compile(
def test_select_from_count(self):
Manager, Engineer = (self.classes.Manager, self.classes.Engineer)
- sess = create_session()
+ sess = fixture_session()
m1 = Manager(name="Tom", manager_data="data1")
e1 = Engineer(name="Kurt", engineer_info="knows how to hack")
sess.add_all([m1, e1])
self.classes.Engineer,
)
- sess = create_session()
+ sess = fixture_session()
m1 = Manager(name="Tom", manager_data="data1")
m2 = Manager(name="Tom2", manager_data="data2")
e1 = Engineer(name="Kurt", engineer_info="knows how to hack")
self.classes.Engineer,
)
- sess = create_session()
+ sess = fixture_session()
r1, r2, r3, r4 = (
Report(name="r1"),
Report(name="r2"),
Manager = self.classes.Manager
Engineer = self.classes.Engineer
- sess = create_session()
+ sess = fixture_session()
m1 = Manager(name="Tom", manager_data="data1")
m2 = Manager(name="Tom2", manager_data="data2")
e1 = Engineer(name="Kurt", engineer_info="data3")
def test_exists_standalone(self):
Engineer = self.classes.Engineer
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(
self.classes.Engineer,
)
- sess = create_session()
+ sess = fixture_session()
m1 = Manager(name="Tom", manager_data="data1")
r1 = Report(employee=m1)
self.classes.Engineer,
)
- sess = create_session()
+ sess = fixture_session()
m1 = Manager(name="Tom", manager_data="data1")
r1 = Report(employee=m1)
def test_subquery_load(self):
Employee, Stuff, Manager = self.classes("Employee", "Stuff", "Manager")
- sess = create_session()
+ sess = fixture_session()
with self.sql_execution_asserter(testing.db) as asserter:
sess.query(Manager).options(subqueryload("stuff")).all()
inherits=Engineer,
polymorphic_identity="juniorengineer",
)
- sess = sessionmaker()()
+ sess = fixture_session()
c1 = Company(name="c1")
c2 = Company(name="c2")
mapper(Employee, employees, polymorphic_on=employees.c.type)
mapper(Engineer, inherits=Employee, polymorphic_identity="engineer")
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Company).outerjoin(
Company.employee.of_type(Engineer),
mapper(Employee, employees)
mapper(Engineer, inherits=Employee)
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Company, Engineer.name).join(
Engineer, Company.company_id == Engineer.company_id
mapper(Employee, employees, polymorphic_on=employees.c.type)
mapper(Engineer, inherits=Employee, polymorphic_identity="engineer")
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Company, Engineer.name).outerjoin("engineers"),
"SELECT companies.company_id AS companies_company_id, "
mapper(Engineer, inherits=Employee, polymorphic_identity="engineer")
eng_alias = aliased(Engineer)
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Company, eng_alias.name).outerjoin(
eng_alias, Company.engineers
mapper(Employee, employees, polymorphic_on=employees.c.type)
mapper(Engineer, inherits=Employee, polymorphic_identity="engineer")
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Company, Engineer).outerjoin(
Engineer, Company.company_id == Engineer.company_id
mapper(Engineer, inherits=Employee, polymorphic_identity="engineer")
eng_alias = aliased(Engineer)
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Company, eng_alias).outerjoin(
eng_alias, Company.company_id == eng_alias.company_id
mapper(Employee, employees, polymorphic_on=employees.c.type)
mapper(Engineer, inherits=Employee, polymorphic_identity="engineer")
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Company, Engineer).outerjoin(Engineer),
"SELECT companies.company_id AS companies_company_id, "
mapper(Engineer, inherits=Employee, polymorphic_identity="engineer")
eng_alias = aliased(Engineer)
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Company, eng_alias).outerjoin(eng_alias),
"SELECT companies.company_id AS companies_company_id, "
)
mapper(Engineer, inherits=Employee, polymorphic_identity="engineer")
- sess = create_session()
+ sess = fixture_session()
engineer_count = (
sess.query(func.count(Engineer.employee_id))
.select_from(Engineer)
mapper(Engineer, inherits=Employee, polymorphic_identity="engineer")
mapper(Manager, inherits=Employee, polymorphic_identity="manager")
- s = create_session()
+ s = fixture_session()
q1 = (
s.query(Engineer)
inherits=Engineer,
polymorphic_identity="juniorengineer",
)
- sess = sessionmaker()()
+ sess = fixture_session()
c1 = Company(name="c1")
c2 = Company(name="c2")
Parent = self.classes.Parent
SubChild1 = self.classes.SubChild1
- s = Session()
+ s = fixture_session()
p1 = s.query(Parent).options(joinedload(Parent.s1)).all()[0]
eq_(p1.__dict__["s1"], SubChild1(name="sc1_1"))
Child = self.classes.Child
SubChild1 = self.classes.SubChild1
- s = Session()
+ s = fixture_session()
p1, c1 = s.query(Parent, Child).outerjoin(Parent.s1).all()[0]
eq_(c1, SubChild1(name="sc1_1"))
Parent = self.classes.Parent
Child = self.classes.Child
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(Parent, Child).outerjoin(Parent.s1),
def test_assert_joinedload_sql(self):
Parent = self.classes.Parent
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(Parent).options(joinedload(Parent.s1)),
)
mapper(Manager, inherits=Employee, polymorphic_identity="manager")
- sess = create_session()
+ sess = fixture_session()
sess.add(Person(name="p1"))
sess.add(Employee(name="e1", employee_data="ed1"))
sess.add(Manager(name="m1", employee_data="ed2", manager_data="md1"))
[self.classes.Boss, self.classes.Manager, self.classes.Engineer],
self._with_poly_fixture(),
)
- s = Session()
+ s = fixture_session()
q = s.query(poly.Boss)
self.assert_compile(
q,
poly = self._with_poly_fixture()
- s = Session()
+ s = fixture_session()
q = s.query(Boss).with_polymorphic(Boss, poly)
self.assert_compile(
q,
def test_single_inh_subclass_join_joined_inh_subclass(self):
Boss, Engineer = self.classes("Boss", "Engineer")
- s = Session()
+ s = fixture_session()
q = s.query(Boss).join(Engineer, Engineer.manager_id == Boss.id)
self._with_poly_fixture(),
)
- s = Session()
+ s = fixture_session()
q = s.query(Boss).join(
poly.Engineer, poly.Engineer.manager_id == Boss.id
def test_joined_inh_subclass_join_single_inh_subclass(self):
Engineer = self.classes.Engineer
Boss = self.classes.Boss
- s = Session()
+ s = fixture_session()
q = s.query(Engineer).join(Boss, Engineer.manager_id == Boss.id)
foo = Foo()
- session = Session()
+ session = fixture_session()
session.add(foo)
session.flush()
def test_persist_bar(self):
Bar = self.classes.Bar
bar = Bar()
- session = Session()
+ session = fixture_session()
session.add(bar)
session.flush()
from sqlalchemy import exc
from sqlalchemy import or_
from sqlalchemy import testing
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import with_polymorphic
from sqlalchemy.testing import eq_
+from sqlalchemy.testing.fixtures import fixture_session
from ._poly_fixtures import _Polymorphic
from ._poly_fixtures import _PolymorphicAliasedJoins
from ._poly_fixtures import _PolymorphicFixtureBase
class WithPolymorphicAPITest(_Polymorphic, _PolymorphicFixtureBase):
def test_no_use_flat_and_aliased(self):
- sess = create_session()
+ sess = fixture_session()
subq = sess.query(Person).subquery()
class _WithPolymorphicBase(_PolymorphicFixtureBase):
def test_join_base_to_sub(self):
- sess = create_session()
+ sess = fixture_session()
pa = with_polymorphic(Person, [Engineer])
def go():
self.assert_sql_count(testing.db, go, 1)
def test_col_expression_base_plus_two_subs(self):
- sess = create_session()
+ sess = fixture_session()
pa = with_polymorphic(Person, [Engineer, Manager])
eq_(
)
def test_join_to_join_entities(self):
- sess = create_session()
+ sess = fixture_session()
pa = with_polymorphic(Person, [Engineer])
pa_alias = with_polymorphic(Person, [Engineer], aliased=True)
)
def test_join_to_join_columns(self):
- sess = create_session()
+ sess = fixture_session()
pa = with_polymorphic(Person, [Engineer])
pa_alias = with_polymorphic(Person, [Engineer], aliased=True)
from sqlalchemy.testing import fixtures
from sqlalchemy.testing.assertsql import CompiledSQL
from sqlalchemy.testing.fixtures import ComparableEntity
+from sqlalchemy.testing.fixtures import fixture_session
class PartitionByFixture(fixtures.DeclarativeMappedTest):
def test_lazyload(self):
A, B = self.classes("A", "B")
- sess = Session()
+ sess = fixture_session()
a1 = sess.query(A).first()
with self.sql_execution_asserter() as asserter:
def test_joinedload(self):
A, B = self.classes("A", "B")
- sess = Session()
+ sess = fixture_session()
with self.sql_execution_asserter() as asserter:
# note this is many-to-one. use_get is unconditionally turned
def test_selectinload(self):
A, B = self.classes("A", "B")
- sess = Session()
+ sess = fixture_session()
with self.sql_execution_asserter() as asserter:
# note this is many-to-one. use_get is unconditionally turned
def test_join(self):
A, B = self.classes("A", "B")
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(A).join(A.b),
from sqlalchemy import Integer
from sqlalchemy import select
from sqlalchemy import String
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
self.classes.Keyword,
)
- sess = create_session()
+ sess = fixture_session()
item1 = Item("item1")
item2 = Item("item2")
item1.keywords.append(
self.classes.Keyword,
)
- sess = create_session()
+ sess = fixture_session()
item1 = Item("item1")
item1.keywords.append(
KeywordAssociation(Keyword("blue"), "blue_assoc")
self.classes.Keyword,
)
- sess = create_session()
+ sess = fixture_session()
item1 = Item("item1")
item2 = Item("item2")
item1.keywords.append(
item_keywords = self.tables.item_keywords
Keyword = self.classes.Keyword
- sess = create_session()
+ sess = fixture_session()
item1 = Item("item1")
item2 = Item("item2")
item1.keywords.append(
)
sess.add_all((item1, item2))
sess.flush()
- eq_(select(func.count("*")).select_from(item_keywords).scalar(), 3)
+ eq_(
+ sess.connection().scalar(
+ select(func.count("*")).select_from(item_keywords)
+ ),
+ 3,
+ )
sess.delete(item1)
sess.delete(item2)
sess.flush()
- eq_(select(func.count("*")).select_from(item_keywords).scalar(), 0)
+ eq_(
+ sess.connection().scalar(
+ select(func.count("*")).select_from(item_keywords)
+ ),
+ 0,
+ )
from sqlalchemy import testing
from sqlalchemy import text
from sqlalchemy.orm import backref
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
+from sqlalchemy.orm import Session
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
cls.classes.Thing,
)
- session = create_session(connection)
+ session = Session(connection)
o = Owner()
c = Category(name="Some Category")
session.flush()
- def test_noorm(self):
+ def test_noorm(self, connection):
"""test the control case"""
tests, options, categories = (
# not orm style correct query
print("Obtaining correct results without orm")
- result = (
+ result = connection.execute(
sa.select(tests.c.id, categories.c.name)
.where(
sa.and_(
),
)
)
- .execute()
- .fetchall()
- )
+ ).fetchall()
eq_(result, [(1, "Some Category"), (3, "Some Category")])
def test_withoutjoinedload(self):
self.tables.options,
)
- s = create_session()
+ s = fixture_session()
result = (
s.query(Thing)
.select_from(
self.tables.options,
)
- s = create_session()
+ s = fixture_session()
q = s.query(Thing).options(sa.orm.joinedload("category"))
result = q.select_from(
self.tables.options,
)
- s = create_session()
+ s = fixture_session()
q = s.query(Thing).options(sa.orm.joinedload("category"))
result = q.filter(
sa.and_(
def test_without_outerjoin_literal(self):
Thing, tests = (self.classes.Thing, self.tables.tests)
- s = create_session()
+ s = fixture_session()
q = s.query(Thing).options(sa.orm.joinedload("category"))
result = q.filter(
(tests.c.owner_id == 1)
self.tables.options,
)
- s = create_session()
+ s = fixture_session()
q = s.query(Thing).options(sa.orm.joinedload("category"))
result = q.filter(
(tests.c.owner_id == 1)
p.left.append(Left("l1"))
p.right.append(Right("r1"))
- session = create_session()
+ session = fixture_session()
session.add(p)
session.flush()
session.expunge_all()
mapper(Stat, stats, properties={"data": relationship(Data)})
- session = create_session()
+ session = fixture_session()
data = [Data(a=x) for x in range(5)]
session.add_all(data)
.group_by(stats.c.data_id)
)
- arb_result = arb_data.execute().fetchall()
+ arb_result = session.connection().execute(arb_data).fetchall()
# order the result list descending based on 'max'
arb_result.sort(key=lambda a: a._mapping["max"], reverse=True)
for e in "Joe", "Bob", "Mary", "Wally":
d2.employees.append(Employee(name=e))
- sess = create_session()
+ sess = fixture_session()
sess.add_all((d1, d2))
sess.flush()
mapper(DerivedII, derivedII, inherits=baseMapper)
- sess = create_session()
+ sess = fixture_session()
d = Derived("uid1", "x", "y")
d.comments = [Comment("uid1", "comment")]
d2 = DerivedII("uid2", "xx", "z")
)
d = Design()
- sess = create_session()
+ sess = fixture_session()
sess.add(d)
sess.flush()
sess.expunge_all()
c1 = Company(company_name="company 1", addresses=[a1, a2])
i1 = Invoice(date=datetime.datetime.now(), company=c1)
- session = create_session()
+ session = fixture_session()
session.add(i1)
session.flush()
properties=dict(type=relationship(Task_Type, lazy="joined")),
)
- session = create_session()
+ session = fixture_session()
eq_(
session.query(Joined).limit(10).offset(0).one(),
self.classes.Transaction,
)
- session = create_session()
+ session = fixture_session()
tx1 = Transaction(name="tx1")
tx2 = Transaction(name="tx2")
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
-from sqlalchemy.orm import sessionmaker
from sqlalchemy.testing import eq_
from sqlalchemy.testing import is_
+from sqlalchemy.testing.fixtures import fixture_session
from test.orm import _fixtures
def test_collection_move_hitslazy(self):
User, Address = self.classes.User, self.classes.Address
- sess = sessionmaker()()
+ sess = fixture_session()
a1 = Address(email_address="address1")
a2 = Address(email_address="address2")
a3 = Address(email_address="address3")
def test_collection_move_preloaded(self):
User, Address = self.classes.User, self.classes.Address
- sess = sessionmaker()()
+ sess = fixture_session()
a1 = Address(email_address="address1")
u1 = User(name="jack", addresses=[a1])
def test_collection_move_notloaded(self):
User, Address = self.classes.User, self.classes.Address
- sess = sessionmaker()()
+ sess = fixture_session()
a1 = Address(email_address="address1")
u1 = User(name="jack", addresses=[a1])
def test_collection_move_commitfirst(self):
User, Address = self.classes.User, self.classes.Address
- sess = sessionmaker()()
+ sess = fixture_session()
a1 = Address(email_address="address1")
u1 = User(name="jack", addresses=[a1])
def test_scalar_move_preloaded(self):
User, Address = self.classes.User, self.classes.Address
- sess = sessionmaker()()
+ sess = fixture_session()
u1 = User(name="jack")
u2 = User(name="ed")
User, Address = self.classes.User, self.classes.Address
- sess = sessionmaker()()
+ sess = fixture_session()
u1 = User(name="jack")
u2 = User(name="ed")
a1 = Address(email_address="a1")
def test_set_none(self):
User, Address = self.classes.User, self.classes.Address
- sess = sessionmaker()()
+ sess = fixture_session()
u1 = User(name="jack")
a1 = Address(email_address="a1")
a1.user = u1
def test_scalar_move_notloaded(self):
User, Address = self.classes.User, self.classes.Address
- sess = sessionmaker()()
+ sess = fixture_session()
u1 = User(name="jack")
u2 = User(name="ed")
def test_scalar_move_commitfirst(self):
User, Address = self.classes.User, self.classes.Address
- sess = sessionmaker()()
+ sess = fixture_session()
u1 = User(name="jack")
u2 = User(name="ed")
def test_collection_move_preloaded(self):
User, Address = self.classes.User, self.classes.Address
- sess = sessionmaker()()
+ sess = fixture_session()
a1 = Address(email_address="address1")
u1 = User(name="jack", address=a1)
def test_scalar_move_preloaded(self):
User, Address = self.classes.User, self.classes.Address
- sess = sessionmaker()()
+ sess = fixture_session()
a1 = Address(email_address="address1")
a2 = Address(email_address="address1")
u1 = User(name="jack", address=a1)
def test_collection_move_notloaded(self):
User, Address = self.classes.User, self.classes.Address
- sess = sessionmaker()()
+ sess = fixture_session()
a1 = Address(email_address="address1")
u1 = User(name="jack", address=a1)
def test_scalar_move_notloaded(self):
User, Address = self.classes.User, self.classes.Address
- sess = sessionmaker()()
+ sess = fixture_session()
a1 = Address(email_address="address1")
a2 = Address(email_address="address1")
u1 = User(name="jack", address=a1)
def test_collection_move_commitfirst(self):
User, Address = self.classes.User, self.classes.Address
- sess = sessionmaker()()
+ sess = fixture_session()
a1 = Address(email_address="address1")
u1 = User(name="jack", address=a1)
def test_scalar_move_commitfirst(self):
User, Address = self.classes.User, self.classes.Address
- sess = sessionmaker()()
+ sess = fixture_session()
a1 = Address(email_address="address1")
a2 = Address(email_address="address2")
u1 = User(name="jack", address=a1)
def test_collection_move_commitfirst(self):
User, Address = self.classes.User, self.classes.Address
- sess = sessionmaker()()
+ sess = fixture_session()
a1 = Address(email_address="address1")
u1 = User(name="jack", address=a1)
def test_m2o_event(self):
User, Address = self.classes.User, self.classes.Address
- sess = sessionmaker()()
+ sess = fixture_session()
a1 = Address(email_address="address1")
u1 = User(name="jack", address=a1)
Item, Keyword = (self.classes.Item, self.classes.Keyword)
- session = Session(autoflush=False)
+ session = fixture_session(autoflush=False)
i1 = Item(description="i1")
session.add(i1)
Item, Keyword = (self.classes.Item, self.classes.Keyword)
- session = Session(autoflush=False)
+ session = fixture_session(autoflush=False)
k1 = Keyword(name="k1")
i1 = Item(description="i1", keywords=[k1])
def test_collection_move_preloaded(self):
Item, Keyword = self.classes.Item, self.classes.Keyword
- sess = sessionmaker()()
+ sess = fixture_session()
k1 = Keyword(name="k1")
i1 = Item(description="i1", keyword=k1)
def test_collection_move_notloaded(self):
Item, Keyword = self.classes.Item, self.classes.Keyword
- sess = sessionmaker()()
+ sess = fixture_session()
k1 = Keyword(name="k1")
i1 = Item(description="i1", keyword=k1)
def test_collection_move_commit(self):
Item, Keyword = self.classes.Item, self.classes.Keyword
- sess = sessionmaker()()
+ sess = fixture_session()
k1 = Keyword(name="k1")
i1 = Item(description="i1", keyword=k1)
from sqlalchemy import testing
from sqlalchemy import true
from sqlalchemy.orm import backref
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import is_
from sqlalchemy.testing import mock
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.mock import Mock
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
},
)
- Session = sessionmaker(
+ maker = sessionmaker(
binds={
users_unbound: testing.db,
addresses_unbound: testing.db,
}
)
- sess = Session()
+ sess = maker()
u1 = User(id=1, name="ed")
sess.add(u1)
mapper(User, users)
- session = Session()
+ session = fixture_session()
session.execute(users.insert(), dict(name="Johnny"))
sess.close()
def test_bind_arg(self):
- sess = Session()
+ sess = fixture_session()
assert_raises_message(
sa.exc.ArgumentError,
mapper(User, users)
c = testing.db.connect()
- sess = create_session(bind=c)
+ sess = Session(bind=c)
sess.begin()
transaction = sess._legacy_transaction()
u = User(name="u1")
mapper(User, users)
c = testing.db.connect()
- sess = create_session(bind=c, autocommit=False)
+ sess = Session(bind=c, autocommit=False)
u = User(name="u1")
sess.add(u)
sess.flush()
assert not c.in_transaction()
assert c.exec_driver_sql("select count(1) from users").scalar() == 0
- sess = create_session(bind=c, autocommit=False)
+ sess = Session(bind=c, autocommit=False)
u = User(name="u2")
sess.add(u)
sess.flush()
c = testing.db.connect()
trans = c.begin()
- sess = create_session(bind=c, autocommit=True)
+ sess = Session(bind=c, autocommit=True)
u = User(name="u3")
sess.add(u)
sess.flush()
for bind in (engine, engine.connect()):
try:
- sess = create_session(bind=bind)
+ sess = Session(bind=bind)
assert sess.bind is bind
f = Foo()
sess.add(f)
def test_session_unbound(self):
Foo = self.classes.Foo
- sess = create_session()
+ sess = Session()
sess.add(Foo())
assert_raises_message(
sa.exc.UnboundExecutionError,
def _fixture(self, binds):
return Session(binds=binds)
- def test_fallback_table_metadata(self):
- session = self._fixture({})
- is_(session.get_bind(self.classes.BaseClass), testing.db)
-
def test_bind_base_table_base_class(self):
base_class_bind = Mock()
session = self._fixture({self.tables.base_table: base_class_bind})
# table, so this is what we expect
is_(session.get_bind(self.classes.JoinedSubClass), base_class_bind)
+ def test_fallback_table_metadata(self):
+ session = self._fixture({})
+ assert_raises_message(
+ sa.exc.UnboundExecutionError,
+ "Could not locate a bind configured on mapper mapped class",
+ session.get_bind,
+ self.classes.BaseClass,
+ )
+
def test_bind_base_table_concrete_sub_class(self):
base_class_bind = Mock()
session = self._fixture({self.tables.base_table: base_class_bind})
- is_(session.get_bind(self.classes.ConcreteSubClass), testing.db)
+ assert_raises_message(
+ sa.exc.UnboundExecutionError,
+ "Could not locate a bind configured on mapper mapped class",
+ session.get_bind,
+ self.classes.ConcreteSubClass,
+ )
def test_bind_sub_table_concrete_sub_class(self):
base_class_bind = Mock(name="base")
from sqlalchemy import String
from sqlalchemy import testing
from sqlalchemy.orm import mapper
-from sqlalchemy.orm import Session
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import mock
from sqlalchemy.testing.assertsql import CompiledSQL
from sqlalchemy.testing.assertsql import Conditional
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from test.orm import _fixtures
def test_bulk_insert_via_save(self):
Foo = self.classes.Foo
- s = Session()
+ s = fixture_session()
s.bulk_save_objects([Foo(value="value")])
def test_bulk_update_via_save(self):
Foo = self.classes.Foo
- s = Session()
+ s = fixture_session()
s.add(Foo(value="value"))
s.commit()
def test_bulk_save_return_defaults(self):
(User,) = self.classes("User")
- s = Session()
+ s = fixture_session()
objects = [User(name="u1"), User(name="u2"), User(name="u3")]
assert "id" not in objects[0].__dict__
def test_bulk_save_mappings_preserve_order(self):
(User,) = self.classes("User")
- s = Session()
+ s = fixture_session()
# commit some object into db
user1 = User(name="i1")
def test_bulk_save_no_defaults(self):
(User,) = self.classes("User")
- s = Session()
+ s = fixture_session()
objects = [User(name="u1"), User(name="u2"), User(name="u3")]
assert "id" not in objects[0].__dict__
def test_bulk_save_updated_include_unchanged(self):
(User,) = self.classes("User")
- s = Session(expire_on_commit=False)
+ s = fixture_session(expire_on_commit=False)
objects = [User(name="u1"), User(name="u2"), User(name="u3")]
s.add_all(objects)
s.commit()
objects[0].name = "u1new"
objects[2].name = "u3new"
- s = Session()
+ s = fixture_session()
with self.sql_execution_asserter() as asserter:
s.bulk_save_objects(objects, update_changed_only=False)
def test_bulk_update(self):
(User,) = self.classes("User")
- s = Session(expire_on_commit=False)
+ s = fixture_session(expire_on_commit=False)
objects = [User(name="u1"), User(name="u2"), User(name="u3")]
s.add_all(objects)
s.commit()
- s = Session()
+ s = fixture_session()
with self.sql_execution_asserter() as asserter:
s.bulk_update_mappings(
User,
def test_bulk_insert(self):
(User,) = self.classes("User")
- s = Session()
+ s = fixture_session()
with self.sql_execution_asserter() as asserter:
s.bulk_insert_mappings(
User,
def test_bulk_insert_render_nulls(self):
(Order,) = self.classes("Order")
- s = Session()
+ s = fixture_session()
with self.sql_execution_asserter() as asserter:
s.bulk_insert_mappings(
Order,
def test_insert_w_fetch(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
a1 = A(x=1)
s.bulk_save_objects([a1])
s.commit()
def test_update_w_fetch(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
a1 = A(x=1, y=2)
s.add(a1)
s.commit()
def _test_insert(self, person_cls):
Person = person_cls
- s = Session()
+ s = fixture_session()
with self.sql_execution_asserter(testing.db) as asserter:
s.bulk_insert_mappings(
Person, [{"id": 5, "personname": "thename"}]
def _test_update(self, person_cls):
Person = person_cls
- s = Session()
+ s = fixture_session()
s.add(Person(id=5, personname="thename"))
s.commit()
"Person", "Engineer", "Manager", "Boss"
)
- s = Session()
+ s = fixture_session()
objects = [
Manager(name="m1", status="s1", manager_name="mn1"),
Engineer(name="e1", status="s2", primary_language="l1"),
"Person", "Engineer", "Manager", "Boss"
)
- s = Session()
+ s = fixture_session()
with self.sql_execution_asserter() as asserter:
s.bulk_save_objects(
[
"Person", "Engineer", "Manager", "Boss"
)
- s = Session()
+ s = fixture_session()
with self.sql_execution_asserter() as asserter:
s.bulk_insert_mappings(
Boss,
from sqlalchemy.testing import AssertsCompiledSQL
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
def test_same_named_col_in_orderby(self):
Data, Other = self.classes("Data", "Other")
bundle = Bundle("pk", Data.id, Other.id)
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Data, Other).order_by(bundle),
def test_same_named_col_in_fetch(self):
Data, Other = self.classes("Data", "Other")
bundle = Bundle("pk", Data.id, Other.id)
- sess = Session()
+ sess = fixture_session()
eq_(
sess.query(bundle)
def test_result(self):
Data = self.classes.Data
- sess = Session()
+ sess = fixture_session()
b1 = Bundle("b1", Data.d1, Data.d2)
def test_subclass(self):
Data = self.classes.Data
- sess = Session()
+ sess = fixture_session()
class MyBundle(Bundle):
def create_row_processor(self, query, procs, labels):
b1 = Bundle("b1", d1.d1, d1.d2)
b2 = Bundle("b2", Data.d1, Other.o1)
- sess = Session()
+ sess = fixture_session()
q = (
sess.query(b1, b2)
def test_single_entity_legacy_query(self):
Data = self.classes.Data
- sess = Session()
+ sess = fixture_session()
b1 = Bundle("b1", Data.d1, Data.d2, single_entity=True)
def test_labeled_cols_non_single_entity_legacy_query(self):
Data = self.classes.Data
- sess = Session()
+ sess = fixture_session()
b1 = Bundle("b1", Data.d1.label("x"), Data.d2.label("y"))
def test_labeled_cols_single_entity_legacy_query(self):
Data = self.classes.Data
- sess = Session()
+ sess = fixture_session()
b1 = Bundle(
"b1", Data.d1.label("x"), Data.d2.label("y"), single_entity=True
def test_labeled_cols_as_rows_future(self):
Data = self.classes.Data
- sess = Session()
+ sess = fixture_session()
b1 = Bundle("b1", Data.d1.label("x"), Data.d2.label("y"))
def test_labeled_cols_as_scalars_future(self):
Data = self.classes.Data
- sess = Session()
+ sess = fixture_session()
b1 = Bundle("b1", Data.d1.label("x"), Data.d2.label("y"))
def test_single_entity_flag_but_multi_entities(self):
Data = self.classes.Data
- sess = Session()
+ sess = fixture_session()
b1 = Bundle("b1", Data.d1, Data.d2, single_entity=True)
b2 = Bundle("b1", Data.d3, single_entity=True)
def test_bundle_nesting(self):
Data = self.classes.Data
- sess = Session()
+ sess = fixture_session()
b1 = Bundle("b1", Data.d1, Bundle("b2", Data.d2, Data.d3))
def test_bundle_nesting_unions(self):
Data = self.classes.Data
- sess = Session()
+ sess = fixture_session()
b1 = Bundle("b1", Data.d1, Bundle("b2", Data.d2, Data.d3))
def test_query_count(self):
Data = self.classes.Data
b1 = Bundle("b1", Data.d1, Data.d2)
- eq_(Session().query(b1).count(), 10)
+ eq_(fixture_session().query(b1).count(), 10)
def test_join_relationship(self):
Data = self.classes.Data
- sess = Session()
+ sess = fixture_session()
b1 = Bundle("b1", Data.d1, Data.d2)
q = sess.query(b1).join(Data.others)
self.assert_compile(
Data = self.classes.Data
Other = self.classes.Other
- sess = Session()
+ sess = fixture_session()
b1 = Bundle("b1", Data.d1, Data.d2)
q = sess.query(b1).join(Other)
self.assert_compile(
b1 = Bundle("b1", Data.id, Data.d1, Data.d2)
- session = Session()
+ session = fixture_session()
first = session.query(b1)
second = session.query(b1)
unioned = first.union(second)
b1 = Bundle("b1", Data.id, Data.d1, Data.d2)
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(b1).filter_by(d1="d1"),
b1 = Bundle("b1", Data.id, Data.d1, Data.d2)
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Data).order_by(b1),
"SELECT data.id AS data_id, data.d1 AS data_d1, "
b1 = Bundle("b1", data_table.c.d1, data_table.c.d2)
- sess = Session()
+ sess = fixture_session()
eq_(
sess.query(b1).filter(b1.c.d1.between("d3d1", "d5d1")).all(),
[(("d3d1", "d3d2"),), (("d4d1", "d4d2"),), (("d5d1", "d5d2"),)],
b1 = Bundle("b1", data_table.c.d1, data_table.c.d2, single_entity=True)
- sess = Session()
+ sess = fixture_session()
eq_(
sess.query(b1).filter(b1.c.d1.between("d3d1", "d5d1")).all(),
[("d3d1", "d3d2"), ("d4d1", "d4d2"), ("d5d1", "d5d2")],
from sqlalchemy.sql.visitors import InternalTraversal
from sqlalchemy.testing import AssertsCompiledSQL
from sqlalchemy.testing import eq_
+from sqlalchemy.testing.fixtures import fixture_session
from test.orm import _fixtures
from .inheritance import _poly_fixtures
from .test_query import QueryTest
self._run_cache_key_fixture(
lambda: stmt_20(
- Session().query(User).join(User.addresses),
- Session().query(User).join(User.orders),
- Session().query(User).join(User.addresses).join(User.orders),
- Session()
+ fixture_session().query(User).join(User.addresses),
+ fixture_session().query(User).join(User.orders),
+ fixture_session()
+ .query(User)
+ .join(User.addresses)
+ .join(User.orders),
+ fixture_session()
.query(User)
.join("addresses")
.join("dingalings", from_joinpoint=True),
- Session().query(User).join("addresses"),
- Session().query(User).join("orders"),
- Session().query(User).join("addresses").join("orders"),
- Session().query(User).join(Address, User.addresses),
- Session().query(User).join(a1, "addresses"),
- Session().query(User).join(a1, "addresses", aliased=True),
- Session().query(User).join(User.addresses.of_type(a1)),
+ fixture_session().query(User).join("addresses"),
+ fixture_session().query(User).join("orders"),
+ fixture_session().query(User).join("addresses").join("orders"),
+ fixture_session().query(User).join(Address, User.addresses),
+ fixture_session().query(User).join(a1, "addresses"),
+ fixture_session()
+ .query(User)
+ .join(a1, "addresses", aliased=True),
+ fixture_session().query(User).join(User.addresses.of_type(a1)),
),
compare_values=True,
)
self._run_cache_key_fixture(
lambda: stmt_20(
- Session()
+ fixture_session()
.query(User)
.from_statement(text("select * from user")),
- Session()
+ fixture_session()
.query(User)
.options(selectinload(User.addresses))
.from_statement(text("select * from user")),
- Session()
+ fixture_session()
.query(User)
.options(subqueryload(User.addresses))
.from_statement(text("select * from user")),
- Session()
+ fixture_session()
.query(User)
.from_statement(text("select * from user order by id")),
- Session()
+ fixture_session()
.query(User.id)
.from_statement(text("select * from user")),
),
self._run_cache_key_fixture(
lambda: stmt_20(
- Session().query(User),
- Session().query(User).prefix_with("foo"),
- Session().query(User).filter_by(name="ed"),
- Session().query(User).filter_by(name="ed").order_by(User.id),
- Session().query(User).filter_by(name="ed").order_by(User.name),
- Session().query(User).filter_by(name="ed").group_by(User.id),
- Session()
+ fixture_session().query(User),
+ fixture_session().query(User).prefix_with("foo"),
+ fixture_session().query(User).filter_by(name="ed"),
+ fixture_session()
+ .query(User)
+ .filter_by(name="ed")
+ .order_by(User.id),
+ fixture_session()
+ .query(User)
+ .filter_by(name="ed")
+ .order_by(User.name),
+ fixture_session()
+ .query(User)
+ .filter_by(name="ed")
+ .group_by(User.id),
+ fixture_session()
.query(User)
.join(User.addresses)
.filter(User.name == "ed"),
- Session().query(User).join(User.orders),
- Session()
+ fixture_session().query(User).join(User.orders),
+ fixture_session()
.query(User)
.join(User.orders)
.filter(Order.description == "adsf"),
- Session().query(User).join(User.addresses).join(User.orders),
- Session().query(User).join(Address, User.addresses),
- Session().query(User).join(a1, User.addresses),
- Session().query(User).join(User.addresses.of_type(a1)),
- Session().query(Address).join(Address.user),
- Session().query(User, Address).filter_by(name="ed"),
- Session().query(User, a1).filter_by(name="ed"),
+ fixture_session()
+ .query(User)
+ .join(User.addresses)
+ .join(User.orders),
+ fixture_session().query(User).join(Address, User.addresses),
+ fixture_session().query(User).join(a1, User.addresses),
+ fixture_session().query(User).join(User.addresses.of_type(a1)),
+ fixture_session().query(Address).join(Address.user),
+ fixture_session().query(User, Address).filter_by(name="ed"),
+ fixture_session().query(User, a1).filter_by(name="ed"),
),
compare_values=True,
)
def one():
return (
- Session().query(Person).with_polymorphic([Manager, Engineer])
+ fixture_session()
+ .query(Person)
+ .with_polymorphic([Manager, Engineer])
)
def two():
wp = with_polymorphic(Person, [Manager, Engineer])
- return Session().query(wp)
+ return fixture_session().query(wp)
def three():
wp = with_polymorphic(Person, [Manager, Engineer])
- return Session().query(wp).filter(wp.name == "asdfo")
+ return fixture_session().query(wp).filter(wp.name == "asdfo")
def three_a():
wp = with_polymorphic(Person, [Manager, Engineer], flat=True)
- return Session().query(wp).filter(wp.name == "asdfo")
+ return fixture_session().query(wp).filter(wp.name == "asdfo")
def four():
return (
- Session()
+ fixture_session()
.query(Person)
.with_polymorphic([Manager, Engineer])
.filter(Person.name == "asdf")
)
wp = with_polymorphic(Person, [Manager, Engineer], subq)
- return Session().query(wp).filter(wp.name == "asdfo")
+ return fixture_session().query(wp).filter(wp.name == "asdfo")
def six():
subq = (
)
return (
- Session()
+ fixture_session()
.query(Person)
.with_polymorphic([Manager, Engineer], subq)
.filter(Person.name == "asdfo")
def one():
return (
- Session()
+ fixture_session()
.query(Company)
.join(Company.employees)
.filter(Person.name == "asdf")
def two():
wp = with_polymorphic(Person, [Manager, Engineer])
return (
- Session()
+ fixture_session()
.query(Company)
.join(Company.employees.of_type(wp))
.filter(wp.name == "asdf")
def three():
wp = with_polymorphic(Person, [Manager, Engineer])
return (
- Session()
+ fixture_session()
.query(Company)
.join(Company.employees.of_type(wp))
.filter(wp.Engineer.name == "asdf")
from sqlalchemy.orm import object_mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
-from sqlalchemy.orm import sessionmaker
from sqlalchemy.orm import util as orm_util
from sqlalchemy.orm.attributes import instance_state
from sqlalchemy.testing import assert_raises
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import in_
from sqlalchemy.testing import not_in
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from test.orm import _fixtures
def test_list_assignment_new(self):
User, Order = self.classes.User, self.classes.Order
- with Session() as sess:
+ with fixture_session() as sess:
u = User(
name="jack",
orders=[
def test_list_assignment_replace(self):
User, Order = self.classes.User, self.classes.Order
- with Session() as sess:
+ with fixture_session() as sess:
u = User(
name="jack",
orders=[
def test_standalone_orphan(self):
Order = self.classes.Order
- with Session() as sess:
+ with fixture_session() as sess:
o5 = Order(description="order 5")
sess.add(o5)
assert_raises(sa_exc.DBAPIError, sess.flush)
Order, User = self.classes.Order, self.classes.User
- sess = sessionmaker(expire_on_commit=False)()
+ sess = fixture_session(expire_on_commit=False)
o1, o2, o3 = (
Order(description="o1"),
Order(description="o2"),
def test_remove_pending_from_collection(self):
User, Order = self.classes.User, self.classes.Order
- with Session() as sess:
+ with fixture_session() as sess:
u = User(name="jack")
sess.add(u)
User, Order = self.classes.User, self.classes.Order
- with Session() as sess:
+ with fixture_session() as sess:
u = User(name="jack")
self.classes.Order,
)
- with Session() as sess:
+ with fixture_session() as sess:
u = User(
name="jack",
orders=[
self.classes.Address,
)
- with Session() as sess:
+ with fixture_session() as sess:
u = User(
name="jack",
addresses=[
self.tables.orders,
)
- with Session(autoflush=False) as sess:
+ with fixture_session(autoflush=False) as sess:
u = User(
name="jack",
orders=[
self.classes.Address,
)
- sess = Session()
+ sess = fixture_session()
u = User(name="jack")
sess.add(u)
assert "orders" not in u.__dict__
self.classes.Order,
)
- sess = Session()
+ sess = fixture_session()
u = User(
name="jack",
orders=[
self.classes.Order,
)
- with Session() as sess:
+ with fixture_session() as sess:
u = User(
name="jack",
orders=[
def test_none_o2m_collection_assignment(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
u1 = User(name="u", addresses=[None])
s.add(u1)
eq_(u1.addresses, [None])
def test_none_o2m_collection_append(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
u1 = User(name="u")
s.add(u1)
self.tables.users,
)
- with Session() as sess:
+ with fixture_session() as sess:
u = User(
name="jack",
orders=[
User, Address = self.classes.User, self.classes.Address
a1 = Address(email_address="some address")
u1 = User(name="u1", address=a1)
- sess = Session()
+ sess = fixture_session()
sess.add(u1)
sess.commit()
User, Address = self.classes.User, self.classes.Address
self._one_to_many_fixture(o2m=True, m2o=False)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
a1 = Address(email_address="a1")
u1.addresses.append(a1)
User, Address = self.classes.User, self.classes.Address
self._one_to_many_fixture(o2m=True, m2o=False, o2m_cascade=False)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
a1 = Address(email_address="a1")
u1.addresses.append(a1)
User, Address = self.classes.User, self.classes.Address
self._one_to_many_fixture(o2m=True, m2o=False, o2m_cascade=False)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
a1 = Address(email_address="a1")
sess.add(a1)
User, Address = self.classes.User, self.classes.Address
self._one_to_many_fixture(o2m=True, m2o=True)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
a1 = Address(email_address="a1")
u1.addresses.append(a1)
User, Address = self.classes.User, self.classes.Address
self._one_to_many_fixture(o2m=True, m2o=True, o2m_cascade=False)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
a1 = Address(email_address="a1")
u1.addresses.append(a1)
User, Address = self.classes.User, self.classes.Address
self._one_to_many_fixture(o2m=True, m2o=True, o2m_cascade=False)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
a1 = Address(email_address="a1")
u1.addresses.append(a1)
User, Address = self.classes.User, self.classes.Address
self._one_to_many_fixture(o2m=True, m2o=True, o2m_cascade=False)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
a1 = Address(email_address="a1")
sess.add(a1)
User, Address = self.classes.User, self.classes.Address
self._one_to_many_fixture(o2m=True, m2o=True, o2m_cascade=False)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
a1 = Address(email_address="a1")
sess.add(a1)
User, Address = self.classes.User, self.classes.Address
self._one_to_many_fixture(o2m=False, m2o=True)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
a1 = Address(email_address="a1")
a1.user = u1
User, Address = self.classes.User, self.classes.Address
self._one_to_many_fixture(o2m=False, m2o=True, m2o_cascade=False)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
a1 = Address(email_address="a1")
a1.user = u1
User, Address = self.classes.User, self.classes.Address
self._one_to_many_fixture(o2m=False, m2o=True, m2o_cascade=False)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
sess.add(u1)
sess.flush()
User, Address = self.classes.User, self.classes.Address
self._one_to_many_fixture(o2m=True, m2o=True)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
a1 = Address(email_address="a1")
a1.user = u1
User, Address = self.classes.User, self.classes.Address
self._one_to_many_fixture(o2m=True, m2o=True, m2o_cascade=False)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
a1 = Address(email_address="a1")
a1.user = u1
User, Address = self.classes.User, self.classes.Address
self._one_to_many_fixture(o2m=True, m2o=True, m2o_cascade=False)
- with Session() as sess:
+ with fixture_session() as sess:
u1 = User(name="u1")
sess.add(u1)
sess.flush()
User, Address = self.classes.User, self.classes.Address
self._one_to_many_fixture(o2m=True, m2o=True, m2o_cascade=False)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
a1 = Address(email_address="a1")
self._one_to_many_fixture(o2m=True, m2o=True, m2o_cascade=False)
- with Session() as sess:
+ with fixture_session() as sess:
u1 = User(name="u1")
sess.add(u1)
sess.flush()
Item, Keyword = self.classes.Item, self.classes.Keyword
self._many_to_many_fixture(fwd=True, bkd=False)
- sess = Session()
+ sess = fixture_session()
i1 = Item(description="i1")
k1 = Keyword(name="k1")
i1.keywords.append(k1)
Item, Keyword = self.classes.Item, self.classes.Keyword
self._many_to_many_fixture(fwd=True, bkd=False, fwd_cascade=False)
- sess = Session()
+ sess = fixture_session()
i1 = Item(description="i1")
k1 = Keyword(name="k1")
i1.keywords.append(k1)
Item, Keyword = self.classes.Item, self.classes.Keyword
self._many_to_many_fixture(fwd=True, bkd=False, fwd_cascade=False)
- sess = Session()
+ sess = fixture_session()
i1 = Item(description="i1")
k1 = Keyword(name="k1")
sess.add(k1)
Item, Keyword = self.classes.Item, self.classes.Keyword
self._many_to_many_fixture(fwd=True, bkd=True)
- sess = Session()
+ sess = fixture_session()
i1 = Item(description="i1")
k1 = Keyword(name="k1")
i1.keywords.append(k1)
Item, Keyword = self.classes.Item, self.classes.Keyword
self._many_to_many_fixture(fwd=True, bkd=True, fwd_cascade=False)
- sess = Session()
+ sess = fixture_session()
i1 = Item(description="i1")
k1 = Keyword(name="k1")
i1.keywords.append(k1)
Item, Keyword = self.classes.Item, self.classes.Keyword
self._many_to_many_fixture(fwd=True, bkd=True, fwd_cascade=False)
- sess = Session()
+ sess = fixture_session()
i1 = Item(description="i1")
k1 = Keyword(name="k1")
i1.keywords.append(k1)
Item, Keyword = self.classes.Item, self.classes.Keyword
self._many_to_many_fixture(fwd=True, bkd=True, fwd_cascade=False)
- sess = Session()
+ sess = fixture_session()
i1 = Item(description="i1")
k1 = Keyword(name="k1")
sess.add(k1)
Item, Keyword = self.classes.Item, self.classes.Keyword
self._many_to_many_fixture(fwd=True, bkd=True, fwd_cascade=False)
- sess = Session()
+ sess = fixture_session()
i1 = Item(description="i1")
k1 = Keyword(name="k1")
sess.add(k1)
),
)
- sess = Session()
+ sess = fixture_session()
o1 = Order()
sess.add(o1)
)
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
u1 = User()
sess.add(u1)
)
mapper(Keyword, keywords)
- sess = Session()
+ sess = fixture_session()
i1 = Item()
k1 = Keyword()
self.tables.extra,
)
- sess = Session()
+ sess = fixture_session()
eq_(
sess.execute(select(func.count("*")).select_from(prefs)).scalar(),
3,
Foo, User = self.classes.Foo, self.classes.User
- sess = sessionmaker(expire_on_commit=True)()
+ sess = fixture_session(expire_on_commit=True)
u1 = User(name="jack", foo=Foo(data="f1"))
sess.add(u1)
Pref, User = self.classes.Pref, self.classes.User
- sess = sessionmaker(expire_on_commit=False)()
+ sess = fixture_session(expire_on_commit=False)
p1, p2 = Pref(data="p1"), Pref(data="p2")
u = User(name="jack", pref=p1)
self.tables.extra,
)
- sess = Session()
+ sess = fixture_session()
jack = sess.query(User).filter_by(name="jack").one()
p = jack.pref
e = jack.pref.extra[0]
def test_pending_expunge(self):
Pref, User = self.classes.Pref, self.classes.User
- sess = Session()
+ sess = fixture_session()
someuser = User(name="someuser")
sess.add(someuser)
sess.flush()
Pref, User = self.classes.Pref, self.classes.User
- sess = Session()
+ sess = fixture_session()
jack = sess.query(User).filter_by(name="jack").one()
newpref = Pref(data="newpref")
def test_cascade_delete(self):
T2, T3, T1 = (self.classes.T2, self.classes.T3, self.classes.T1)
- sess = Session()
+ sess = fixture_session()
x = T1(data="t1a", t2=T2(data="t2a", t3=T3(data="t3a")))
sess.add(x)
sess.flush()
def test_deletes_orphans_onelevel(self):
T2, T3, T1 = (self.classes.T2, self.classes.T3, self.classes.T1)
- sess = Session()
+ sess = fixture_session()
x2 = T1(data="t1b", t2=T2(data="t2b", t3=T3(data="t3b")))
sess.add(x2)
sess.flush()
def test_deletes_orphans_twolevel(self):
T2, T3, T1 = (self.classes.T2, self.classes.T3, self.classes.T1)
- sess = Session()
+ sess = fixture_session()
x = T1(data="t1a", t2=T2(data="t2a", t3=T3(data="t3a")))
sess.add(x)
sess.flush()
def test_finds_orphans_twolevel(self):
T2, T3, T1 = (self.classes.T2, self.classes.T3, self.classes.T1)
- sess = Session()
+ sess = fixture_session()
x = T1(data="t1a", t2=T2(data="t2a", t3=T3(data="t3a")))
sess.add(x)
sess.flush()
def test_cascade_delete(self):
T2, T3, T1 = (self.classes.T2, self.classes.T3, self.classes.T1)
- sess = Session()
+ sess = fixture_session()
x = T1(data="t1a", t2=T2(data="t2a", t3=T3(data="t3a")))
sess.add(x)
sess.flush()
def test_cascade_delete_postappend_onelevel(self):
T2, T3, T1 = (self.classes.T2, self.classes.T3, self.classes.T1)
- sess = Session()
+ sess = fixture_session()
x1 = T1(data="t1")
x2 = T2(data="t2")
x3 = T3(data="t3")
def test_cascade_delete_postappend_twolevel(self):
T2, T3, T1 = (self.classes.T2, self.classes.T3, self.classes.T1)
- sess = Session()
+ sess = fixture_session()
x1 = T1(data="t1", t2=T2(data="t2"))
x3 = T3(data="t3")
sess.add_all((x1, x3))
def test_preserves_orphans_onelevel(self):
T2, T3, T1 = (self.classes.T2, self.classes.T3, self.classes.T1)
- sess = Session()
+ sess = fixture_session()
x2 = T1(data="t1b", t2=T2(data="t2b", t3=T3(data="t3b")))
sess.add(x2)
sess.flush()
def test_preserves_orphans_onelevel_postremove(self):
T2, T3, T1 = (self.classes.T2, self.classes.T3, self.classes.T1)
- sess = Session()
+ sess = fixture_session()
x2 = T1(data="t1b", t2=T2(data="t2b", t3=T3(data="t3b")))
sess.add(x2)
sess.flush()
def test_preserves_orphans_twolevel(self):
T2, T3, T1 = (self.classes.T2, self.classes.T3, self.classes.T1)
- sess = Session()
+ sess = fixture_session()
x = T1(data="t1a", t2=T2(data="t2a", t3=T3(data="t3a")))
sess.add(x)
sess.flush()
)
mapper(B, b)
- sess = Session()
+ sess = fixture_session()
b1 = B(data="b1")
a1 = A(data="a1", bs=[b1])
sess.add(a1)
# failed until [ticket:427] was fixed
mapper(B, b)
- sess = Session()
+ sess = fixture_session()
b1 = B(data="b1")
a1 = A(data="a1", bs=[b1])
sess.add(a1)
)
mapper(C, c)
- sess = Session()
+ sess = fixture_session()
b1 = B(data="b1", cs=[C(data="c1")])
a1 = A(data="a1", bs=[b1])
sess.add(a1)
)
mapper(B, b)
- sess = Session()
+ sess = fixture_session()
a1 = A(data="a1", bs=[B(data="b1")])
sess.add(a1)
sess.flush()
)
mapper(B, b)
- s = Session()
+ s = fixture_session()
a1 = A(bs=[None])
s.add(a1)
eq_(a1.bs, [None])
)
mapper(B, b)
- s = Session()
+ s = fixture_session()
a1 = A()
a1.bs.append(None)
s.add(a1)
def test_self_referential_delete(self):
Node = self.classes.Node
- s = Session()
+ s = fixture_session()
n1, n2, n3, n4 = Node(), Node(), Node(), Node()
n1.children = [n2, n3]
def test_o2m_basic(self):
User, Address = self.classes.User, self.classes.Address
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
sess.add(u1)
def test_o2m_commit_warns(self):
User, Address = self.classes.User, self.classes.Address
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
sess.add(u1)
def test_o2m_flag_on_backref(self):
Dingaling, Address = self.classes.Dingaling, self.classes.Address
- sess = Session()
+ sess = fixture_session()
a1 = Address(email_address="a1")
sess.add(a1)
def test_m2o_basic(self):
Dingaling, Address = self.classes.Dingaling, self.classes.Address
- sess = Session()
+ sess = fixture_session()
a1 = Address(email_address="a1")
d1 = Dingaling()
def test_m2o_flag_on_backref(self):
User, Address = self.classes.User, self.classes.Address
- sess = Session()
+ sess = fixture_session()
a1 = Address(email_address="a1")
sess.add(a1)
def test_m2o_commit_warns(self):
Dingaling, Address = self.classes.Dingaling, self.classes.Address
- sess = Session()
+ sess = fixture_session()
a1 = Address(email_address="a1")
d1 = Dingaling()
orders=relationship(Order, cascade="all, delete-orphan"),
),
)
- s = Session()
+ s = fixture_session()
# the standalone Address goes in, its foreign key
# allows NULL
)
),
)
- s = Session()
+ s = fixture_session()
u = User()
s.add(u)
)
),
)
- s = Session()
+ s = fixture_session()
u = User(name="u1", addresses=[Address(email_address="ad1")])
s.add(u)
a1 = u.addresses[0]
},
)
mapper(Item, item)
- s = Session()
+ s = fixture_session()
o1 = Order()
s.add(o1)
},
)
mapper(Attribute, attribute)
- s = Session()
+ s = fixture_session()
o1 = Order()
s.add(o1)
)
),
)
- s = Session(expire_on_commit=False, autoflush=False)
+ s = fixture_session(expire_on_commit=False, autoflush=False)
a = Account(balance=0)
sr = SalesRep(name="John")
},
)
- session = Session()
+ session = fixture_session()
h1 = Home(description="home1", address=Address(street="address1"))
b1 = Business(
description="business1", address=Address(street="address2")
)
},
)
- session = Session()
+ session = fixture_session()
a1 = Address()
session.add(a1)
session.flush()
a1 = A(name="a1", bs=[B(name="b1"), B(name="b2"), B(name="b3")])
- sess = Session()
+ sess = fixture_session()
sess.add(a1)
sess.flush()
RelatedTwo(cores=[c1])
if persistent:
- s = Session()
+ s = fixture_session()
s.add(c1)
s.flush()
def _do_move_test(self, delete_old):
Parent, Child = self.classes.Parent, self.classes.Child
- with Session(autoflush=False) as sess:
+ with fixture_session(autoflush=False) as sess:
p1, p2, c1 = Parent(), Parent(), Child()
if Parent.child.property.uselist:
p1.child.append(c1)
)
mapper(Child, noninh_child)
- sess = Session()
+ sess = fixture_session()
c1, c2 = Child(), Child()
b1 = Base(descr="b1", children=[c1, c2])
assert c2 in sess and c2 not in sess.new
assert b1 in sess and b1 not in sess.new
- sess = Session()
+ sess = fixture_session()
c1, c2 = Child(), Child()
b1 = Base(descr="b1", children=[c1, c2])
sess.add(b1)
assert c2 in sess and c2 in sess.new
assert b1 in sess and b1 in sess.new
- sess = Session()
+ sess = fixture_session()
c1, c2 = Child(), Child()
b1 = Base(descr="b1", children=[c1, c2])
sess.add(b1)
mapper(Parent, parent, inherits=Base)
- sess = Session()
+ sess = fixture_session()
p1 = Parent()
c1, c2, c3 = Child(), Child(), Child()
)
]
)
- s = Session()
+ s = fixture_session()
s.add(obj)
s.commit()
},
)
- sess = Session()
+ sess = fixture_session()
u = User(id=1, name="jack")
sess.add(u)
sess.add_all(
},
)
- sess = Session()
+ sess = fixture_session()
u1 = User(id=1, name="jack")
sess.add(u1)
},
)
- sess = Session()
+ sess = fixture_session()
u1 = User(id=1, name="jack")
o1, o2 = (
from sqlalchemy import text
from sqlalchemy import util
from sqlalchemy.orm import attributes
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import instrumentation
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import is_false
from sqlalchemy.testing import is_true
from sqlalchemy.testing import ne_
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
p = Parent()
p.children["foo"] = Child("foo", "value")
p.children["bar"] = Child("bar", "value")
- session = create_session()
+ session = fixture_session()
session.add(p)
session.flush()
pid = p.id
p.children[("foo", "1")] = Child("foo", "1", "value 1")
p.children[("foo", "2")] = Child("foo", "2", "value 2")
- session = create_session()
+ session = fixture_session()
session.add(p)
session.flush()
pid = p.id
f = Foo()
f.bars.add(Bar())
f.bars.add(Bar())
- sess = create_session()
+ sess = fixture_session()
sess.add(f)
sess.flush()
sess.expunge_all()
f = Foo()
f.bars.set(Bar())
f.bars.set(Bar())
- sess = create_session()
+ sess = fixture_session()
sess.add(f)
sess.flush()
sess.expunge_all()
col = collections.collection_adapter(f.bars)
col.append_with_event(Bar("a"))
col.append_with_event(Bar("b"))
- sess = create_session()
+ sess = fixture_session()
sess.add(f)
sess.flush()
sess.expunge_all()
p1.children.append(o)
assert control == list(p1.children)
- sess = create_session()
+ sess = fixture_session()
sess.add(p1)
sess.flush()
sess.expunge_all()
from sqlalchemy.orm import backref
from sqlalchemy.orm import clear_mappers
from sqlalchemy.orm import configure_mappers
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
+from sqlalchemy.orm import Session
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import fixtures
"host": relationship(Host),
},
)
- sess = create_session(connection)
+ sess = Session(connection)
assert sess.query(Node).get(1).names == []
def test_conflicting_backref_two(self):
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
# pending/transient object.
e1 = Edge()
assert e1.end is None
- sess = Session()
+ sess = fixture_session()
sess.add(e1)
# however, once it's persistent, the code as of 0.7.3
Graph, Edge = self.classes.Graph, self.classes.Edge
- sess = Session()
+ sess = fixture_session()
g = Graph(id=1)
e = Edge(None, None)
g.edges.append(e)
def test_round_trip(self):
Thing, AB, CD = self._fixture()
- s = Session()
+ s = fixture_session()
s.add(Thing(AB("a", "b", CD("c", "d"))))
s.commit()
def _fixture(self):
Graph, Version = self.classes.Graph, self.classes.Version
- sess = Session()
+ sess = fixture_session()
g = Graph(Version(1, 1))
sess.add(g)
sess.commit()
def test_null_pk(self):
Graph, Version = self.classes.Graph, self.classes.Version
- sess = Session()
+ sess = fixture_session()
# test pk with one column NULL
# only sqlite can really handle this
def test_attributes_with_defaults(self):
Foobar, FBComposite = self.classes.Foobar, self.classes.FBComposite
- sess = Session()
+ sess = fixture_session()
f1 = Foobar()
f1.foob = FBComposite(None, 5, None, None)
sess.add(f1)
def test_set_composite_values(self):
Foobar, FBComposite = self.classes.Foobar, self.classes.FBComposite
- sess = Session()
+ sess = fixture_session()
f1 = Foobar()
f1.foob = FBComposite(None, 5, None, None)
sess.add(f1)
self.tables.descriptions,
)
- session = Session()
+ session = fixture_session()
d = Descriptions(
custom_descriptions=CustomValues("Color", "Number"),
values=[
def test_persist(self):
A, C, B = (self.classes.A, self.classes.C, self.classes.B)
- sess = Session()
+ sess = fixture_session()
sess.add(A(c=C("b1", B(data="b2"))))
sess.commit()
def test_query(self):
A, C, B = (self.classes.A, self.classes.C, self.classes.B)
- sess = Session()
+ sess = fixture_session()
b1, b2 = B(data="b1"), B(data="b2")
a1 = A(c=C("a1b1", b1))
a2 = A(c=C("a2b1", b2))
def test_query_aliased(self):
A, C, B = (self.classes.A, self.classes.C, self.classes.B)
- sess = Session()
+ sess = fixture_session()
b1, b2 = B(data="b1"), B(data="b2")
a1 = A(c=C("a1b1", b1))
a2 = A(c=C("a2b1", b2))
Edge, Point = self.classes.Edge, self.classes.Point
e1 = Edge(start=Point(3, 4), end=Point(5, 6))
- sess = Session()
+ sess = fixture_session()
sess.add(e1)
sess.commit()
def _test_comparator_behavior(self):
Edge, Point = (self.classes.Edge, self.classes.Point)
- sess = Session()
+ sess = fixture_session()
e1 = Edge(Point(3, 4), Point(5, 6))
e2 = Edge(Point(14, 5), Point(2, 7))
sess.add_all([e1, e2])
Edge(Point(0, 1), Point(3, 5)),
)
- sess = Session()
+ sess = fixture_session()
sess.add_all([edge_1, edge_2])
sess.commit()
def test_order_by(self):
self._fixture(False)
Edge = self.classes.Edge
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(Edge).order_by(Edge.start, Edge.end),
"SELECT edge.id AS edge_id, edge.x1 AS edge_x1, "
def test_order_by_aliased(self):
self._fixture(False)
Edge = self.classes.Edge
- s = Session()
+ s = fixture_session()
ea = aliased(Edge)
self.assert_compile(
s.query(ea).order_by(ea.start, ea.end),
from sqlalchemy.orm import mapper
from sqlalchemy.orm import query_expression
from sqlalchemy.orm import relationship
-from sqlalchemy.orm import Session
from sqlalchemy.orm import with_expression
from sqlalchemy.orm import with_polymorphic
from sqlalchemy.sql import sqltypes
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import AssertsCompiledSQL
from sqlalchemy.testing import eq_
+from sqlalchemy.testing.fixtures import fixture_session
from .inheritance import _poly_fixtures
from .test_query import QueryTest
def test_no_joinedload_in_subquery_select_rows(self, joinedload_fixture):
User, Address = joinedload_fixture
- sess = Session()
+ sess = fixture_session()
stmt1 = sess.query(User).subquery()
stmt1 = sess.query(stmt1)
def test_no_joinedload_in_subquery_select_entity(self, joinedload_fixture):
User, Address = joinedload_fixture
- sess = Session()
+ sess = fixture_session()
stmt1 = sess.query(User).subquery()
ua = aliased(User, stmt1)
stmt1 = sess.query(ua)
stmt1 = select(u1).where(u1.addresses.of_type(a1))
stmt2 = (
- Session()
+ fixture_session()
.query(u1)
.filter(u1.addresses.of_type(a1))
._final_statement(legacy_query_style=False)
.order_by(Person.person_id)
)
- sess = Session()
+ sess = fixture_session()
q = (
sess.query(Person.person_id, Person.name)
.filter(Person.name == "some name")
.order_by(Person.person_id)
)
- sess = Session()
+ sess = fixture_session()
q = (
sess.query(Person)
.filter(Person.name == "some name")
.order_by(Engineer.person_id)
)
- sess = Session()
+ sess = fixture_session()
q = (
sess.query(Engineer)
.filter(Engineer.name == "some name")
.order_by(Engineer.person_id)
)
- sess = Session()
+ sess = fixture_session()
q = (
sess.query(Engineer.person_id, Engineer.name)
.filter(Engineer.name == "some name")
)
stmt2 = select(Company).join(Company.employees)
stmt3 = (
- Session()
+ fixture_session()
.query(Company)
.join(Company.employees)
._final_statement(legacy_query_style=False)
select(Company).join(Company.employees).where(Person.name == "ed")
)
stmt3 = (
- Session()
+ fixture_session()
.query(Company)
.join(Company.employees)
.filter(Person.name == "ed")
stmt2 = select(Company).join(Company.employees).join(Person.paperwork)
stmt3 = (
- Session()
+ fixture_session()
.query(Company)
.join(Company.employees)
.join(Person.paperwork)
stmt2 = select(Company).join(Company.employees.of_type(p1))
stmt3 = (
- Session()
+ fixture_session()
.query(Company)
.join(Company.employees.of_type(p1))
._final_statement(legacy_query_style=False)
Company, Person, Manager, Engineer = self.classes(
"Company", "Person", "Manager", "Engineer"
)
- s = Session()
+ s = fixture_session()
p1 = with_polymorphic(Person, "*", aliased=True)
stmt2 = select(Company).join(p1, Company.employees.of_type(p1))
stmt3 = (
- Session()
+ fixture_session()
.query(Company)
.join(Company.employees.of_type(p1))
._final_statement(legacy_query_style=False)
stmt1 = select(User).where(User.addresses)
stmt2 = (
- Session()
+ fixture_session()
.query(User)
.filter(User.addresses)
._final_statement(legacy_query_style=False)
stmt1 = select(Item).where(Item.keywords)
stmt2 = (
- Session()
+ fixture_session()
.query(Item)
.filter(Item.keywords)
._final_statement(legacy_query_style=False)
expected = "SELECT * FROM users"
stmt1 = select(literal_column("*")).select_from(User)
stmt2 = (
- Session()
+ fixture_session()
.query(literal_column("*"))
.select_from(User)
._final_statement(legacy_query_style=False)
stmt1 = select(literal_column("*")).select_from(ua)
stmt2 = (
- Session()
+ fixture_session()
.query(literal_column("*"))
.select_from(ua)
._final_statement(legacy_query_style=False)
.scalar_subquery(),
)
stmt2 = (
- Session()
+ fixture_session()
.query(
User.name,
Address.id,
)
stmt2 = (
- Session()
+ fixture_session()
.query(
uu.name,
Address.id,
stmt1 = select(User)
stmt2 = (
- Session().query(User)._final_statement(legacy_query_style=False)
+ fixture_session()
+ .query(User)
+ ._final_statement(legacy_query_style=False)
)
self.assert_compile(stmt1, expected)
stmt1 = select(User.id, User.name)
stmt2 = (
- Session()
+ fixture_session()
.query(User.id, User.name)
._final_statement(legacy_query_style=False)
)
stmt1 = select(ua.id, ua.name)
stmt2 = (
- Session()
+ fixture_session()
.query(ua.id, ua.name)
._final_statement(legacy_query_style=False)
)
ua = aliased(User, name="ua")
stmt1 = select(ua)
- stmt2 = Session().query(ua)._final_statement(legacy_query_style=False)
+ stmt2 = (
+ fixture_session()
+ .query(ua)
+ ._final_statement(legacy_query_style=False)
+ )
expected = "SELECT ua.id, ua.name FROM users AS ua"
self.assert_compile(stmt1, expected)
User = self.classes.User
Address = self.classes.Address
- s = Session()
+ s = fixture_session()
q = s.query(User.id, User.name).filter_by(name="ed")
self.assert_compile(
insert(Address).from_select(("id", "email_address"), q),
User = self.classes.User
Address = self.classes.Address
- s = Session()
+ s = fixture_session()
q = s.query(User.id, User.name).filter_by(name="ed")
self.assert_compile(
insert(Address).from_select(
stmt1 = select(Foo).where(Foo.foob == "somename").order_by(Foo.foob)
stmt2 = (
- Session()
+ fixture_session()
.query(Foo)
.filter(Foo.foob == "somename")
.order_by(Foo.foob)
from sqlalchemy import String
from sqlalchemy import testing
from sqlalchemy.orm import backref
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
-from sqlalchemy.orm import Session
-from sqlalchemy.orm import sessionmaker
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import is_
from sqlalchemy.testing.assertsql import CompiledSQL
from sqlalchemy.testing.assertsql import Conditional
from sqlalchemy.testing.assertsql import RegexSQL
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
a = C1("head c1")
a.c1s.append(C1("another c1"))
- sess = create_session()
+ sess = fixture_session()
sess.add(a)
sess.flush()
sess.delete(a)
c1 = C1()
- sess = create_session()
+ sess = fixture_session()
sess.add(c1)
sess.flush()
sess.expunge_all()
a.c1s[0].c1s.append(C1("subchild2"))
a.c1s[1].c2s.append(C2("child2 data1"))
a.c1s[1].c2s.append(C2("child2 data2"))
- sess = create_session()
+ sess = fixture_session()
sess.add(a)
sess.flush()
mapper(C1, t1, properties={"children": relationship(C1)})
- sess = create_session()
+ sess = fixture_session()
c1 = C1()
c2 = C1()
c1.children.append(c2)
t1.children.append(TT())
t1.children.append(TT())
- s = create_session()
+ s = fixture_session()
s.add(t1)
s.flush()
s.expunge_all()
def test_lazy_clause(self):
TT = self.classes.TT
- s = create_session()
+ s = fixture_session()
t1 = TT()
t2 = TT()
t1.children.append(t2)
Child1, Child2 = self.classes.Child1, self.classes.Child2
- session = create_session()
+ session = fixture_session()
c1 = Child1()
c1.child1_data = "qwerty"
},
)
- sess = create_session()
+ sess = fixture_session()
bobj = B()
sess.add(bobj)
cobj = C()
o1 = T1()
o1.t2 = T2()
- sess = create_session()
+ sess = fixture_session()
sess.add(o1)
sess.flush()
o1 = T1()
o1.t2 = T2()
- sess = create_session()
+ sess = fixture_session()
sess.add(o1)
sess.flush()
a.c2s.append(b)
d.c1s.append(c)
b.c1s.append(c)
- sess = create_session()
+ sess = fixture_session()
sess.add_all((a, b, c, d, e, f))
sess.flush()
a.data.append(C1Data(data="c1data1"))
a.data.append(C1Data(data="c1data2"))
c.data.append(C1Data(data="c1data3"))
- sess = create_session()
+ sess = fixture_session()
sess.add_all((a, b, c, d, e, f))
sess.flush()
b = Ball()
p = Person()
p.balls.append(b)
- sess = create_session()
+ sess = fixture_session()
sess.add(p)
sess.flush()
b = Ball(data="some data")
p = Person(data="some data")
p.favorite = b
- sess = create_session()
+ sess = fixture_session()
sess.add(b)
sess.add(p)
sess.flush()
p.balls.append(Ball(data="some data"))
p.balls.append(Ball(data="some data"))
p.favorite = b
- sess = create_session()
+ sess = fixture_session()
sess.add(b)
sess.add(p)
),
)
- sess = sessionmaker()()
+ sess = fixture_session()
p1 = Person(data="p1")
p2 = Person(data="p2")
p3 = Person(data="p3")
b4 = Ball(data="some data")
p.balls.append(b4)
p.favorite = b
- sess = create_session()
+ sess = fixture_session()
sess.add_all((b, p, b2, b3, b4))
self.assert_sql_execution(
)
mapper(Person, person)
- sess = create_session(autocommit=False, expire_on_commit=True)
+ sess = fixture_session(autocommit=False, expire_on_commit=True)
sess.add(Ball(person=Person()))
sess.commit()
b1 = sess.query(Ball).first()
},
)
- session = create_session()
+ session = fixture_session(autoflush=False)
def append_child(parent, child):
if parent.children:
},
)
- session = create_session()
+ session = fixture_session()
f1 = A(fui="f1")
session.add(f1)
properties={"parent": relationship(Child, remote_side=child.c.id)},
)
- session = create_session()
+ session = fixture_session()
p1 = Parent("p1")
c1 = Child("c1")
c2 = Child("c2")
mapper(Child2, child2)
mapper(Child3, child3)
- sess = create_session()
+ sess = fixture_session()
p1 = Parent("p1")
c11, c12, c13 = Child1("c1"), Child1("c2"), Child1("c3")
def test_update_defaults(self):
A, B = self.classes("A", "B")
- s = Session()
+ s = fixture_session()
a1 = A()
b1 = B()
event.listen(A, "refresh_flush", canary.refresh_flush)
event.listen(A, "expire", canary.expire)
- s = Session()
+ s = fixture_session()
a1 = A()
b1 = B()
event.listen(A, "refresh_flush", canary.refresh_flush)
event.listen(A, "expire", canary.expire)
- s = Session()
+ s = fixture_session()
a1 = A()
s.add(a1)
event.listen(A, "refresh_flush", canary.refresh_flush)
event.listen(A, "expire", canary.expire)
- s = Session()
+ s = fixture_session()
a1 = A()
b1 = B()
event.listen(A, "refresh_flush", canary.refresh_flush)
event.listen(A, "expire", canary.expire)
- s = Session()
+ s = fixture_session()
a1 = A()
s.add(a1)
def test_update_defaults_can_set_value(self):
A, B = self.classes("A", "B")
- s = Session()
+ s = fixture_session()
a1 = A()
b1 = B()
import sqlalchemy as sa
from sqlalchemy import testing
from sqlalchemy import util
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
-from sqlalchemy.orm import Session
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import eq_
+from sqlalchemy.testing.fixtures import fixture_session
from test.orm import _fixtures
),
)
- return create_session()
+ return fixture_session()
def _upgrade_fixture(self):
(
),
)
- return create_session()
+ return fixture_session()
def test_downgrade_baseline(self):
"""Mapper strategy defaults load as expected
)
),
)
- q = create_session().query(m)
+ q = fixture_session().query(m)
result = [None]
def go():
)
),
)
- q = create_session().query(m).options(sa.orm.lazyload("addresses"))
+ q = fixture_session().query(m).options(sa.orm.lazyload("addresses"))
result = [None]
def go():
)
mapper(Address, addresses, properties={"user": relationship(User)})
mapper(User, users)
- s = Session()
+ s = fixture_session()
a1 = (
s.query(Address)
.filter_by(id=1)
from sqlalchemy import Integer
from sqlalchemy import String
from sqlalchemy import testing
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import mapper
-from sqlalchemy.orm import Session
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
from sqlalchemy.testing.assertsql import assert_engine
from sqlalchemy.testing.assertsql import CompiledSQL
from sqlalchemy.testing.assertsql import Conditional
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
eq_(d1.col3, None)
eq_(d1.col4, None)
- session = create_session()
+ session = fixture_session()
session.add(d1)
session.flush()
d1 = Default(id=1)
- session = create_session()
+ session = fixture_session()
session.add(d1)
session.flush()
d1.col1 = "set"
mapper(Foo, dt, exclude_properties=("col1",))
f1 = Foo()
- sess = create_session()
+ sess = fixture_session()
sess.add(f1)
sess.flush()
- eq_(dt.select().execute().fetchall(), [(1, "hello")])
+ eq_(sess.connection().execute(dt.select()).fetchall(), [(1, "hello")])
class ComputedDefaultsOnUpdateTest(fixtures.MappedTest):
else:
Thing = self.classes.ThingNoEager
- s = Session()
+ s = fixture_session()
t1, t2 = (Thing(id=1, foo=5), Thing(id=2, foo=10))
else:
Thing = self.classes.ThingNoEager
- s = Session()
+ s = fixture_session()
t1, t2 = (Thing(id=1, foo=1), Thing(id=2, foo=2))
def test_insert_identity(self):
Thing = self.classes.Thing
- s = Session()
+ s = fixture_session()
t1, t2 = (Thing(foo=5), Thing(foo=10))
from sqlalchemy.orm import aliased
from sqlalchemy.orm import attributes
from sqlalchemy.orm import contains_eager
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import defaultload
from sqlalchemy.orm import defer
from sqlalchemy.orm import deferred
from sqlalchemy.testing import AssertsCompiledSQL
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from test.orm import _fixtures
o = Order()
self.assert_(o.description is None)
- q = create_session().query(Order).order_by(Order.id)
+ q = fixture_session().query(Order).order_by(Order.id)
def go():
result = q.all()
mapper(Order, orders, properties={"id": deferred(orders.c.id)})
# right now, it's not that graceful :)
- q = create_session().query(Order)
+ q = fixture_session().query(Order)
assert_raises_message(
sa.exc.NoSuchColumnError, "Could not locate", q.first
)
properties={"description": deferred(orders.c.description)},
)
- sess = create_session()
+ sess = fixture_session()
o = Order()
sess.add(o)
o.id = 7
},
)
- sess = create_session()
+ sess = fixture_session()
o1 = sess.query(Order).get(1)
eq_(o1.description, "order 1")
properties={"description": deferred(orders.c.description)},
)
- sess = create_session()
+ sess = fixture_session()
o = Order()
sess.add(o)
),
)
- sess = create_session()
+ sess = fixture_session()
o = Order()
sess.add(o)
o.id = 7
),
)
- sess = create_session()
+ sess = fixture_session()
o = Order()
sess.add(o)
properties={"description": deferred(orders.c.description)},
)
- sess = create_session()
+ sess = fixture_session()
o2 = sess.query(Order).get(2)
o2.isopen = 1
sess.flush()
),
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(Order).order_by(Order.id)
def go():
"opened": deferred(orders.c.isopen, group="primary"),
},
)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
o = sess.query(Order).get(3)
assert "userident" not in o.__dict__
o.description = "somenewdescription"
},
)
- sess = create_session()
+ sess = fixture_session()
o2 = sess.query(Order).get(3)
# this will load the group of attributes
properties={"description": deferred(order_select.c.description)},
)
- sess = Session()
+ sess = fixture_session()
o1 = sess.query(Order).order_by(Order.id).first()
assert "description" not in o1.__dict__
eq_(o1.description, "order 1")
mapper(Order, orders)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(Order).order_by(Order.id).options(defer("user_id"))
def go():
),
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(Order).order_by(Order.id)
def go():
),
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(Order).order_by(Order.id)
def go():
),
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(Order).order_by(Order.id)
def go():
),
)
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(User)
.filter(User.id == 7)
),
)
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(User)
.filter(User.id == 7)
),
)
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(User)
.filter(User.id == 7)
),
)
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(User)
.filter(User.id == 7)
),
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(Order).options(Load(Order).undefer("*"))
self.assert_compile(
q,
properties={"description": deferred(orders.c.description)},
)
- sess = create_session()
+ sess = fixture_session()
o1 = (
sess.query(Order)
.order_by(Order.id)
properties={"description": deferred(orders.c.description)},
)
- sess = create_session()
+ sess = fixture_session()
stmt = sa.select(Order).order_by(Order.id)
o1 = (sess.query(Order).from_statement(stmt).all())[0]
},
)
- sess = create_session()
+ sess = fixture_session()
stmt = sa.select(Order).order_by(Order.id)
o1 = (sess.query(Order).from_statement(stmt).all())[0]
mapper(Order, orders)
- sess = create_session()
+ sess = fixture_session()
stmt = sa.select(Order).order_by(Order.id)
o1 = (
sess.query(Order)
mapper(Order, orders)
- sess = create_session()
+ sess = fixture_session()
stmt = sa.select(Order).order_by(Order.id)
o1 = (
sess.query(Order)
properties=dict(orders=relationship(Order, order_by=orders.c.id)),
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User).order_by(User.id)
result = q.all()
item = result[0].orders[1].items[1]
)
mapper(Item, items)
- sess = create_session()
+ sess = fixture_session()
exp = (
"SELECT users.id AS users_id, users.name AS users_name, "
mapper(User, users, properties={"orders": relationship(Order)})
mapper(Order, orders)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User).options(
joinedload(User.orders).defer("description").defer("isopen")
)
mapper(Order, orders)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(Order).options(load_only("isopen", "description"))
self.assert_compile(
q,
mapper(Order, orders)
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(Order)
.order_by(Order.id)
properties={"description": deferred(orders.c.description)},
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(Order).options(
load_only("isopen", "description"), undefer("user_id")
)
mapper(User, users, properties={"addresses": relationship(Address)})
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
expected = [
(
"SELECT users.id AS users_id, users.name AS users_name "
mapper(Address, addresses)
mapper(Order, orders)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User, Order, Address).options(
Load(User).load_only("name"),
Load(Order).load_only("id"),
mapper(Address, addresses)
mapper(Order, orders)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User).options(
load_only("name")
def test_present_overrides_deferred(self):
Node = self.classes.Node
- session = Session()
+ session = fixture_session()
q = session.query(Node).options(
joinedload(Node.parent).load_only(Node.id, Node.parent_id)
)
def test_load_only_subclass(self):
- s = Session()
+ s = fixture_session()
q = (
s.query(Manager)
.order_by(Manager.person_id)
)
def test_load_only_subclass_bound(self):
- s = Session()
+ s = fixture_session()
q = (
s.query(Manager)
.order_by(Manager.person_id)
)
def test_load_only_subclass_and_superclass(self):
- s = Session()
+ s = fixture_session()
q = (
s.query(Boss)
.order_by(Person.person_id)
)
def test_load_only_subclass_and_superclass_bound(self):
- s = Session()
+ s = fixture_session()
q = (
s.query(Boss)
.order_by(Person.person_id)
)
def test_load_only_alias_subclass(self):
- s = Session()
+ s = fixture_session()
m1 = aliased(Manager, flat=True)
q = (
s.query(m1)
)
def test_load_only_alias_subclass_bound(self):
- s = Session()
+ s = fixture_session()
m1 = aliased(Manager, flat=True)
q = (
s.query(m1)
)
def test_load_only_subclass_from_relationship_polymorphic(self):
- s = Session()
+ s = fixture_session()
wp = with_polymorphic(Person, [Manager], flat=True)
q = (
s.query(Company)
)
def test_load_only_subclass_from_relationship_polymorphic_bound(self):
- s = Session()
+ s = fixture_session()
wp = with_polymorphic(Person, [Manager], flat=True)
q = (
s.query(Company)
)
def test_load_only_subclass_from_relationship(self):
- s = Session()
+ s = fixture_session()
q = (
s.query(Company)
.join(Company.managers)
)
def test_load_only_subclass_from_relationship_bound(self):
- s = Session()
+ s = fixture_session()
q = (
s.query(Company)
.join(Company.managers)
# TODO: what is ".*"? this is not documented anywhere, how did this
# get implemented without docs ? see #4390
- s = Session()
+ s = fixture_session()
q = (
s.query(Manager)
.order_by(Person.person_id)
# to have this ".*" featue.
def test_load_only_subclass_of_type(self):
- s = Session()
+ s = fixture_session()
q = s.query(Company).options(
joinedload(Company.employees.of_type(Manager)).load_only("status")
)
)
def test_wildcard_subclass_of_type(self):
- s = Session()
+ s = fixture_session()
q = s.query(Company).options(
joinedload(Company.employees.of_type(Manager)).defer("*")
)
)
def test_defer_super_name_on_subclass(self):
- s = Session()
+ s = fixture_session()
q = s.query(Manager).order_by(Person.person_id).options(defer("name"))
self.assert_compile(
q,
)
def test_defer_super_name_on_subclass_bound(self):
- s = Session()
+ s = fixture_session()
q = (
s.query(Manager)
.order_by(Person.person_id)
)
def test_load_only_from_with_polymorphic(self):
- s = Session()
+ s = fixture_session()
wp = with_polymorphic(Person, [Manager], flat=True)
)
def test_load_only_of_type_with_polymorphic(self):
- s = Session()
+ s = fixture_session()
wp = with_polymorphic(Person, [Manager], flat=True)
def test_simple_expr(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
a1 = (
s.query(A)
.options(with_expression(A.my_expr, A.x + A.y))
def test_expr_default_value(self):
A = self.classes.A
C = self.classes.C
- s = Session()
+ s = fixture_session()
a1 = s.query(A).order_by(A.id).filter(A.x > 1)
eq_(a1.all(), [A(my_expr=None), A(my_expr=None), A(my_expr=None)])
def test_reuse_expr(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
# so people will obv. want to say, "filter(A.my_expr > 10)".
# but that means Query or Core has to post-modify the statement
def test_in_joinedload(self):
A, B = self.classes("A", "B")
- s = Session()
+ s = fixture_session()
q = (
s.query(A)
def test_no_refresh_unless_populate_existing(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
a1 = s.query(A).first()
def go():
def test_no_sql_not_set_up(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
a1 = s.query(A).first()
def go():
def test_dont_explode_on_expire_individual(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
q = (
s.query(A)
.options(with_expression(A.my_expr, A.x + A.y))
def test_dont_explode_on_expire_whole(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
q = (
s.query(A)
.options(with_expression(A.my_expr, A.x + A.y))
def test_mapper_raise(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
a1 = s.query(A).first()
assert_raises_message(
sa.exc.InvalidRequestError,
def test_mapper_defer_unraise(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
a1 = s.query(A).options(defer(A.z)).first()
assert "z" not in a1.__dict__
eq_(a1.z, 4)
def test_mapper_undefer_unraise(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
a1 = s.query(A).options(undefer(A.z)).first()
assert "z" in a1.__dict__
eq_(a1.z, 4)
def test_deferred_raise_option_raise_column_plain(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
a1 = s.query(A).options(defer(A.x)).first()
a1.x
def test_deferred_raise_option_load_column_unexpire(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
a1 = s.query(A).options(defer(A.x, raiseload=True)).first()
s.expire(a1, ["x"])
def test_mapper_raise_after_expire_attr(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
a1 = s.query(A).first()
s.expire(a1, ["z"])
def test_mapper_raise_after_expire_obj(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
a1 = s.query(A).first()
s.expire(a1)
def test_mapper_raise_after_modify_attr_expire_obj(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
a1 = s.query(A).first()
a1.z = 10
def test_deferred_raise_option_load_after_expire_obj(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
a1 = s.query(A).options(defer(A.y, raiseload=True)).first()
s.expire(a1)
def test_option_raiseload_unexpire_modified_obj(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
a1 = s.query(A).options(defer(A.y, raiseload=True)).first()
a1.y = 10
def test_option_raise_deferred(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
a1 = s.query(A).options(defer(A.y, raiseload=True)).first()
assert_raises_message(
def test_does_expire_cancel_normal_defer_option(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
a1 = s.query(A).options(defer(A.x)).first()
# expire object
def test_deferred_autoflushes(self):
A, B = self.classes("A", "B")
- s = Session()
+ s = fixture_session()
a1 = A(id=1, bs=[B()])
s.add(a1)
def test_no_previous_query(self):
Thing = self.classes.Thing
- session = create_session()
+ session = fixture_session()
thing = session.query(Thing).options(sa.orm.undefer("name")).first()
self._test(thing)
def test_query_twice_with_clear(self):
Thing = self.classes.Thing
- session = create_session()
+ session = fixture_session()
result = session.query(Thing).first() # noqa
session.expunge_all()
thing = session.query(Thing).options(sa.orm.undefer("name")).first()
def test_query_twice_no_clear(self):
Thing = self.classes.Thing
- session = create_session()
+ session = fixture_session()
result = session.query(Thing).first() # noqa
thing = session.query(Thing).options(sa.orm.undefer("name")).first()
self._test(thing)
def test_joinedload_with_clear(self):
Thing, Human = self.classes.Thing, self.classes.Human
- session = create_session()
+ session = fixture_session()
human = ( # noqa
session.query(Human).options(sa.orm.joinedload("thing")).first()
)
def test_joinedload_no_clear(self):
Thing, Human = self.classes.Thing, self.classes.Human
- session = create_session()
+ session = fixture_session()
human = ( # noqa
session.query(Human).options(sa.orm.joinedload("thing")).first()
)
def test_join_with_clear(self):
Thing, Human = self.classes.Thing, self.classes.Human
- session = create_session()
+ session = fixture_session()
result = ( # noqa
session.query(Human).add_entity(Thing).join("thing").first()
)
def test_join_no_clear(self):
Thing, Human = self.classes.Thing, self.classes.Human
- session = create_session()
+ session = fixture_session()
result = ( # noqa
session.query(Human).add_entity(Thing).join("thing").first()
)
from sqlalchemy import func
from sqlalchemy import Integer
from sqlalchemy import literal_column
+from sqlalchemy import MetaData
from sqlalchemy import or_
from sqlalchemy import select
from sqlalchemy import String
from sqlalchemy import testing
from sqlalchemy import text
from sqlalchemy import true
+from sqlalchemy.engine import default
from sqlalchemy.orm import aliased
from sqlalchemy.orm import as_declarative
from sqlalchemy.orm import attributes
from sqlalchemy.orm import configure_mappers
from sqlalchemy.orm import contains_alias
from sqlalchemy.orm import contains_eager
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import declarative_base
from sqlalchemy.orm import declared_attr
from sqlalchemy.orm import defer
from sqlalchemy.testing import assertions
from sqlalchemy.testing import AssertsCompiledSQL
from sqlalchemy.testing import eq_
+from sqlalchemy.testing import eq_ignore_whitespace
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import is_
from sqlalchemy.testing import is_true
from sqlalchemy.testing import mock
from sqlalchemy.testing.assertsql import CompiledSQL
from sqlalchemy.testing.fixtures import ComparableEntity
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.mock import call
from sqlalchemy.testing.mock import Mock
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from . import _fixtures
from .inheritance import _poly_fixtures
+from .test_bind import GetBindTest as _GetBindTest
from .test_dynamic import _DynamicFixture
from .test_events import _RemoveListeners
from .test_options import PathTest as OptionsPathTest
def test_deprecated_negative_slices(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User).order_by(User.id)
with testing.expect_deprecated(
def test_deprecated_negative_slices_compile(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User).order_by(User.id)
with testing.expect_deprecated(
def test_aliased(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
with testing.expect_deprecated_20(join_aliased_dep):
q1 = s.query(User).join(User.addresses, aliased=True)
User = self.classes.User
Address = self.classes.Address
- s = create_session()
+ s = fixture_session()
u1 = aliased(User)
User = self.classes.User
Address = self.classes.Address
- s = create_session()
+ s = fixture_session()
u1 = aliased(User)
def test_str_join_target(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
with testing.expect_deprecated_20(join_strings_dep):
q1 = s.query(User).join("addresses")
def test_str_rel_loader_opt(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q1 = s.query(User).options(joinedload("addresses"))
def test_str_col_loader_opt(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q1 = s.query(User).options(defer("name"))
User = self.classes.User
Address = self.classes.Address
- s = create_session()
+ s = fixture_session()
u1 = User(id=1)
def test_invalid_column(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q = s.query(User.id)
with testing.expect_deprecated(r"Query.add_column\(\) is deprecated"):
def test_via_textasfrom_select_from(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
with self._expect_implicit_subquery():
eq_(
def test_text_as_column(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
# TODO: this works as of "use rowproxy for ORM keyed tuple"
# Ieb9085e9bcff564359095b754da9ae0af55679f0
def test_query_as_scalar(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
with assertions.expect_deprecated(
r"The Query.as_scalar\(\) method is deprecated and will "
"be removed in a future release."
User, users = self.classes.User, self.tables.users
sel = users.select()
- sess = create_session()
+ sess = fixture_session()
with self._expect_implicit_subquery():
eq_(
def test_select_entity_from_select(self):
User, users = self.classes.User, self.tables.users
- sess = create_session()
+ sess = fixture_session()
with self._expect_implicit_subquery():
self.assert_compile(
sess.query(User.name).select_entity_from(
def test_select_entity_from_q_statement(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
with self._expect_implicit_subquery():
def test_select_from_q_statement_no_aliasing(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
with self._expect_implicit_subquery():
use_labels=True, order_by=[text("ulist.id"), addresses.c.id]
)
)
- sess = create_session()
+ sess = fixture_session()
# better way. use select_entity_from()
def go():
self.tables.users,
)
- sess = create_session()
+ sess = fixture_session()
# same thing, but alias addresses, so that the adapter
# generated by select_entity_from() is wrapped within
def test_select(self):
users = self.tables.users
- sess = create_session()
+ sess = fixture_session()
with self._expect_implicit_subquery():
self.assert_compile(
# mapper(Address, addresses)
sel = users.select(users.c.id.in_([7, 8]))
- sess = create_session()
+ sess = fixture_session()
with self._expect_implicit_subquery():
result = (
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
sel = users.select(users.c.id.in_([7, 8]))
with self._expect_implicit_subquery():
User, users = self.classes.User, self.tables.users
sel = users.select(users.c.id.in_([7, 8]))
- sess = create_session()
+ sess = fixture_session()
with self._expect_implicit_subquery():
eq_(
)
sel = users.select(users.c.id.in_([7, 8]))
- sess = create_session()
+ sess = fixture_session()
def go():
with self._expect_implicit_subquery():
self.classes.User,
)
- sess = Session()
+ sess = fixture_session()
oalias = orders.select()
def insert_data(cls, connection):
Node = cls.classes.Node
- sess = create_session(connection)
+ sess = Session(connection)
n1 = Node(data="n1")
n1.append(Node(data="n11"))
n1.append(Node(data="n12"))
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
n1 = aliased(Node)
def test_multiple_explicit_entities_two(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
parent = aliased(Node)
grandparent = aliased(Node)
def test_multiple_explicit_entities_three(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
parent = aliased(Node)
grandparent = aliased(Node)
def test_multiple_explicit_entities_five(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
parent = aliased(Node)
grandparent = aliased(Node)
class DynamicTest(_DynamicFixture, _fixtures.FixtureTest):
def test_negative_slice_access_raises(self):
User, Address = self._user_address_fixture()
- sess = create_session(testing.db)
+ sess = fixture_session()
u1 = sess.get(User, 8)
with testing.expect_deprecated_20(
User = self.classes.User
- s = Session()
+ s = fixture_session()
with self._from_self_deprecated():
q = s.query(User).from_self()
def test_columns_augmented_distinct_on(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
with self._from_self_deprecated():
q = (
"""
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
with self._from_self_deprecated():
q = (
sess.query(User, Address.email_address)
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
with self._from_self_deprecated():
q = (
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
# explicit onclause with from_self(), means
# the onclause must be aliased against the query's custom
# FROM object
Item, Keyword = self.classes.Item, self.classes.Keyword
- sess = create_session()
+ sess = fixture_session()
with self._from_self_deprecated():
self.assert_compile(
def test_single_prop_9(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
with self._from_self_deprecated():
self.assert_compile(
sess.query(User)
def test_anonymous_expression_from_self_twice_oldstyle(self):
# relies upon _orm_only_from_obj_alias setting
- sess = create_session()
+ sess = fixture_session()
c1, c2 = column("c1"), column("c2")
q1 = sess.query(c1, c2).filter(c1 == "dog")
with self._from_self_deprecated():
Address = self.classes.Address
addresses = self.tables.addresses
- sess = create_session()
+ sess = fixture_session()
q1 = sess.query(User.id).filter(User.id > 5)
with self._from_self_deprecated():
q1 = q1.from_self()
Address = self.classes.Address
addresses = self.tables.addresses
- sess = create_session()
+ sess = fixture_session()
q1 = sess.query(User.id).filter(User.id > 5)
with self._from_self_deprecated():
q1 = q1.from_self()
# relies upon _orm_only_from_obj_alias setting
from sqlalchemy.sql import column
- sess = create_session()
+ sess = fixture_session()
t1 = table("t1", column("c1"), column("c2"))
q1 = sess.query(t1.c.c1, t1.c.c2).filter(t1.c.c1 == "dog")
with self._from_self_deprecated():
def test_self_referential(self):
Order = self.classes.Order
- sess = create_session()
+ sess = fixture_session()
oalias = aliased(Order)
with self._from_self_deprecated():
# relies upon _orm_only_from_obj_alias setting
Order = self.classes.Order
- sess = create_session()
+ sess = fixture_session()
# ensure column expressions are taken from inside the subquery, not
# restated at the top
def test_column_access_from_self(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
with self._from_self_deprecated():
q = sess.query(User).from_self()
def test_column_access_from_self_twice(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
with self._from_self_deprecated():
q = sess.query(User).from_self(User.id, User.name).from_self()
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
adalias = aliased(Address)
# select from aliasing + explicit aliasing
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
# anon + select from aliasing
aa = aliased(Address)
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
adalias = aliased(Address)
# test eager aliasing, with/without select_entity_from aliasing
with self._from_self_deprecated():
eq_(
[User(id=8), User(id=9)],
- create_session()
+ fixture_session()
.query(User)
.filter(User.id.in_([8, 9]))
.from_self()
with self._from_self_deprecated():
eq_(
[User(id=8), User(id=9)],
- create_session()
+ fixture_session()
.query(User)
.order_by(User.id)
.slice(1, 3)
eq_(
[User(id=8)],
list(
- create_session()
+ fixture_session()
.query(User)
.filter(User.id.in_([8, 9]))
.from_self()
(User(id=8), Address(id=4)),
(User(id=9), Address(id=5)),
],
- create_session()
+ fixture_session()
.query(User)
.filter(User.id.in_([8, 9]))
.from_self()
Address = self.classes.Address
eq_(
- create_session()
+ fixture_session()
.query(Address.user_id, func.count(Address.id).label("count"))
.group_by(Address.user_id)
.order_by(Address.user_id)
with self._from_self_deprecated():
eq_(
- create_session()
+ fixture_session()
.query(Address.user_id, Address.id)
.from_self(Address.user_id, func.count(Address.id))
.group_by(Address.user_id)
def test_having(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
with self._from_self_deprecated():
self.assert_compile(
User = self.classes.User
- s = create_session()
+ s = fixture_session()
with self._from_self_deprecated():
q = s.query(User).options(joinedload(User.addresses)).from_self()
User, Address = self.classes.User, self.classes.Address
- s = create_session()
+ s = fixture_session()
ualias = aliased(User)
def test_multiple_entities(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
with self._from_self_deprecated():
eq_(
# relies upon _orm_only_from_obj_alias setting
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
with self._from_self_deprecated():
eq_(
def test_subq_w_from_self_one(self):
A, B, C = self.classes("A", "B", "C")
- s = Session()
+ s = fixture_session()
cache = {}
A, B, C = self.classes("A", "B", "C")
- s = Session()
+ s = fixture_session()
cache = {}
for i in range(3):
with testing.expect_deprecated_20(
"The Session.autocommit parameter is deprecated"
):
- sess = Session(autocommit=True)
+ sess = Session(testing.db, autocommit=True)
with sess.begin():
sess.add(User(name="u1"))
with testing.expect_deprecated_20(
"The Session.autocommit parameter is deprecated"
):
- sess = Session(autocommit=True)
+ sess = Session(testing.db, autocommit=True)
def go():
with sess.begin():
eq_(sess.query(User).count(), 1)
+class AutocommitClosesOnFailTest(fixtures.MappedTest):
+ __requires__ = ("deferrable_or_no_constraints",)
+
+ @classmethod
+ def define_tables(cls, metadata):
+ Table("t1", metadata, Column("id", Integer, primary_key=True))
+
+ Table(
+ "t2",
+ metadata,
+ Column("id", Integer, primary_key=True),
+ Column(
+ "t1_id",
+ Integer,
+ ForeignKey("t1.id", deferrable=True, initially="deferred"),
+ ),
+ )
+
+ @classmethod
+ def setup_classes(cls):
+ class T1(cls.Comparable):
+ pass
+
+ class T2(cls.Comparable):
+ pass
+
+ @classmethod
+ def setup_mappers(cls):
+ T2, T1, t2, t1 = (
+ cls.classes.T2,
+ cls.classes.T1,
+ cls.tables.t2,
+ cls.tables.t1,
+ )
+
+ mapper(T1, t1)
+ mapper(T2, t2)
+
+ def test_close_transaction_on_commit_fail(self):
+ T2 = self.classes.T2
+
+ session = fixture_session(autocommit=True)
+
+ # with a deferred constraint, this fails at COMMIT time instead
+ # of at INSERT time.
+ session.add(T2(t1_id=123))
+
+ assert_raises(sa.exc.IntegrityError, session.flush)
+
+ assert session._legacy_transaction() is None
+
+
class DeprecatedInhTest(_poly_fixtures._Polymorphic):
def test_with_polymorphic(self):
Person = _poly_fixtures.Person
engineers = self.tables.engineers
machines = self.tables.machines
- sess = create_session()
+ sess = fixture_session()
mach_alias = machines.select()
with DeprecatedQueryTest._expect_implicit_subquery():
m.add_property("_name", deferred(users.c.name))
m.add_property("name", synonym("_name"))
- sess = create_session(autocommit=False)
+ sess = fixture_session(autocommit=False)
assert sess.query(User).get(7)
u = sess.query(User).filter_by(name="jack").one()
assert_raises_message(
sa.exc.ArgumentError,
message,
- create_session()
+ fixture_session()
.query(*entity_list)
.options(*options)
._compile_context,
},
)
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated(
r"The \*addl_attrs on orm.defer is deprecated. "
User, Address, Order, Item = self.classes(
"User", "Address", "Order", "Item"
)
- q = create_session().query(User).order_by(User.id)
+ q = fixture_session().query(User).order_by(User.id)
def go():
eq_(
self.assert_sql_count(testing.db, go, count)
- sess = create_session()
+ sess = fixture_session()
user = sess.query(User).get(7)
closed_mapper = User.closed_orders.entity
open_mapper = User.open_orders.entity
eq_(
[Order(id=1), Order(id=5)],
- create_session()
+ fixture_session()
.query(closed_mapper)
.with_parent(user, property="closed_orders")
.all(),
)
eq_(
[Order(id=3)],
- create_session()
+ fixture_session()
.query(open_mapper)
.with_parent(user, property="open_orders")
.all(),
use_labels=True, order_by=[text("ulist.id"), addresses.c.id]
)
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
# note this has multiple problems because we aren't giving Query
use_labels=True, order_by=[text("ulist.id"), addresses.c.id]
)
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
def go():
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
selectquery = users.outerjoin(addresses).select(
users.c.id < 10,
):
result = list(
q.options(contains_eager("addresses")).instances(
- selectquery.execute()
+ sess.execute(selectquery)
)
)
assert self.static.user_address_result[0:3] == result
):
result = list(
q.options(contains_eager(User.addresses)).instances(
- selectquery.execute()
+ sess.connection().execute(selectquery)
)
)
assert self.static.user_address_result[0:3] == result
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
adalias = addresses.alias("adalias")
result = list(
q.options(
contains_eager("addresses", alias="adalias")
- ).instances(selectquery.execute())
+ ).instances(sess.connection().execute(selectquery))
)
assert self.static.user_address_result == result
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
adalias = addresses.alias("adalias")
result = list(
q.options(
contains_eager("addresses", alias=adalias)
- ).instances(selectquery.execute())
+ ).instances(sess.connection().execute(selectquery))
)
assert self.static.user_address_result == result
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
oalias = orders.alias("o1")
q.options(
contains_eager("orders", alias="o1"),
contains_eager("orders.items", alias="i1"),
- ).instances(query.execute())
+ ).instances(sess.connection().execute(query))
)
assert self.static.user_order_result == result
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
oalias = orders.alias("o1")
q.options(
contains_eager("orders", alias=oalias),
contains_eager("orders.items", alias=ialias),
- ).instances(query.execute())
+ ).instances(sess.connection().execute(query))
)
assert self.static.user_order_result == result
def test_columns_augmented_roundtrip_one(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated_20(join_strings_dep):
q = (
sess.query(User)
def test_columns_augmented_roundtrip_two(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated_20(join_strings_dep):
q = (
sess.query(User)
def test_columns_augmented_roundtrip_three(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(User.id, User.name.label("foo"), Address.id)
def test_columns_augmented_sql_one(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(User.id, User.name.label("foo"), Address.id)
def test_on_bulk_update_hook(self):
User, users = self.classes.User, self.tables.users
- sess = Session()
+ sess = fixture_session()
canary = Mock()
event.listen(sess, "after_bulk_update", canary.after_bulk_update)
def test_on_bulk_delete_hook(self):
User, users = self.classes.User, self.tables.users
- sess = Session()
+ sess = fixture_session()
canary = Mock()
event.listen(sess, "after_bulk_delete", canary.after_bulk_delete)
def test_value(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated(r"Query.value\(\) is deprecated"):
eq_(sess.query(User).filter_by(id=7).value(User.id), 7)
def test_value_cancels_loader_opts(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(User)
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated(r"Query.values?\(\) is deprecated"):
assert list(sess.query(User).values()) == list()
def test_values_specific_order_by(self):
users, User = self.tables.users, self.classes.User
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated(r"Query.values?\(\) is deprecated"):
assert list(sess.query(User).values()) == list()
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
with testing.expect_deprecated(r"Query.values?\(\) is deprecated"):
self.classes.Order,
)
- sess = create_session()
+ sess = fixture_session()
OrderAlias = aliased(Order)
with testing.expect_deprecated_20(join_strings_dep):
self.classes.Order,
)
- sess = create_session()
+ sess = fixture_session()
# no arg error
with testing.expect_deprecated_20(join_aliased_dep):
(
self.classes.Address,
)
- sess = create_session()
+ sess = fixture_session()
# test a basic aliasized path
with testing.expect_deprecated(join_aliased_dep, join_strings_dep):
def test_overlapping_paths_two(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
# test overlapping paths. User->orders is used by both joins, but
# rendered once.
with testing.expect_deprecated_20(*warnings):
result = (
- create_session()
+ fixture_session()
.query(User)
.join("orders", "items", aliased=aliased_)
.filter_by(id=3)
def test_overlapping_paths_multilevel(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
with testing.expect_deprecated_20(join_strings_dep, join_chain_dep):
q = (
self.classes.Order,
)
- sess = create_session()
+ sess = fixture_session()
for oalias, ialias in [
(True, True),
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated(join_tuple_form):
q = (
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated_20(join_tuple_form):
q = (
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
# the old "backwards" form
with testing.expect_deprecated_20(join_tuple_form, join_strings_dep):
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated_20(join_strings_dep):
q = (
"User", "Order", "Item", "Keyword"
)
- sess = create_session()
+ sess = fixture_session()
# ensure when the tokens are broken up that from_joinpoint
# is set between them
def test_single_name(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated_20(join_strings_dep):
self.assert_compile(
User,
) = (self.classes.Order, self.classes.User)
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated_20(join_chain_dep):
self.assert_compile(
sess.query(User).join(User.orders, Order.items),
def test_single_prop_7(self):
Order, User = (self.classes.Order, self.classes.User)
- sess = create_session()
+ sess = fixture_session()
# this query is somewhat nonsensical. the old system didn't render a
# correct query for this. In this case its the most faithful to what
# was asked - there's no linkage between User.orders and "oalias",
User,
) = (self.classes.Order, self.classes.User)
- sess = create_session()
+ sess = fixture_session()
# same as before using an aliased() for User as well
ualias = aliased(User)
oalias = aliased(Order)
def test_single_prop_10(self):
User, Address = (self.classes.User, self.classes.Address)
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated_20(join_aliased_dep):
self.assert_compile(
sess.query(User)
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated_20(join_aliased_dep, join_chain_dep):
self.assert_compile(
sess.query(User)
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated_20(join_chain_dep, join_aliased_dep):
self.assert_compile(
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
# this is now a very weird test, nobody should really
# be using the aliased flag in this way.
with testing.expect_deprecated_20(join_strings_dep, join_chain_dep):
result = (
- create_session()
+ fixture_session()
.query(User)
.select_from(users.join(oalias))
.filter(
with testing.expect_deprecated_20(join_strings_dep, join_chain_dep):
result = (
- create_session()
+ fixture_session()
.query(User)
.select_from(users.join(oalias))
.filter(
# id 1 (order 3, owned by jack)
with testing.expect_deprecated_20(*warnings):
result = (
- create_session()
+ fixture_session()
.query(User)
.join("orders", "items", aliased=aliased_)
.filter_by(id=3)
with testing.expect_deprecated_20(*warnings):
result = (
- create_session()
+ fixture_session()
.query(User)
.join("orders", "items", aliased=aliased_, isouter=True)
.filter_by(id=3)
with testing.expect_deprecated_20(*warnings):
result = (
- create_session()
+ fixture_session()
.query(User)
.outerjoin("orders", "items", aliased=aliased_)
.filter_by(id=3)
def test_join_prop_to_string(self):
A, B, X = self.classes("A", "B", "X")
- s = Session()
+ s = fixture_session()
with testing.expect_deprecated_20(join_strings_dep):
q = s.query(B).join(B.a_list, "x_list").filter(X.name == "x1")
def test_join_prop_to_prop(self):
A, B, X = self.classes("A", "B", "X")
- s = Session()
+ s = fixture_session()
# B -> A, but both are Object. So when we say A.x_list, make sure
# we pick the correct right side
def insert_data(cls, connection):
Node = cls.classes.Node
- sess = create_session(connection)
+ sess = Session(connection)
n1 = Node(data="n1")
n1.append(Node(data="n11"))
n1.append(Node(data="n12"))
def test_join_1(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated_20(join_strings_dep, join_aliased_dep):
node = (
def test_join_2(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated_20(join_aliased_dep):
ret = (
sess.query(Node.data)
def test_join_3_filter_by(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated_20(
join_strings_dep, join_aliased_dep, join_chain_dep
):
def test_join_3_filter(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated_20(
join_strings_dep, join_aliased_dep, join_chain_dep
):
def test_join_4_filter_by(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated_20(join_strings_dep, join_aliased_dep):
q = (
def test_join_4_filter(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated_20(join_strings_dep, join_aliased_dep):
q = (
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
nalias = aliased(
Node, sess.query(Node).filter_by(data="n1").subquery()
)
def test_string_or_prop_aliased_two(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
nalias = aliased(
Node, sess.query(Node).filter_by(data="n1").subquery()
)
self.classes.Engineer,
)
- sess = create_session()
+ sess = fixture_session()
mach_alias = aliased(Machine, machines.select().subquery())
self.classes.Paperwork,
)
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated_20(join_strings_dep, w_polymorphic_dep):
self.assert_compile(
self.classes.Paperwork,
)
- sess = create_session()
+ sess = fixture_session()
with testing.expect_deprecated_20(
join_strings_dep, w_polymorphic_dep, join_aliased_dep
def test_mapped_to_select_implicit_left_w_aliased(self):
T1, T2 = self.classes.T1, self.classes.T2
- sess = Session()
+ sess = fixture_session()
subq = (
sess.query(T2.t1_id, func.count(T2.id).label("count"))
.group_by(T2.t1_id)
with testing.expect_deprecated_20(join_strings_dep):
q = (
- create_session()
+ fixture_session()
.query(T1)
.join("t2s_1")
.filter(t2.c.id == 5)
"WHERE t2.id = :id_1",
use_default_dialect=True,
)
+
+
+class BindSensitiveStringifyTest(fixtures.TestBase):
+ def _fixture(self):
+ # building a totally separate metadata /mapping here
+ # because we need to control if the MetaData is bound or not
+
+ class User(object):
+ pass
+
+ m = MetaData()
+ user_table = Table(
+ "users",
+ m,
+ Column("id", Integer, primary_key=True),
+ Column("name", String(50)),
+ )
+
+ mapper(User, user_table)
+ return User
+
+ def _dialect_fixture(self):
+ class MyDialect(default.DefaultDialect):
+ default_paramstyle = "qmark"
+
+ from sqlalchemy.engine import base
+
+ return base.Engine(mock.Mock(), MyDialect(), mock.Mock())
+
+ def _test(self, bound_session, session_present, expect_bound):
+ if bound_session:
+ eng = self._dialect_fixture()
+ else:
+ eng = None
+
+ User = self._fixture()
+
+ s = Session(eng if bound_session else None)
+ q = s.query(User).filter(User.id == 7)
+ if not session_present:
+ q = q.with_session(None)
+
+ eq_ignore_whitespace(
+ str(q),
+ "SELECT users.id AS users_id, users.name AS users_name "
+ "FROM users WHERE users.id = ?"
+ if expect_bound
+ else "SELECT users.id AS users_id, users.name AS users_name "
+ "FROM users WHERE users.id = :id_1",
+ )
+
+ def test_query_bound_session(self):
+ self._test(True, True, True)
+
+ def test_query_no_session(self):
+ self._test(False, False, False)
+
+ def test_query_unbound_session(self):
+ self._test(False, True, False)
+
+
+class GetBindTest(_GetBindTest):
+ @classmethod
+ def define_tables(cls, metadata):
+ super(GetBindTest, cls).define_tables(metadata)
+ metadata.bind = testing.db
+
+ def test_fallback_table_metadata(self):
+ session = self._fixture({})
+ is_(session.get_bind(self.classes.BaseClass), testing.db)
+
+ def test_bind_base_table_concrete_sub_class(self):
+ base_class_bind = Mock()
+ session = self._fixture({self.tables.base_table: base_class_bind})
+
+ is_(session.get_bind(self.classes.ConcreteSubClass), testing.db)
from sqlalchemy.orm import attributes
from sqlalchemy.orm import backref
from sqlalchemy.orm import configure_mappers
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import exc as orm_exc
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
-from sqlalchemy.orm import Session
from sqlalchemy.testing import assert_raises
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import AssertsCompiledSQL
from sqlalchemy.testing import expect_raises_message
from sqlalchemy.testing import is_
from sqlalchemy.testing.assertsql import CompiledSQL
+from sqlalchemy.testing.fixtures import fixture_session
from test.orm import _fixtures
class DynamicTest(_DynamicFixture, _fixtures.FixtureTest, AssertsCompiledSQL):
def test_basic(self):
User, Address = self._user_address_fixture()
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
eq_(
def test_slice_access(self):
User, Address = self._user_address_fixture()
- sess = create_session()
+ sess = fixture_session()
u1 = sess.get(User, 8)
eq_(u1.addresses.limit(1).one(), Address(id=2))
def test_negative_slice_access_raises(self):
User, Address = self._user_address_fixture()
- sess = create_session(testing.db, future=True)
+ sess = fixture_session(future=True)
u1 = sess.get(User, 8)
with expect_raises_message(
would render, without any _clones called."""
User, Address = self._user_address_fixture()
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
u = q.filter(User.id == 7).first()
def test_detached_raise(self):
User, Address = self._user_address_fixture()
- sess = create_session()
+ sess = fixture_session()
u = sess.query(User).get(8)
sess.expunge(u)
def test_order_by(self):
User, Address = self._user_address_fixture()
- sess = create_session()
+ sess = fixture_session()
u = sess.query(User).get(8)
eq_(
list(u.addresses.order_by(desc(Address.email_address))),
addresses_args={"order_by": addresses.c.email_address.desc()}
)
- sess = create_session()
+ sess = fixture_session()
u = sess.query(User).get(8)
eq_(
list(u.addresses),
def test_count(self):
User, Address = self._user_address_fixture()
- sess = create_session()
+ sess = fixture_session()
u = sess.query(User).first()
eq_(u.addresses.count(), 1)
)
mapper(User, users)
- sess = create_session()
+ sess = fixture_session()
ad = sess.query(Address).get(1)
def go():
def test_no_count(self):
User, Address = self._user_address_fixture()
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
# dynamic collection cannot implement __len__() (at least one that
items_args={"backref": backref("orders", lazy="dynamic")}
)
- sess = create_session()
+ sess = fixture_session()
o1 = Order(id=15, description="order 10")
i1 = Item(id=10, description="item 8")
o1.items.append(i1)
)
mapper(Item, items)
- sess = create_session()
+ sess = fixture_session()
o = sess.query(Order).first()
self.assert_compile(
)
mapper(Item, items)
- sess = create_session()
+ sess = fixture_session()
u1 = sess.query(User).first()
self.assert_compile(
properties={"item_keywords": relationship(ItemKeyword)},
)
- sess = create_session()
+ sess = fixture_session()
order = sess.query(Order).first()
self.assert_compile(
addresses = self.tables.addresses
User, Address = self._user_address_fixture()
- sess = create_session()
+ sess = fixture_session()
u1 = User(name="jack")
a1 = Address(email_address="foo")
sess.add_all([u1, a1])
sess.flush()
eq_(
- testing.db.scalar(
+ sess.connection().scalar(
select(func.count(cast(1, Integer))).where(
addresses.c.user_id != None
)
sess.flush()
eq_(
- testing.db.execute(
+ sess.connection()
+ .execute(
select(addresses).where(addresses.c.user_id != None) # noqa
- ).fetchall(),
+ )
+ .fetchall(),
[(a1.id, u1.id, "foo")],
)
u1.addresses.remove(a1)
sess.flush()
eq_(
- testing.db.scalar(
+ sess.connection().scalar(
select(func.count(cast(1, Integer))).where(
addresses.c.user_id != None
)
u1.addresses.append(a1)
sess.flush()
eq_(
- testing.db.execute(
+ sess.connection()
+ .execute(
select(addresses).where(addresses.c.user_id != None) # noqa
- ).fetchall(),
+ )
+ .fetchall(),
[(a1.id, u1.id, "foo")],
)
u1.addresses.append(a2)
sess.flush()
eq_(
- testing.db.execute(
+ sess.connection()
+ .execute(
select(addresses).where(addresses.c.user_id != None) # noqa
- ).fetchall(),
+ )
+ .fetchall(),
[(a2.id, u1.id, "bar")],
)
User, Address = self._user_address_fixture(
addresses_args={"order_by": addresses.c.email_address}
)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
u1 = User(name="jack")
a1 = Address(email_address="a1")
a2 = Address(email_address="a2")
User, Address = self._user_address_fixture(
addresses_args={"order_by": addresses.c.email_address}
)
- sess = create_session(autoflush=True, autocommit=False)
+ sess = fixture_session(autoflush=True, autocommit=False)
u1 = User(name="jack")
a1 = Address(email_address="a1")
a2 = Address(email_address="a2")
# when flushing an append
User, Address = self._user_address_fixture()
- sess = Session()
+ sess = fixture_session()
u1 = User(name="jack", addresses=[Address(email_address="a1")])
sess.add(u1)
sess.commit()
# when flushing a remove
User, Address = self._user_address_fixture()
- sess = Session()
+ sess = fixture_session()
u1 = User(name="jack", addresses=[Address(email_address="a1")])
a2 = Address(email_address="a2")
u1.addresses.append(a2)
def test_rollback(self):
User, Address = self._user_address_fixture()
- sess = create_session(
+ sess = fixture_session(
expire_on_commit=False, autocommit=False, autoflush=True
)
u1 = User(name="jack")
}
)
- sess = create_session(autoflush=True, autocommit=False)
+ sess = fixture_session(autoflush=True, autocommit=False)
u = User(name="ed")
u.addresses.extend(
[Address(email_address=letter) for letter in "abcdef"]
},
)
- sess = Session()
+ sess = fixture_session()
n2, n3 = Node(), Node()
n1 = Node(children=[n2, n3])
sess.add(n1)
}
)
- sess = create_session(autoflush=True, autocommit=False)
+ sess = fixture_session(autoflush=True, autocommit=False)
u = User(name="ed")
u.addresses.extend(
[Address(email_address=letter) for letter in "abcdef"]
User, Address = self._user_address_fixture(
addresses_args={"backref": "user"}
)
- sess = create_session(autoflush=autoflush, autocommit=False)
+ sess = fixture_session(autoflush=autoflush, autocommit=False)
u = User(name="buffy")
addresses_args={"backref": "user"}
)
- session = create_session()
- user = User()
- user.name = "joe"
- user.fullname = "Joe User"
- user.password = "Joe's secret"
- address = Address()
- address.email_address = "joe@joesdomain.example"
- address.user = user
- session.add(user)
- session.flush()
- session.expunge_all()
+ with fixture_session() as session:
+ user = User()
+ user.name = "joe"
+ user.fullname = "Joe User"
+ user.password = "Joe's secret"
+ address = Address()
+ address.email_address = "joe@joesdomain.example"
+ address.user = user
+ session.add(user)
+ session.commit()
def query1():
- session = create_session(testing.db)
+ session = fixture_session()
user = session.query(User).first()
return user.addresses.all()
def query2():
- session = create_session(testing.db)
+ session = fixture_session()
return session.query(User).first().addresses.all()
def query3():
- session = create_session(testing.db)
+ session = fixture_session()
return session.query(User).first().addresses.all()
eq_(query1(), [Address(email_address="joe@joesdomain.example")])
u1 = User(name="u1")
a1 = Address(email_address="a1")
- s = Session(autoflush=autoflush)
+ s = fixture_session(autoflush=autoflush)
s.add(u1)
s.flush()
return u1, a1, s
o1 = Order()
i1 = Item(description="i1")
- s = Session(autoflush=autoflush)
+ s = fixture_session(autoflush=autoflush)
s.add(o1)
s.flush()
return o1, i1, s
from sqlalchemy.orm import close_all_sessions
from sqlalchemy.orm import column_property
from sqlalchemy.orm import contains_eager
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import defaultload
from sqlalchemy.orm import deferred
from sqlalchemy.orm import joinedload
from sqlalchemy.testing import is_
from sqlalchemy.testing import is_not
from sqlalchemy.testing.assertsql import CompiledSQL
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from sqlalchemy.util import OrderedDict as odict
)
},
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
eq_(
)
m = mapper(User, users)
- sess = create_session()
+ sess = fixture_session()
sess.query(User).all()
m.add_property("addresses", relationship(mapper(Address, addresses)))
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
user = sess.query(User).get(7)
assert getattr(User, "addresses").hasparent(
sa.orm.attributes.instance_state(user.addresses[0]),
)
},
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
eq_(
[
User(id=7, addresses=[Address(id=1)]),
)
},
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
eq_(
[
User(id=7, addresses=[Address(id=1)]),
),
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
result = (
q.filter(User.id == Address.user_id)
.order_by(Address.email_address)
)
),
)
- sess = create_session()
+ sess = fixture_session()
eq_(
[
User(id=7, addresses=[Address(id=1)]),
mapper(Address, addresses)
mapper(User, users, properties=dict(addresses=relationship(Address)))
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(User)
.join("addresses")
)
mapper(User, users)
- sess = create_session()
+ sess = fixture_session()
for q in [
sess.query(Address)
5,
),
]:
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
properties={"addresses": relationship(Address, lazy="dynamic")},
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
assert_raises_message(
sa.exc.InvalidRequestError,
"User.addresses' does not support object "
),
)
- q = create_session().query(Item).order_by(Item.id)
+ q = fixture_session().query(Item).order_by(Item.id)
def go():
eq_(self.static.item_keyword_result, q.all())
)
),
)
- q = create_session().query(Item)
+ q = fixture_session().query(Item)
def go():
eq_(
eq_(sa.orm.class_mapper(User).get_property("addresses").lazy, "joined")
eq_(sa.orm.class_mapper(Address).get_property("user").lazy, "joined")
- sess = create_session()
+ sess = fixture_session()
eq_(
self.static.user_address_result,
sess.query(User).order_by(User.id).all(),
User, Address, Order, Item = self.classes(
"User", "Address", "Order", "Item"
)
- q = create_session().query(User).order_by(User.id)
+ q = fixture_session().query(User).order_by(User.id)
def items(*ids):
if no_items:
mapper(Address, addresses)
mapper(Order, orders)
- self.allusers = create_session().query(User).all()
+ self.allusers = fixture_session().query(User).all()
# using a textual select, the columns will be 'id' and 'name'. the
# eager loaders have aliases which should not hit on those columns,
# they should be required to locate only their aliased/fully table
# qualified column name.
noeagers = (
- create_session()
+ fixture_session()
.query(User)
.from_statement(text("select * from users"))
.all()
},
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
result = q.order_by(User.id).limit(2).offset(1).all()
},
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
def go():
},
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
eq_(
[
User(id=7, addresses=[Address(id=1)]),
),
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(Item)
result = (
q.filter(
),
),
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
)
mapper(Order, orders)
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(User).first(),
User(
},
)
- sess = create_session()
+ sess = fixture_session()
u1 = sess.query(User).filter(User.id == 8).one()
def go():
class MyBogusOption(MapperOption):
propagate_to_loaders = True
- sess = create_session()
+ sess = fixture_session()
u1 = (
sess.query(User)
.options(MyBogusOption())
mapper(Address, addresses)
mapper(Item, items)
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User).options(joinedload(User.orders)).limit(10),
)
),
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
def go():
result = q.filter(users.c.id == 7).all()
)
),
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
q = q.filter(users.c.id == 7).limit(1)
self.assert_compile(
user=relationship(mapper(User, users), lazy="joined")
),
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(Address)
def go():
)
),
)
- sess = create_session()
+ sess = fixture_session()
def go():
o1 = (
),
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
result = q.filter(text("users.id in (7, 8, 9)")).order_by(
text("users.id")
},
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
def go():
eq_(
properties={"order": relationship(Order, uselist=False)},
)
mapper(Order, orders)
- s = create_session()
+ s = fixture_session()
assert_raises(
sa.exc.SAWarning, s.query(User).options(joinedload(User.order)).all
)
orders=relationship(Order, lazy=False, order_by=orders.c.id),
),
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
def go():
eq_(self.static.user_all_result, q.order_by(User.id).all())
mapper(User, users)
mapper(Item, items)
- q = create_session().query(Order)
+ q = fixture_session().query(Order)
eq_(
[Order(id=3, user=User(id=7)), Order(id=4, user=User(id=9))],
q.all(),
)
),
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
result = (
q.filter(addresses.c.email_address == "ed@lala.com")
.filter(Address.user_id == User.id)
)
),
)
- sess = create_session()
+ sess = fixture_session()
eq_(
[
User(id=7, addresses=[Address(id=1)]),
)
mapper(Item, items)
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User),
"SELECT users.id AS users_id, users.name AS users_name, "
)
mapper(Item, items)
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User),
"SELECT users.id AS users_id, users.name AS users_name, "
)
mapper(Item, items)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User).options(
joinedload("orders", innerjoin=False).joinedload(
"items", innerjoin=True
mapper(Order, orders)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User).options(
joinedload("orders"), joinedload("addresses", innerjoin="unnested")
)
mapper(Order, orders)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User).options(
joinedload("orders"), joinedload("addresses", innerjoin=True)
)
)
mapper(Keyword, keywords)
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(User)
.join(User.orders)
)
mapper(Item, items)
- sess = create_session()
+ sess = fixture_session()
# joining from user, its all LEFT OUTER JOINs
self.assert_compile(
)
mapper(Item, items)
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User),
),
)
mapper(Item, items)
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User).options(joinedload(User.orders, innerjoin=True)),
"SELECT users.id AS users_id, users.name AS users_name, "
)
mapper(Item, items)
- sess = create_session()
+ sess = fixture_session()
if use_load:
opt = Load(User).defaultload("orders").lazyload("*")
.order_by(Address.id)
)
- s = create_session()
+ s = fixture_session()
result = s.execute(stmt)
eq_(result.scalars().all(), self.static.address_user_result)
User = self.classes.User
stmt = select(User).options(joinedload(User.addresses))
- s = create_session()
+ s = fixture_session()
result = s.execute(stmt)
with expect_raises_message(
stmt = (
select(User).options(joinedload(User.addresses)).order_by(User.id)
)
- s = create_session()
+ s = fixture_session()
result = s.execute(stmt)
eq_(
stmt = (
select(User).options(joinedload(User.addresses)).order_by(User.id)
)
- s = create_session()
+ s = fixture_session()
result = s.execute(stmt)
eq_(result.scalars().unique().all(), self.static.user_address_result)
.options(joinedload(User.addresses))
.order_by(User.id, Address.id)
)
- s = create_session()
+ s = fixture_session()
result = s.execute(stmt)
eq_(
.options(joinedload(User.addresses))
.order_by(User.id)
)
- s = create_session()
+ s = fixture_session()
result = s.execute(stmt)
eq_(
self.classes.C2,
)
- s = Session()
+ s = fixture_session()
q = s.query(A).options(
joinedload(A.bs, innerjoin=False)
# test #3447
A = self.classes.A
- s = Session()
+ s = fixture_session()
q = s.query(A).options(
joinedload("bs"),
def test_multiple_splice_points(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
q = s.query(A).options(
joinedload("bs", innerjoin=False),
a_mapper = inspect(A)
a_mapper.add_property("bs_np", relationship(b_np, viewonly=True))
- s = Session()
+ s = fixture_session()
q = s.query(A).options(joinedload("bs_np", innerjoin=False))
self.assert_compile(
def test_joined_across(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
q = s.query(A).options(
joinedload("b")
.joinedload("c", innerjoin=True)
self._fixture({"summation": column_property(cp.scalar_subquery())})
self.assert_compile(
- create_session()
+ fixture_session()
.query(A)
.options(joinedload("bs"))
.order_by(A.summation)
self._fixture({"summation": column_property(cp.scalar_subquery())})
self.assert_compile(
- create_session()
+ fixture_session()
.query(A)
.options(joinedload("bs"))
.order_by(A.summation.desc())
self._fixture({"summation": column_property(cp.scalar_subquery())})
self.assert_compile(
- create_session()
+ fixture_session()
.query(A)
.options(joinedload("bs"))
.order_by(A.summation)
# the removal of a separate _make_proxy() from ScalarSelect
# fixed that.
self.assert_compile(
- create_session()
+ fixture_session()
.query(A)
.options(joinedload("bs"))
.order_by(cp)
.label("foo")
)
self.assert_compile(
- create_session()
+ fixture_session()
.query(A)
.options(joinedload("bs"))
.order_by(cp)
# TODO: there is no test in Core that asserts what is happening
# here as far as the label generation for the ORDER BY
self.assert_compile(
- create_session()
+ fixture_session()
.query(A)
.options(joinedload("bs"))
.order_by(~cp)
)
mapper(Dingaling, self.tables.dingalings)
- sess = Session(autoflush=False)
+ sess = fixture_session(autoflush=False)
return User, Address, Dingaling, sess
def _collection_to_collection_fixture(self):
)
mapper(Item, self.tables.items)
- sess = Session(autoflush=False)
+ sess = fixture_session(autoflush=False)
return User, Order, Item, sess
def _eager_config_fixture(self):
properties={"addresses": relationship(Address, lazy="joined")},
)
mapper(Address, self.tables.addresses)
- sess = Session(autoflush=False)
+ sess = fixture_session(autoflush=False)
return User, Address, sess
def test_runs_query_on_refresh(self):
)
mapper(Item, items)
- sess = create_session()
+ sess = fixture_session()
oalias = sa.orm.aliased(Order)
def go():
)
mapper(Item, items)
- sess = create_session()
+ sess = fixture_session()
oalias = sa.orm.aliased(Order)
)
mapper(B, b)
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(A).all(),
[
)
},
)
- sess = create_session()
+ sess = fixture_session()
n1 = Node(data="n1")
n1.append(Node(data="n11"))
n1.append(Node(data="n12"))
)
},
)
- sess = create_session()
+ sess = fixture_session()
n1 = Node(data="n1")
n1.append(Node(data="n11"))
n1.append(Node(data="n12"))
"data": deferred(nodes.c.data),
},
)
- sess = create_session()
+ sess = fixture_session()
n1 = Node(data="n1")
n1.append(Node(data="n11"))
n1.append(Node(data="n12"))
)
},
)
- sess = create_session()
+ sess = fixture_session()
n1 = Node(data="n1")
n1.append(Node(data="n11"))
n1.append(Node(data="n12"))
nodes,
properties={"children": relationship(Node, lazy="joined")},
)
- sess = create_session()
+ sess = fixture_session()
n1 = Node(data="n1")
n1.append(Node(data="n11"))
n1.append(Node(data="n12"))
def test_eager_load(self):
A, B = self.classes.A, self.classes.B
- session = create_session()
+ session = fixture_session()
def go():
eq_(
},
)
- sess = create_session()
+ sess = fixture_session()
w1 = Widget(name="w1")
w2 = Widget(name="w2")
w1.children.append(w2)
self.classes.Address,
)
- sess = create_session()
+ sess = fixture_session()
# two FROM clauses
def go():
self.classes.Address,
)
- sess = create_session()
+ sess = fixture_session()
# two FROM clauses where there's a join on each one
def go():
self.classes.Address,
)
- sess = create_session()
+ sess = fixture_session()
oalias = sa.orm.aliased(Order)
self.classes.Address,
)
- sess = create_session()
+ sess = fixture_session()
oalias = sa.orm.aliased(Order)
def test_aliased_entity_three(self):
Order, User = (self.classes.Order, self.classes.User)
- sess = create_session()
+ sess = fixture_session()
oalias = sa.orm.aliased(Order)
},
)
- session = create_session()
+ session = fixture_session()
session.add(
User(
name="joe",
},
)
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
self.assert_sql_count(testing.db, go, 1)
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
self.assert_sql_count(testing.db, go, 2)
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
self.assert_sql_count(testing.db, go, 1)
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
mapper(SubT2, None, inherits=T2, polymorphic_identity="subt2")
# testing a particular endless loop condition in eager load setup
- create_session().query(SubT).all()
+ fixture_session().query(SubT).all()
class CyclicalInheritingEagerTestTwo(
def test_from_subclass(self):
Director = self.classes.Director
- s = create_session()
+ s = fixture_session()
self.assert_compile(
s.query(Director).options(joinedload("*")),
def test_gen_query_nodepth(self):
PersistentObject = self.classes.PersistentObject
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(PersistentObject),
"SELECT persistent.id AS persistent_id, "
def test_gen_query_depth(self):
PersistentObject = self.classes.PersistentObject
Director = self.classes.Director
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(PersistentObject).options(joinedload(Director.other)),
"SELECT persistent.id AS persistent_id, "
def test_joinedload_defered_pk_limit_o2m(self):
Parent = self.classes.Parent
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(Parent)
def test_joinedload_defered_pk_limit_m2m(self):
Parent = self.classes.Parent
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(Parent)
def test_joinedload_defered_pk_o2m(self):
Parent = self.classes.Parent
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(Parent).options(
def test_joinedload_defered_pk_m2m(self):
Parent = self.classes.Parent
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(Parent).options(
def test_multi_path_load(self):
A, B, C, D = self.classes("A", "B", "C", "D")
- s = Session()
+ s = fixture_session()
c = C(d=D())
def test_multi_path_load_of_type(self):
A, B, C, D = self.classes("A", "B", "C", "D")
- s = Session()
+ s = fixture_session()
c = C(d=D())
def test_multi_path_load_legacy_join_style(self):
User, LD, A, LDA = self.classes("User", "LD", "A", "LDA")
- s = Session()
+ s = fixture_session()
u0 = User(data=42)
l0 = LD(user=u0)
def test_multi_path_load_of_type(self):
User, LD, A, LDA = self.classes("User", "LD", "A", "LDA")
- s = Session()
+ s = fixture_session()
u0 = User(data=42)
l0 = LD(user=u0)
def test_string_options_aliased_whatever(self):
A, B, C = self.classes("A", "B", "C")
- s = Session()
+ s = fixture_session()
aa = aliased(A)
q = (
s.query(aa, A)
def test_string_options_unaliased_whatever(self):
A, B, C = self.classes("A", "B", "C")
- s = Session()
+ s = fixture_session()
aa = aliased(A)
q = (
s.query(A, aa)
def test_lazyload_aliased_abs_bcs_one(self):
A, B, C = self.classes("A", "B", "C")
- s = Session()
+ s = fixture_session()
aa = aliased(A)
q = (
s.query(aa, A)
def test_lazyload_aliased_abs_bcs_two(self):
A, B, C = self.classes("A", "B", "C")
- s = Session()
+ s = fixture_session()
aa = aliased(A)
q = (
s.query(aa, A)
def test_pathed_lazyload_aliased_abs_bcs(self):
A, B, C = self.classes("A", "B", "C")
- s = Session()
+ s = fixture_session()
aa = aliased(A)
opt = Load(A).joinedload(A.bs).joinedload(B.cs)
def test_pathed_lazyload_plus_joined_aliased_abs_bcs(self):
A, B, C = self.classes("A", "B", "C")
- s = Session()
+ s = fixture_session()
aa = aliased(A)
opt = Load(aa).defaultload(aa.bs).joinedload(B.cs)
def test_pathed_joinedload_aliased_abs_bcs(self):
A, B, C = self.classes("A", "B", "C")
- s = Session()
+ s = fixture_session()
aa = aliased(A)
opt = Load(aa).joinedload(aa.bs).joinedload(B.cs)
def test_lazyload_plus_joined_aliased_abs_bcs(self):
A, B, C = self.classes("A", "B", "C")
- s = Session()
+ s = fixture_session()
aa = aliased(A)
q = (
s.query(aa, A)
def test_joinedload_aliased_abs_bcs(self):
A, B, C = self.classes("A", "B", "C")
- s = Session()
+ s = fixture_session()
aa = aliased(A)
q = (
s.query(aa, A)
def test_lazyload_unaliased_abs_bcs_one(self):
A, B, C = self.classes("A", "B", "C")
- s = Session()
+ s = fixture_session()
aa = aliased(A)
q = (
s.query(A, aa)
def test_lazyload_unaliased_abs_bcs_two(self):
A, B, C = self.classes("A", "B", "C")
- s = Session()
+ s = fixture_session()
aa = aliased(A)
q = (
s.query(A, aa)
def test_lazyload_plus_joined_unaliased_abs_bcs(self):
A, B, C = self.classes("A", "B", "C")
- s = Session()
+ s = fixture_session()
aa = aliased(A)
q = (
s.query(A, aa)
def test_joinedload_unaliased_abs_bcs(self):
A, B, C = self.classes("A", "B", "C")
- s = Session()
+ s = fixture_session()
aa = aliased(A)
q = (
s.query(A, aa)
def test_multi_path_load_lazy_none(self):
A = self.classes.A
- s = Session()
+ s = fixture_session()
s.add_all(
[
A(id=1, parent_id=None),
def test_deep_options_1(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
# joinedload nothing.
u = sess.query(User).order_by(User.id).all()
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
result = (
sess.query(User)
self.sql_count_(0, go)
- sess = create_session()
+ sess = fixture_session()
result = (
sess.query(User).options(
def test_deep_options_3(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
# same thing, with separate options calls
q2 = (
self.classes.Order,
)
- sess = create_session()
+ sess = fixture_session()
assert_raises_message(
sa.exc.ArgumentError,
self.sql_count_(2, go)
- sess = create_session()
+ sess = fixture_session()
q3 = (
sess.query(User)
.order_by(User.id)
def test_contains_eager(self):
Child1, Related = self.classes.Child1, self.classes.Related
- sess = create_session()
+ sess = fixture_session()
child1s = (
sess.query(Child1)
def test_joinedload_on_other(self):
Child1, Related = self.classes.Child1, self.classes.Related
- sess = create_session()
+ sess = fixture_session()
child1s = (
sess.query(Child1)
self.classes.Related,
)
- sess = create_session()
+ sess = fixture_session()
child1s = (
sess.query(Child1)
from sqlalchemy.orm import exc as orm_exc
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
-from sqlalchemy.orm import Session
from sqlalchemy.testing import assert_raises
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import expect_warnings
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import is_
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
def test_delete_not_expired(self):
Parent, Child = self.classes("Parent", "Child")
- session = Session(expire_on_commit=False)
+ session = fixture_session(expire_on_commit=False)
p = Parent(id=1)
session.add(p)
def test_delete_expired(self):
Parent, Child = self.classes("Parent", "Child")
- session = Session()
+ session = fixture_session()
p = Parent(id=1)
session.add(p)
from sqlalchemy.orm import attributes
from sqlalchemy.orm import class_mapper
from sqlalchemy.orm import configure_mappers
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import deferred
from sqlalchemy.orm import events
from sqlalchemy.orm import EXT_SKIP
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import is_not
from sqlalchemy.testing.assertsql import CompiledSQL
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.mock import ANY
from sqlalchemy.testing.mock import call
from sqlalchemy.testing.mock import Mock
canary = self.listen_all(User)
named_canary = self.listen_all(User, named=True)
- sess = create_session()
+ sess = fixture_session()
u = User(name="u1")
sess.add(u)
sess.flush()
event.listen(mapper, "load", load)
- s = Session()
+ s = fixture_session()
u = User(name="u1")
s.add(u)
s.commit()
- s = Session()
+ s = fixture_session()
u2 = s.merge(u)
- s = Session()
+ s = fixture_session()
u2 = s.merge(User(name="u2")) # noqa
s.commit()
s.query(User).order_by(User.id).first()
canary2 = self.listen_all(User)
canary3 = self.listen_all(AdminUser)
- sess = create_session()
+ sess = fixture_session()
am = AdminUser(name="au1", email_address="au1@e1")
sess.add(am)
sess.flush()
)
canary3 = self.listen_all(AdminUser)
- sess = create_session()
+ sess = fixture_session()
am = AdminUser(name="au1", email_address="au1@e1")
sess.add(am)
sess.flush()
canary1 = self.listen_all(Item)
canary2 = self.listen_all(Keyword)
- sess = create_session()
+ sess = fixture_session()
i1 = Item(description="i1")
k1 = Keyword(name="k1")
sess.add(i1)
event.listen(mapper, "before_configured", m1)
event.listen(mapper, "after_configured", m2)
- s = Session()
+ s = fixture_session()
s.query(User)
eq_(m1.mock_calls, [call()])
# fails by default because Mammal needs to be configured, and cannot
# be:
def probe():
- s = Session()
+ s = fixture_session()
s.query(User)
assert_raises(sa.exc.InvalidRequestError, probe)
@_combinations
def test_warning(self, target, event_name, fn):
A = self.classes.A
- s = Session()
+ s = fixture_session()
target = testing.util.resolve_lambda(target, A=A, session=s)
event.listen(target, event_name, fn)
@_combinations
def test_flag_resolves_existing(self, target, event_name, fn):
A = self.classes.A
- s = Session()
+ s = fixture_session()
target = testing.util.resolve_lambda(target, A=A, session=s)
a1 = s.query(A).all()[0]
@_combinations
def test_flag_resolves(self, target, event_name, fn):
A = self.classes.A
- s = Session()
+ s = fixture_session()
target = testing.util.resolve_lambda(target, A=A, session=s)
event.listen(target, event_name, fn, restore_load_context=True)
canary = self._fixture()
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
sess.add(u1)
canary = self._fixture()
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
sess.add(u1)
canary = self._fixture()
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
sess.add(u1)
def canary2(obj, context, props):
obj.name = "refreshed name!"
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
sess.add(u1)
sess.commit()
canary = self._fixture()
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
sess.add(u1)
canary = self._fixture()
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
sess.add(u1)
canary = self._fixture()
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
sess.add(u1)
canary = self._fixture()
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
sess.add(u1)
canary = self._fixture()
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
sess.add(u1)
canary = self._fixture()
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
sess.add(u1)
event.listen(Session, "before_flush", my_listener)
- s = Session()
+ s = fixture_session()
assert my_listener in s.dispatch.before_flush
def test_sessionmaker_listen(self):
def my_listener_one(*arg, **kw):
pass
- scope = scoped_session(lambda: Session())
+ scope = scoped_session(lambda: fixture_session())
assert_raises_message(
sa.exc.ArgumentError,
class NotASession(object):
def __call__(self):
- return Session()
+ return fixture_session()
scope = scoped_session(NotASession)
return go
- sess = Session(**kw)
+ sess = fixture_session(**kw)
for evt in [
"after_transaction_create",
User, users = self.classes.User, self.tables.users
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
assertions = []
def test_state_before_attach(self):
User, users = self.classes.User, self.tables.users
- sess = Session()
+ sess = fixture_session()
@event.listens_for(sess, "before_attach")
def listener(session, inst):
def test_state_after_attach(self):
User, users = self.classes.User, self.tables.users
- sess = Session()
+ sess = fixture_session()
@event.listens_for(sess, "after_attach")
def listener(session, inst):
def test_on_bulk_update_hook(self):
User, users = self.classes.User, self.tables.users
- sess = Session()
+ sess = fixture_session()
canary = Mock()
event.listen(sess, "after_begin", canary.after_begin)
def test_on_bulk_delete_hook(self):
User, users = self.classes.User, self.tables.users
- sess = Session()
+ sess = fixture_session()
canary = Mock()
event.listen(sess, "after_begin", canary.after_begin)
eq_(upd.result.rowcount, 0)
def test_connection_emits_after_begin(self):
- sess, canary = self._listener_fixture(bind=testing.db)
+ sess, canary = self._listener_fixture()
sess.connection()
# changed due to #5074
eq_(canary, ["after_transaction_create", "after_begin"])
def before_flush(session, flush_context, objects):
session.flush()
- sess = Session()
+ sess = fixture_session()
event.listen(sess, "before_flush", before_flush)
sess.add(User(name="foo"))
assert_raises_message(
)
session.delete(x)
- sess = Session()
+ sess = fixture_session()
event.listen(sess, "before_flush", before_flush)
u = User(name="u1")
for obj in list(session.identity_map.values()):
obj.name += " modified"
- sess = Session(autoflush=True)
+ sess = fixture_session(autoflush=True)
event.listen(sess, "before_flush", before_flush)
u = User(name="u1")
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
listener = Mock()
- sess = Session()
+ sess = fixture_session()
def start_events():
event.listen(
return query
User = self.classes.User
- s = Session()
+ s = fixture_session()
q = s.query(User).filter_by(id=7)
self.assert_compile(
counter[0] += 1
User = self.classes.User
- s = Session()
+ s = fixture_session()
q = s.query(User).filter_by(id=7)
str(q)
def fn(query):
return query.add_columns(User.name)
- s = Session()
+ s = fixture_session()
q = s.query(User.id).filter_by(id=7)
self.assert_compile(
return query
User = self.classes.User
- s = Session()
+ s = fixture_session()
with self.sql_execution_asserter() as asserter:
s.query(User).filter_by(id=7).update({"name": "ed"})
return query
User = self.classes.User
- s = Session()
+ s = fixture_session()
# note this deletes no rows
with self.sql_execution_asserter() as asserter:
):
opts.update(context.execution_options)
- sess = create_session(bind=testing.db, autocommit=False)
+ sess = fixture_session(autocommit=False)
sess.query(User).first()
eq_(opts["my_option"], True)
mock = Mock()
event.listen(Thing, "refresh_flush", mock)
t1 = Thing()
- s = Session()
+ s = fixture_session()
s.add(t1)
s.flush()
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
-from sqlalchemy.testing.fixtures import create_session
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from sqlalchemy.testing.util import gc_collect
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
u = sess.query(User).get(7)
assert len(u.addresses) == 1
u.name = "foo"
mapper(User, users)
mapper(Address, addresses, properties={"user": relationship(User)})
- s = Session()
+ s = fixture_session()
a1 = s.query(Address).get(2)
u1 = s.query(User).get(7)
users, User = self.tables.users, self.classes.User
mapper(User, users)
- s = create_session()
+ s = fixture_session()
u = s.query(User).get(7)
s.expunge_all()
users, User = self.tables.users, self.classes.User
mapper(User, users)
- s = create_session(autocommit=False)
+ s = fixture_session(autocommit=False)
u = s.query(User).get(10)
s.expire_all()
users, User = self.tables.users, self.classes.User
mapper(User, users)
- s = create_session(autocommit=False)
+ s = fixture_session(autocommit=False)
u = s.query(User).get(10)
s.expire_all()
users, User = self.tables.users, self.classes.User
mapper(User, users)
- s = create_session(autocommit=False)
+ s = fixture_session(autocommit=False)
u = s.query(User).get(10)
s.expire_all()
users, User = self.tables.users, self.classes.User
mapper(User, users)
- s = create_session(autocommit=False)
+ s = fixture_session(autocommit=False)
u = s.query(User).get(10)
s.expire_all()
s.execute(users.delete().where(User.id == 10))
properties={"description": deferred(orders.c.description)},
)
- s = create_session()
+ s = fixture_session()
o1 = s.query(Order).first()
assert "description" not in o1.__dict__
s.expire(o1)
users, User = self.tables.users, self.classes.User
mapper(User, users, properties={"name": deferred(users.c.name)})
- s = create_session(autocommit=False)
+ s = fixture_session(autocommit=False)
u = s.query(User).get(10)
assert "name" not in u.__dict__
},
)
mapper(Address, addresses)
- s = create_session(autoflush=True, autocommit=False)
+ s = fixture_session(autoflush=True, autocommit=False)
u = s.query(User).get(8)
adlist = u.addresses
eq_(
},
)
mapper(Address, addresses)
- s = create_session(autoflush=True, autocommit=False)
+ s = fixture_session(autoflush=True, autocommit=False)
u = s.query(User).get(8)
assert_raises_message(
sa_exc.InvalidRequestError,
users, User = self.tables.users, self.classes.User
mapper(User, users)
- s = create_session()
+ s = fixture_session()
u = s.query(User).get(7)
s.expire(u)
s.refresh(u)
mapper(User, users)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
u = sess.query(User).get(7)
sess.expire(u, attribute_names=["name"])
users, User = self.tables.users, self.classes.User
mapper(User, users)
- sess = create_session()
+ sess = fixture_session()
u = sess.query(User).get(7)
sess.expire(u, attribute_names=["name"])
# this was the opposite in 0.4, but the reasoning there seemed off.
# expiring a pending instance makes no sense, so should raise
mapper(User, users)
- sess = create_session()
+ sess = fixture_session()
u = User(id=15)
sess.add(u)
assert_raises(sa_exc.InvalidRequestError, sess.expire, u, ["name"])
# is actually part of a larger behavior when postfetch needs to
# occur during a flush() on an instance that was just inserted
mapper(User, users)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
u = sess.query(User).get(7)
sess.expire(u, attribute_names=["name"])
# same as test_no_instance_key, but the PK columns
# are absent. ensure an error is raised.
mapper(User, users)
- sess = create_session()
+ sess = fixture_session()
u = sess.query(User).get(7)
sess.expire(u, attribute_names=["name", "id"])
Order, orders = self.classes.Order, self.tables.orders
mapper(Order, orders)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
o = sess.query(Order).get(3)
sess.expire(o)
mapper(Order, orders)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
o = sess.query(Order).get(3)
sess.expire(o)
},
)
mapper(Address, addresses)
- s = create_session()
+ s = fixture_session(autoflush=False)
u = s.query(User).get(8)
assert u.addresses[0].email_address == "ed@wood.com"
},
)
mapper(Address, addresses)
- s = create_session()
+ s = fixture_session(autoflush=False)
u = s.query(User).get(8)
assert u.addresses[0].email_address == "ed@wood.com"
properties={"addresses": relationship(Address, cascade=cascade)},
)
mapper(Address, addresses)
- s = create_session()
+ s = fixture_session(autoflush=False)
u = s.query(User).get(8)
a = Address(id=12, email_address="foobar")
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
u = sess.query(User).get(7)
sess.expire(u)
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
u = sess.query(User).get(7)
sess.expire(u)
},
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
u = sess.query(User).get(8)
sess.expire(u, ["name", "addresses"])
u.addresses
},
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
u = sess.query(User).get(8)
sess.expire(u)
u.id
properties={"addresses": relationship(Address, backref="user")},
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
u = sess.query(User).options(joinedload(User.addresses)).get(8)
sess.expire(u)
u.id
},
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
u = sess.query(User).get(8)
sess.expire(u)
mapper(User, users, properties={"uname": sa.orm.synonym("name")})
- sess = create_session()
+ sess = fixture_session()
u = sess.query(User).get(7)
assert "name" in u.__dict__
assert u.uname == u.name
mapper(Order, orders)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
o = sess.query(Order).get(3)
sess.expire(o, attribute_names=["description"])
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
u = sess.query(User).get(8)
sess.expire(u, ["name", "addresses"])
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
u = sess.query(User).get(8)
sess.expire(u, ["name", "addresses"])
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
u = sess.query(User).get(8)
assert "name" in u.__dict__
u.addresses
properties={"description": sa.orm.deferred(orders.c.description)},
)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
o = sess.query(Order).get(3)
sess.expire(o, ["description", "isopen"])
assert "isopen" not in o.__dict__
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
u = sess.query(User).get(8)
assert len(u.addresses) == 3
sess.expire(u)
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
userlist = sess.query(User).order_by(User.id).all()
eq_(self.static.user_address_result, userlist)
eq_(len(list(sess)), 9)
mapper(User, users)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
# deferred attribute option, gets the LoadDeferredColumns
# callable
mapper(User, users, properties={"name": deferred(users.c.name)})
- sess = create_session()
+ sess = fixture_session(autoflush=False)
u1 = sess.query(User).options(undefer(User.name)).first()
assert "name" not in attributes.instance_state(u1).callables
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
u1 = sess.query(User).options(lazyload(User.addresses)).first()
assert isinstance(
attributes.instance_state(u1).callables["addresses"],
properties={"description": deferred(orders.c.description)},
)
- s = Session()
+ s = fixture_session()
item = Order(id=1)
make_transient_to_detached(item)
properties={"description": deferred(orders.c.description)},
)
- s = Session()
+ s = fixture_session()
item = s.query(Order).first()
s.expire(item)
properties={"description": deferred(orders.c.description)},
)
- s = Session()
+ s = fixture_session()
item = s.query(Order).first()
s.expire(item, ["isopen", "description"])
self.classes.Engineer,
)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
[p1, e1, e2] = sess.query(Person).order_by(people.c.person_id).all()
sess.expire(p1)
def test_no_instance_key(self):
Engineer = self.classes.Engineer
- sess = create_session()
+ sess = fixture_session(autoflush=False)
e1 = sess.query(Engineer).get(2)
sess.expire(e1, attribute_names=["name"])
# same as test_no_instance_key, but the PK columns
# are absent. ensure an error is raised.
- sess = create_session()
+ sess = fixture_session(autoflush=False)
e1 = sess.query(Engineer).get(2)
sess.expire(e1, attribute_names=["name", "person_id"])
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
a1 = Address(email_address="a1")
sess.add(a1)
sess.flush()
def test_attr_not_inserted(self):
Data = self.classes.Data
- sess = create_session()
+ sess = fixture_session()
d1 = Data()
sess.add(d1)
def test_attr_not_inserted_expired(self):
Data = self.classes.Data
- sess = create_session()
+ sess = fixture_session(autoflush=False)
d1 = Data()
sess.add(d1)
def test_attr_not_inserted_fetched(self):
Data = self.classes.DataFetched
- sess = create_session()
+ sess = fixture_session()
d1 = Data()
sess.add(d1)
d1 = Data(data="d1")
sess.add(d1)
- sess = create_session()
+ sess = fixture_session()
d1 = sess.query(Data).from_statement(select(Data.id)).first()
# cols not present in the row are implicitly expired
)
},
)
- s = create_session()
+ s = fixture_session(autoflush=False)
u = s.query(User).get(7)
u.name = "foo"
a = Address()
users, User = self.tables.users, self.classes.User
mapper(User, users)
- s = create_session()
+ s = fixture_session()
u = s.query(User).get(7)
s.expunge_all()
assert_raises_message(
mapper(User, users)
mapper(Address, addresses, properties={"user": relationship(User)})
- s = Session()
+ s = fixture_session()
a1 = s.query(Address).get(2)
u1 = s.query(User).get(7)
User, users = self.classes.User, self.tables.users
mapper(User, users)
- s = create_session()
+ s = fixture_session()
u = s.query(User).get(7)
s.expire(u)
assert "name" not in u.__dict__
self.tables.users,
)
- s = create_session()
+ s = fixture_session()
mapper(
User,
users,
},
)
- s = create_session()
+ s = fixture_session()
u = s.query(User).get(8)
assert len(u.addresses) == 3
s.refresh(u)
assert len(u.addresses) == 3
- s = create_session()
+ s = fixture_session()
u = s.query(User).get(8)
assert len(u.addresses) == 3
s.expire(u)
mapper(Dingaling, dingalings)
- s = create_session()
+ s = fixture_session()
q = (
s.query(User)
.filter_by(name="fred")
self.classes.User,
)
- s = create_session()
+ s = fixture_session()
mapper(Address, addresses)
mapper(
from sqlalchemy.orm import column_property
from sqlalchemy.orm import configure_mappers
from sqlalchemy.orm import contains_eager
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import joinedload
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import is_
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from test.orm import _fixtures
)
def test_scalar_subquery_query_auto_correlate(self):
- sess = create_session()
+ sess = fixture_session()
Address, User = self.classes.Address, self.classes.User
query = (
sess.query(func.count(Address.id))
)
def test_scalar_subquery_query_explicit_correlate(self):
- sess = create_session()
+ sess = fixture_session()
Address, User = self.classes.Address, self.classes.User
query = (
sess.query(func.count(Address.id))
@testing.combinations(False, None)
def test_scalar_subquery_query_correlate_off(self, value):
- sess = create_session()
+ sess = fixture_session()
Address, User = self.classes.Address, self.classes.User
query = (
sess.query(func.count(Address.id))
def test_correlate_to_union(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
q = sess.query(User).union(q)
def test_select(self):
addresses, users = self.tables.addresses, self.tables.users
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(users)
User = self.classes.User
subq = select(User).filter(User.id.in_([8, 9])).subquery()
- q = create_session().query(aliased(User, subq))
+ q = fixture_session().query(aliased(User, subq))
eq_(
[User(id=8), User(id=9)],
q.all(),
)
subq = select(User).order_by(User.id).slice(1, 3).subquery()
- q = create_session().query(aliased(User, subq))
+ q = fixture_session().query(aliased(User, subq))
eq_([User(id=8), User(id=9)], q.all())
subq = select(User).filter(User.id.in_([8, 9])).subquery()
u = aliased(User, subq)
- q = create_session().query(u).order_by(u.id)
+ q = fixture_session().query(u).order_by(u.id)
eq_(
[User(id=8)],
list(q[0:1]),
u = aliased(User, stmt)
q = (
- create_session()
+ fixture_session()
.query(u)
.join(u.addresses)
.add_entity(Address)
# there's no reason to do aliased(Address) in this case but we're just
# testing
aq = aliased(Address, subq)
- q = create_session().query(aq.user_id, subq.c.count)
+ q = fixture_session().query(aq.user_id, subq.c.count)
eq_(
q.all(),
[(7, 1), (8, 3), (9, 1)],
aq = aliased(Address, subq)
q = (
- create_session()
+ fixture_session()
.query(aq.user_id, func.count(aq.id))
.group_by(aq.user_id)
.order_by(aq.user_id)
def test_error_w_aliased_against_select(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
stmt = select(User.id)
def test_having(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
stmt = (
select(User.id)
User = self.classes.User
- s = create_session()
+ s = fixture_session()
subq = (
select(User)
User, Address = self.classes.User, self.classes.Address
- s = create_session()
+ s = fixture_session()
ualias = aliased(User)
def test_multiple_entities(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
subq = (
select(User, Address)
)
uq2 = aliased(User, subq2)
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(uq2.id, subq2.c.foo).all(),
def test_multiple_with_column_entities_newstyle(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q1 = sess.query(User.id)
def test_select_entity_from(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
q = sess.query(User).select_entity_from(q.statement.subquery())
def test_select_entity_from_no_entities(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
assert_raises_message(
sa.exc.ArgumentError,
def test_select_from_no_aliasing(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
q = sess.query(User).select_from(q.statement.subquery())
# relies upon _orm_only_from_obj_alias setting
from sqlalchemy.sql import column
- sess = create_session()
+ sess = fixture_session()
c1, c2 = column("c1"), column("c2")
q1 = sess.query(c1, c2).filter(c1 == "dog")
q2 = sess.query(c1, c2).filter(c1 == "cat")
def test_anonymous_labeled_expression_oldstyle(self):
# relies upon _orm_only_from_obj_alias setting
- sess = create_session()
+ sess = fixture_session()
c1, c2 = column("c1"), column("c2")
q1 = sess.query(c1.label("foo"), c2.label("bar")).filter(c1 == "dog")
q2 = sess.query(c1.label("foo"), c2.label("bar")).filter(c1 == "cat")
Address = self.classes.Address
addresses = self.tables.addresses
- sess = create_session()
+ sess = fixture_session()
q1 = sess.query(User.id).filter(User.id > 5)
uq = aliased(User, q1.apply_labels().subquery())
Address = self.classes.Address
addresses = self.tables.addresses
- sess = create_session()
+ sess = fixture_session()
q1 = sess.query(User.id).filter(User.id > 5).apply_labels().subquery()
uq = aliased(User, q1)
def insert_data(cls, connection):
A, C, B = (cls.classes.A, cls.classes.C, cls.classes.B)
- sess = create_session(connection)
+ sess = Session(connection)
sess.add_all(
[
B(name="b1"),
def test_add_entity_equivalence(self):
A, C, B = (self.classes.A, self.classes.C, self.classes.B)
- sess = create_session()
+ sess = fixture_session()
for q in [
sess.query(A, B).join(A.link),
use_labels=True, order_by=[text("ulist.id"), addresses.c.id]
)
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
def go():
use_labels=True, order_by=[text("ulist.id"), addresses.c.id]
)
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
def go():
use_labels=True, order_by=[text("ulist.id"), addresses.c.id]
)
)
- sess = create_session()
+ sess = fixture_session()
# better way. use select_entity_from()
def go():
self.tables.users,
)
- sess = create_session()
+ sess = fixture_session()
# same thing, but alias addresses, so that the adapter
# generated by select_entity_from() is wrapped within
def test_contains_eager_one(self):
addresses, User = (self.tables.addresses, self.classes.User)
- sess = create_session()
+ sess = fixture_session()
# test that contains_eager suppresses the normal outer join rendering
q = (
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
adalias = addresses.alias()
q = (
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
selectquery = users.outerjoin(addresses).select(
users.c.id < 10,
self.classes.User,
)
- sess = create_session(testing.db, future=True)
+ sess = fixture_session(future=True)
selectquery = users.outerjoin(addresses).select(
users.c.id < 10,
def test_contains_eager_aliased(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
# Aliased object
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
oalias = orders.alias("o1")
self.classes.Order,
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
# test using Aliased with more than one level deep
self.classes.Order,
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
# test using Aliased with more than one level deep
self.classes.Address,
)
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(User)
.join(User.addresses)
self.classes.Address,
)
- sess = create_session()
+ sess = fixture_session()
da = aliased(Dingaling, name="foob")
q = (
sess.query(User)
self.classes.Address,
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
def test_alias_naming(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
ua = aliased(User, name="foobar")
q = sess.query(ua)
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
subq = (
select(func.count())
def test_column_queries_one(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(User.name).all(),
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
sel = users.select(User.id.in_([7, 8])).alias()
q = sess.query(User.name)
q2 = q.select_entity_from(sel).all()
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(User.name, Address.email_address)
.filter(User.id == Address.user_id)
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(User.name, func.count(Address.email_address))
.outerjoin(User.addresses)
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(User, func.count(Address.email_address))
.outerjoin(User.addresses)
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(func.count(Address.email_address), User)
.outerjoin(User.addresses)
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
adalias = aliased(Address)
eq_(
sess.query(User, func.count(adalias.email_address))
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
adalias = aliased(Address)
eq_(
sess.query(func.count(adalias.email_address), User)
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
adalias = aliased(Address)
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
# anon + select from aliasing
aa = aliased(Address)
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
adalias = aliased(Address)
def test_column_from_limited_joinedload(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
def go():
results = (
def test_self_referential_from_self(self):
Order = self.classes.Order
- sess = create_session()
+ sess = fixture_session()
oalias = aliased(Order)
q1 = (
self.classes.User,
)
- test_session = create_session()
+ test_session = fixture_session()
(user7, user8, user9, user10) = test_session.query(User).all()
(
(user10, None),
]
- sess = create_session(testing.db, future=True)
+ sess = fixture_session(future=True)
selectquery = users.outerjoin(addresses).select(
use_labels=True, order_by=[users.c.id, addresses.c.id]
self.classes.Address,
)
- sess = create_session()
+ sess = fixture_session()
(user7, user8, user9, user10) = sess.query(User).all()
(address1, address2, address3, address4, address5) = sess.query(
def test_with_entities(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User).filter(User.id == 7).order_by(User.name)
def test_multi_columns(self):
users, User = self.tables.users, self.classes.User
- sess = create_session()
+ sess = fixture_session()
expected = [(u, u.name) for u in sess.query(User).all()]
users, User = self.tables.users, self.classes.User
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(User.id).add_columns(users).all(),
self.tables.users,
)
- sess = create_session()
+ sess = fixture_session()
(user7, user8, user9, user10) = sess.query(User).all()
expected = [(user7, 1), (user8, 3), (user9, 1), (user10, 0)]
User = self.classes.User
users = self.tables.users
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User.id, User.name)
stmt = select(users).order_by(users.c.id)
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
(user7, user8, user9, user10) = sess.query(User).all()
expected = [
(user7, 1, "Name:jack"),
adalias = addresses.alias()
q = (
- create_session()
+ fixture_session()
.query(User)
.add_columns(func.count(adalias.c.id), ("Name:" + users.c.name))
.outerjoin(adalias, "addresses")
.group_by(*[c for c in users.c])
.order_by(users.c.id)
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
result = (
q.add_columns(s.selected_columns.count, s.selected_columns.concat)
.from_statement(s)
# test with select_entity_from()
q = (
- create_session()
+ fixture_session()
.query(User)
.add_columns(func.count(addresses.c.id), ("Name:" + users.c.name))
.select_entity_from(users.outerjoin(addresses))
sess.expunge_all()
q = (
- create_session()
+ fixture_session()
.query(User)
.add_columns(func.count(addresses.c.id), ("Name:" + users.c.name))
.outerjoin("addresses")
sess.expunge_all()
q = (
- create_session()
+ fixture_session()
.query(User)
.add_columns(func.count(adalias.c.id), ("Name:" + users.c.name))
.outerjoin(adalias, "addresses")
ua = aliased(User)
aa = aliased(Address)
- s = create_session()
+ s = fixture_session()
for crit, j, exp in [
(
User.id + Address.id,
def test_aliased_adapt_on_names(self):
User, Address = self.classes.User, self.classes.Address
- sess = Session()
+ sess = fixture_session()
agg_address = sess.query(
Address.id,
func.sum(func.length(Address.email_address)).label(
mapper(Address, addresses)
sel = users.select(users.c.id.in_([7, 8])).alias()
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(User).select_entity_from(sel).all(),
mapper(User, users)
- sess = create_session()
+ sess = fixture_session()
not_users = table("users", column("id"), column("name"))
ua = aliased(User, select(not_users).alias(), adapt_on_names=True)
mapper(User, users)
- sess = create_session()
+ sess = fixture_session()
ua = aliased(User)
mapper(User, users)
- sess = create_session()
+ sess = fixture_session()
ua = users.alias()
mapper(User, users)
- sess = create_session()
+ sess = fixture_session()
sel = sess.query(User).filter(User.id.in_([7, 8])).subquery()
ualias = aliased(User)
ua = aliased(User)
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User).select_from(ua).join(User, ua.name > User.name),
"SELECT users.id AS users_id, users.name AS users_name "
mapper(User, users)
sel = users.select(users.c.id.in_([7, 8]))
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(User).select_entity_from(sel.subquery()).all(),
},
)
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User).select_from(Address).join("user"),
properties={"addresses": relationship(mapper(Address, addresses))},
)
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User)
properties={"addresses": relationship(mapper(Address, addresses))},
)
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User).select_from(Address).join(User),
mapper(Address, addresses)
sel = users.select(users.c.id.in_([7, 8]))
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(User)
) # m2m
mapper(Keyword, keywords)
- sess = create_session()
+ sess = fixture_session()
sel = users.select(users.c.id.in_([7, 8]))
eq_(
) # m2m
mapper(Keyword, keywords)
- sess = create_session()
+ sess = fixture_session()
sel = users.select(users.c.id.in_([7, 8]))
mapper(Address, addresses)
sel = users.select(users.c.id.in_([7, 8]))
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
),
),
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
eq_(
q.join("open_orders", "items", aliased=True)
),
),
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
oo = aliased(Order)
co = aliased(Order)
},
)
- sess = create_session()
+ sess = fixture_session()
sess.query(Address).options(joinedload("user")).all()
Order, orders, properties={"address": relationship(Address)}
) # m2o
- sess = create_session()
+ sess = fixture_session()
def go():
o1 = (
self.assert_sql_count(testing.db, go, 1)
- sess = create_session()
+ sess = fixture_session()
def go():
o1 = (
)
},
)
- sess = create_session()
+ sess = fixture_session()
a1 = sess.query(Address).first()
eq_(a1.username, "jack")
- sess = create_session()
+ sess = fixture_session()
subq = sess.query(Address).subquery()
aa = aliased(Address, subq)
a1 = sess.query(aa).first()
mapper(Sub1, sub1)
mapper(Sub2, sub2)
- sess = create_session()
+ sess = fixture_session()
s11 = Sub1(data="s11")
s12 = Sub1(data="s12")
s.commit()
def test_overlap_plain(self):
- s = Session()
+ s = fixture_session()
row = (
s.query(self.classes.Foo, self.classes.Bar)
.join(self.classes.Bar, true())
self.assert_sql_count(testing.db, go, 0)
def test_overlap_subquery(self):
- s = Session()
+ s = fixture_session()
subq = (
s.query(self.classes.Foo, self.classes.Bar)
from sqlalchemy import func
from sqlalchemy import Integer
from sqlalchemy import testing
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from test.orm import _fixtures
def test_selectby(self):
Foo = self.classes.Foo
- res = create_session().query(Foo).filter_by(range=5)
+ res = fixture_session().query(Foo).filter_by(range=5)
assert res.order_by(Foo.bar)[0].bar == 5
assert res.order_by(sa.desc(Foo.bar))[0].bar == 95
def test_slice(self):
Foo = self.classes.Foo
- sess = create_session()
+ sess = fixture_session()
query = sess.query(Foo).order_by(Foo.id)
orig = query.all()
def test_aggregate(self):
foo, Foo = self.tables.foo, self.classes.Foo
- sess = create_session()
+ sess = fixture_session()
query = sess.query(Foo)
assert query.count() == 100
assert sess.query(func.min(foo.c.bar)).filter(
def test_aggregate_1(self):
foo = self.tables.foo
- query = create_session().query(func.sum(foo.c.bar))
+ query = fixture_session().query(func.sum(foo.c.bar))
assert query.filter(foo.c.bar < 30).one() == (435,)
@testing.fails_on("firebird", "FIXME: unknown")
def test_aggregate_2(self):
foo = self.tables.foo
- query = create_session().query(func.avg(foo.c.bar))
+ query = fixture_session().query(func.avg(foo.c.bar))
avg = query.filter(foo.c.bar < 30).one()[0]
eq_(float(round(avg, 1)), 14.5)
def test_aggregate_3(self):
foo, Foo = self.tables.foo, self.classes.Foo
- query = create_session().query(Foo)
+ query = fixture_session().query(Foo)
avg_f = (
query.filter(foo.c.bar < 30)
def test_filter(self):
Foo = self.classes.Foo
- query = create_session().query(Foo)
+ query = fixture_session().query(Foo)
assert query.count() == 100
assert query.filter(Foo.bar < 30).count() == 30
res2 = query.filter(Foo.bar < 30).filter(Foo.bar > 10)
def test_order_by(self):
Foo = self.classes.Foo
- query = create_session().query(Foo)
+ query = fixture_session().query(Foo)
assert query.order_by(Foo.bar)[0].bar == 0
assert query.order_by(sa.desc(Foo.bar))[0].bar == 99
def test_offset_order_by(self):
Foo = self.classes.Foo
- query = create_session().query(Foo)
+ query = fixture_session().query(Foo)
assert list(query.order_by(Foo.bar).offset(10))[0].bar == 10
def test_offset(self):
Foo = self.classes.Foo
- query = create_session().query(Foo)
+ query = fixture_session().query(Foo)
assert len(list(query.limit(10))) == 10
self.tables.table1,
)
- query = create_session().query(Obj1)
+ query = fixture_session().query(Obj1)
eq_(query.count(), 4)
res = query.filter(
User, Address = self.classes.User, self.classes.Address
- session = create_session()
+ session = fixture_session()
q = (
session.query(User)
.join("orders", "addresses")
self.classes.Address,
)
- session = create_session()
+ session = fixture_session()
q = (
session.query(User)
.outerjoin("orders", "addresses")
self.classes.Address,
)
- session = create_session()
+ session = fixture_session()
q = (
session.query(User)
self.tables.addresses,
)
- session = create_session()
+ session = fixture_session()
sel = users.outerjoin(orders).outerjoin(
addresses, orders.c.address_id == addresses.c.id
self.tables.Table1,
)
- q = create_session(bind=testing.db).query(Obj1)
+ q = fixture_session().query(Obj1)
assert q.count() == 4
res = q.filter(
sa.and_(Table1.c.ID == Table2.c.T1ID, Table2.c.T1ID == 1)
"""test the current state of the hasparent() flag."""
-
from sqlalchemy import ForeignKey
from sqlalchemy import Integer
from sqlalchemy import testing
from sqlalchemy.orm import exc as orm_exc
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
-from sqlalchemy.orm import Session
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from sqlalchemy.testing.util import gc_collect
def _fixture(self):
User, Address = self.classes.User, self.classes.Address
- s = Session()
+ s = fixture_session()
u1 = User()
a1 = Address()
"""basic tests of lazy loaded attributes"""
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import immediateload
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import eq_
+from sqlalchemy.testing.fixtures import fixture_session
from test.orm import _fixtures
mapper(Address, addresses)
mapper(User, users, properties={"addresses": relationship(Address)})
- sess = create_session()
+ sess = fixture_session()
result = (
sess.query(User)
users,
properties={"addresses": relationship(Address, lazy="immediate")},
)
- sess = create_session()
+ sess = fixture_session()
result = sess.query(User).filter(users.c.id == 7).all()
eq_(len(sess.identity_map), 2)
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import eq_
from sqlalchemy.testing import is_
+from sqlalchemy.testing.fixtures import fixture_session
from test.orm import _fixtures
def test_instance_state_scalar_attr_hist(self):
User = self.classes.User
u1 = User(name="ed")
- sess = Session()
+ sess = fixture_session()
sess.add(u1)
sess.commit()
assert "name" not in u1.__dict__
def test_instance_state_scalar_attr_hist_load(self):
User = self.classes.User
u1 = User(name="ed")
- sess = Session()
+ sess = fixture_session()
sess.add(u1)
sess.commit()
assert "name" not in u1.__dict__
insp = inspect(u1)
is_(insp.session, None)
- s = Session()
+ s = fixture_session()
s.add(u1)
is_(insp.session, s)
from sqlalchemy.orm import attributes
from sqlalchemy.orm import class_mapper
from sqlalchemy.orm import clear_mappers
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import instrumentation
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import ne_
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
a = A()
b.a = a
- session = create_session()
+ session = fixture_session()
session.add(b)
assert a in session, "base is %s" % base
b = B()
b.a = a
- session = create_session()
+ session = fixture_session()
session.add(a)
assert b in session, "base: %s" % base
clear_mappers()
from sqlalchemy.engine import default
from sqlalchemy.orm import aliased
from sqlalchemy.orm import backref
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import join
from sqlalchemy.orm import joinedload
from sqlalchemy.orm import mapper
from sqlalchemy.testing import AssertsCompiledSQL
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from test.orm import _fixtures
from .inheritance import _poly_fixtures
def test_single_prop(self):
Company = self.classes.Company
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Company).join(Company.employees),
self.classes.Engineer,
)
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Company)
def test_force_via_select_from(self):
Company, Engineer = self.classes.Company, self.classes.Engineer
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Company)
def test_single_prop_of_type(self):
Company, Engineer = self.classes.Company, self.classes.Engineer
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Company).join(Company.employees.of_type(Engineer)),
def test_explicit_polymorphic_join_one(self):
Company, Engineer = self.classes.Company, self.classes.Engineer
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Company)
def test_explicit_polymorphic_join_two(self):
Company, Engineer = self.classes.Company, self.classes.Engineer
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Company)
.join(Engineer, Company.company_id == Engineer.company_id)
def test_auto_aliasing_multi_link(self):
# test [ticket:2903]
- sess = create_session()
+ sess = fixture_session()
Company, Engineer, Manager, Boss = (
self.classes.Company,
def test_join_on_synonym(self):
User = self.classes.User
self.assert_compile(
- Session().query(User).join(User.ad_syn),
+ fixture_session().query(User).join(User.ad_syn),
"SELECT users.id AS users_id, users.name AS users_name "
"FROM users JOIN addresses ON users.id = addresses.user_id",
)
def test_filter_by_from_full_join(self):
User, Address = self.classes("User", "Address")
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(User)
def test_invalid_kwarg_join(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
assert_raises_message(
TypeError,
"unknown arguments: bar, foob",
User = self.classes.User
Address = self.classes.Address
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User, literal_column("x")).join(Address),
def test_left_is_none_and_query_has_no_entities(self):
Address = self.classes.Address
- sess = create_session()
+ sess = fixture_session()
assert_raises_message(
sa_exc.InvalidRequestError,
User = self.classes.User
self.assert_compile(
- create_session().query(User).join(User.orders, isouter=True),
+ fixture_session().query(User).join(User.orders, isouter=True),
"SELECT users.id AS users_id, users.name AS users_name "
"FROM users LEFT OUTER JOIN orders ON users.id = orders.user_id",
)
User = self.classes.User
self.assert_compile(
- create_session().query(User).outerjoin(User.orders, full=True),
+ fixture_session().query(User).outerjoin(User.orders, full=True),
"SELECT users.id AS users_id, users.name AS users_name "
"FROM users FULL OUTER JOIN orders ON users.id = orders.user_id",
)
def test_single_prop_1(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User).join(User.orders),
"SELECT users.id AS users_id, users.name AS users_name "
def test_single_prop_2(self):
Order, User = (self.classes.Order, self.classes.User)
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User).join(Order.user),
"SELECT users.id AS users_id, users.name AS users_name "
def test_single_prop_3(self):
Order, User = (self.classes.Order, self.classes.User)
- sess = create_session()
+ sess = fixture_session()
oalias1 = aliased(Order)
self.assert_compile(
User,
) = (self.classes.Order, self.classes.User)
- sess = create_session()
+ sess = fixture_session()
oalias1 = aliased(Order)
oalias2 = aliased(Order)
# another nonsensical query. (from [ticket:1537]).
def test_single_prop_6(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
ualias = aliased(User)
self.assert_compile(
sess.query(ualias).join(ualias.orders),
def test_single_prop_9(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
subq = (
sess.query(User)
self.classes.Address,
)
- sess = create_session()
+ sess = fixture_session()
oalias1 = aliased(Order)
# test #1 for [ticket:1706]
ualias = aliased(User)
self.classes.Address,
)
- sess = create_session()
+ sess = fixture_session()
# test #2 for [ticket:1706]
ualias = aliased(User)
ualias2 = aliased(User)
User = self.classes.User
Order = self.classes.Order
- sess = create_session()
+ sess = fixture_session()
# test overlapping paths. User->orders is used by both joins, but
# rendered once.
Order = self.classes.Order
Address = self.classes.Address
- s = Session()
+ s = fixture_session()
q = (
s.query(User)
.join(User.orders)
Order, User = self.classes.Order, self.classes.User
- sess = create_session()
+ sess = fixture_session()
# intentionally join() with a non-existent "left" side
self.assert_compile(
# a more controversial feature. join from
# User->Address, but the onclause is Address.user.
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(User)
def test_multiple_with_aliases(self):
Order, User = self.classes.Order, self.classes.User
- sess = create_session()
+ sess = fixture_session()
ualias = aliased(User)
oalias1 = aliased(Order)
def test_select_from_orm_joins(self):
User, Order = self.classes.User, self.classes.Order
- sess = create_session()
+ sess = fixture_session()
ualias = aliased(User)
oalias1 = aliased(Order)
def test_overlapping_backwards_joins(self):
User, Order = self.classes.User, self.classes.Order
- sess = create_session()
+ sess = fixture_session()
oalias1 = aliased(Order)
oalias2 = aliased(Order)
self.classes.Address,
)
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Address, User)
def test_invalid_join_entity_from_single_from_clause(self):
Address, Item = (self.classes.Address, self.classes.Item)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(Address).select_from(Address)
def test_invalid_join_entity_from_no_from_clause(self):
Address, Item = (self.classes.Address, self.classes.Item)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(Address)
self.classes.Address,
self.classes.Item,
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(Address, User).join(Address.dingaling).join(User.orders)
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
u1 = aliased(User)
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
u1 = aliased(User)
u2 = aliased(User)
self.classes.Dingaling,
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(Address, User).join(Address.dingaling).join(User.orders)
self.classes.Dingaling,
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(Order, Dingaling)
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
a1 = aliased(Address)
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
a1 = aliased(Address)
def test_pure_expression_error(self):
addresses, users = self.tables.addresses, self.tables.users
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(users).join(addresses),
self.classes.Order,
)
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(User)
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(User)
def test_aliased_classes(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
(user7, user8, user9, user10) = sess.query(User).all()
(address1, address2, address3, address4, address5) = sess.query(
def test_expression_onclauses(self):
Order, User = self.classes.Order, self.classes.User
- sess = create_session()
+ sess = fixture_session()
subq = sess.query(User).subquery()
def test_aliased_classes_m2m(self):
Item, Order = self.classes.Item, self.classes.Order
- sess = create_session()
+ sess = fixture_session()
(order1, order2, order3, order4, order5) = sess.query(Order).all()
(item1, item2, item3, item4, item5) = sess.query(Item).all()
# test for #1853
- session = create_session()
+ session = fixture_session()
first = session.query(User)
second = session.query(User)
unioned = first.union(second)
# test for #1853
- session = create_session()
+ session = fixture_session()
first = session.query(User)
second = session.query(User)
unioned = first.union(second)
oalias = orders.alias("oalias")
result = (
- create_session()
+ fixture_session()
.query(User)
.select_from(users.join(oalias))
.filter(
assert [User(id=7, name="jack"), User(id=9, name="fred")] == result
result = (
- create_session()
+ fixture_session()
.query(User)
.select_from(users.join(oalias))
.filter(
def test_aliased_order_by(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
ualias = aliased(User)
eq_(
def test_plain_table(self):
addresses, User = self.tables.addresses, self.classes.User
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(User.name)
def test_no_joinpoint_expr(self):
User, users = self.classes.User, self.tables.users
- sess = create_session()
+ sess = fixture_session()
# these are consistent regardless of
# select_from() being present.
def test_on_clause_no_right_side_one(self):
User = self.classes.User
Address = self.classes.Address
- sess = create_session()
+ sess = fixture_session()
# coercions does not catch this due to the
# legacy=True flag for JoinTargetRole
def test_on_clause_no_right_side_two(self):
User = self.classes.User
Address = self.classes.Address
- sess = create_session()
+ sess = fixture_session()
assert_raises_message(
sa_exc.ArgumentError,
self.classes.User,
)
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Item.id)
.select_from(User)
def test_select_mapped_to_mapped_explicit_left(self):
T1, T2 = self.classes.T1, self.classes.T2
- sess = Session()
+ sess = fixture_session()
subq = (
sess.query(T2.t1_id, func.count(T2.id).label("count"))
.group_by(T2.t1_id)
def test_select_mapped_to_mapped_implicit_left(self):
T1, T2 = self.classes.T1, self.classes.T2
- sess = Session()
+ sess = fixture_session()
subq = (
sess.query(T2.t1_id, func.count(T2.id).label("count"))
.group_by(T2.t1_id)
def test_select_mapped_to_select_explicit_left(self):
T1, T2 = self.classes.T1, self.classes.T2
- sess = Session()
+ sess = fixture_session()
subq = (
sess.query(T2.t1_id, func.count(T2.id).label("count"))
.group_by(T2.t1_id)
def test_select_mapped_to_select_implicit_left(self):
T1, T2 = self.classes.T1, self.classes.T2
- sess = Session()
+ sess = fixture_session()
subq = (
sess.query(T2.t1_id, func.count(T2.id).label("count"))
.group_by(T2.t1_id)
def test_mapped_select_to_mapped_implicit_left(self):
T1, T2 = self.classes.T1, self.classes.T2
- sess = Session()
+ sess = fixture_session()
subq = (
sess.query(T2.t1_id, func.count(T2.id).label("count"))
.group_by(T2.t1_id)
def test_mapped_select_to_mapped_explicit_left(self):
T1, T2 = self.classes.T1, self.classes.T2
- sess = Session()
+ sess = fixture_session()
subq = (
sess.query(T2.t1_id, func.count(T2.id).label("count"))
.group_by(T2.t1_id)
def test_mapped_select_to_select_explicit_left(self):
T1, T2 = self.classes.T1, self.classes.T2
- sess = Session()
+ sess = fixture_session()
subq = (
sess.query(T2.t1_id, func.count(T2.id).label("count"))
.group_by(T2.t1_id)
def test_mapped_select_to_select_implicit_left(self):
T1, T2 = self.classes.T1, self.classes.T2
- sess = Session()
+ sess = fixture_session()
subq = (
sess.query(T2.t1_id, func.count(T2.id).label("count"))
.group_by(T2.t1_id)
def test_o2m_aliased_plus_o2m(self):
Node, Sub = self.classes.Node, self.classes.Sub
- sess = create_session()
+ sess = fixture_session()
n1 = aliased(Node)
self.assert_compile(
def test_m2m_aliased_plus_o2m(self):
Node, Sub = self.classes.Node, self.classes.Sub
- sess = create_session()
+ sess = fixture_session()
n1 = aliased(Node)
self.assert_compile(
def test_double_level_aliased_exists(self):
A, B, C, Base = self._inherits_fixture()
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(A).filter(A.b.has(B.c.has(C.id == 5))),
"SELECT a.id AS a_id, base.id AS base_id, a.b_id AS a_b_id "
def test_join_parent_child(self):
Parent = self.classes.Parent
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Parent)
.join(Parent.npc)
def test_join_parent_child_select_from(self):
Parent = self.classes.Parent
npc = self.npc
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(npc)
.select_from(Parent)
def test_join_select_parent_child(self):
Parent = self.classes.Parent
npc = self.npc
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Parent, npc)
.join(Parent.npc)
def insert_data(cls, connection):
Node = cls.classes.Node
- sess = create_session(connection)
+ sess = Session(connection)
n1 = Node(data="n1")
n1.append(Node(data="n11"))
n1.append(Node(data="n12"))
def test_join_4_explicit_join(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
na = aliased(Node)
na2 = aliased(Node)
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
n1 = aliased(Node)
def test_join_to_self_no_aliases_raises(self):
Node = self.classes.Node
- s = Session()
+ s = fixture_session()
assert_raises_message(
sa.exc.InvalidRequestError,
"Can't construct a join from mapped class Node->nodes to mapped "
def test_explicit_join_4(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
n1 = aliased(Node)
n2 = aliased(Node)
def test_explicit_join_5(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
n1 = aliased(Node)
n2 = aliased(Node)
def test_explicit_join_6(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
n1 = aliased(Node)
node = (
def test_explicit_join_7(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
n1 = aliased(Node)
n2 = aliased(Node)
def test_explicit_join_8(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
n1 = aliased(Node)
n2 = aliased(Node)
def test_explicit_join_9(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
n1 = aliased(Node)
n2 = aliased(Node)
def test_explicit_join_10(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
n1 = aliased(Node)
n2 = aliased(Node)
def test_join_to_nonaliased(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
n1 = aliased(Node)
def test_multiple_explicit_entities_one(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
parent = aliased(Node)
grandparent = aliased(Node)
def test_multiple_explicit_entities_two(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
parent = aliased(Node)
grandparent = aliased(Node)
def test_multiple_explicit_entities_three(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
parent = aliased(Node)
grandparent = aliased(Node)
def test_multiple_explicit_entities_four(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
parent = aliased(Node)
grandparent = aliased(Node)
def test_multiple_explicit_entities_five(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
parent = aliased(Node)
grandparent = aliased(Node)
def test_any(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Node)
.filter(Node.children.any(Node.data == "n1"))
def test_has(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Node)
def test_contains(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
n122 = sess.query(Node).filter(Node.data == "n122").one()
eq_(
def test_eq_ne(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
n12 = sess.query(Node).filter(Node.data == "n12").one()
eq_(
)
},
)
- sess = create_session(connection)
+ sess = Session(connection)
n1 = Node(data="n1")
n2 = Node(data="n2")
n3 = Node(data="n3")
def test_any(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Node)
.filter(Node.children.any(Node.data == "n3"))
def test_contains(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
n4 = sess.query(Node).filter_by(data="n4").one()
eq_(
def test_explicit_join(self):
Node = self.classes.Node
- sess = create_session()
+ sess = fixture_session()
n1 = aliased(Node)
eq_(
def test_select_subquery(self):
Person, Book = self.classes("Person", "Book")
- s = Session()
+ s = fixture_session()
subq = (
s.query(Book.book_id)
def test_select_subquery_sef_implicit_correlate(self):
Person, Book = self.classes("Person", "Book")
- s = Session()
+ s = fixture_session()
stmt = s.query(Person).subquery()
def test_select_subquery_sef_implicit_correlate_coreonly(self):
Person, Book = self.classes("Person", "Book")
- s = Session()
+ s = fixture_session()
stmt = s.query(Person).subquery()
def test_select_subquery_sef_explicit_correlate_coreonly(self):
Person, Book = self.classes("Person", "Book")
- s = Session()
+ s = fixture_session()
stmt = s.query(Person).subquery()
def test_select_subquery_sef_explicit_correlate(self):
Person, Book = self.classes("Person", "Book")
- s = Session()
+ s = fixture_session()
stmt = s.query(Person).subquery()
def test_from_function(self):
Bookcase = self.classes.Bookcase
- s = Session()
+ s = fixture_session()
srf = lateral(func.generate_series(1, Bookcase.bookcase_shelves))
def test_from_function_select_entity_from(self):
Bookcase = self.classes.Bookcase
- s = Session()
+ s = fixture_session()
subq = s.query(Bookcase).subquery()
from sqlalchemy.testing import AssertsCompiledSQL
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from .inheritance import _poly_fixtures
def test_user_cols_single_lambda_query(self, plain_fixture):
User, Address = plain_fixture
- s = Session()
+ s = fixture_session()
q = s.query(lambda: (User.id, User.name)).select_from(lambda: User)
self.assert_compile(
from sqlalchemy.orm import aliased
from sqlalchemy.orm import attributes
from sqlalchemy.orm import configure_mappers
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import exc as orm_exc
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import is_false
from sqlalchemy.testing import is_true
from sqlalchemy.testing.assertsql import CompiledSQL
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from sqlalchemy.types import TypeDecorator
)
},
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
eq_(
[
)
},
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
u = q.filter(users.c.id == 7).first()
sess.expunge(u)
)
},
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
assert [
User(id=7, addresses=[Address(id=1)]),
User(
users,
properties=dict(addresses=relationship(Address, lazy="select")),
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
result = (
q.filter(users.c.id == addresses.c.user_id)
.order_by(addresses.c.email_address)
)
),
)
- sess = create_session()
+ sess = fixture_session()
assert [
User(id=7, addresses=[Address(id=1)]),
User(
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
user = sess.query(User).get(7)
assert getattr(User, "addresses").hasparent(
attributes.instance_state(user.addresses[0]), optimistic=True
},
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
if testing.against("mssql"):
},
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
# use a union all to get a lot of rows to join against
properties={"order": relationship(Order, uselist=False)},
)
mapper(Order, orders)
- s = create_session()
+ s = fixture_session()
u1 = s.query(User).filter(User.id == 7).one()
assert_raises(sa.exc.SAWarning, getattr, u1, "order")
),
)
- s = Session()
+ s = fixture_session()
ed = s.query(User).filter_by(name="ed").one()
eq_(
ed.addresses,
)
),
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
result = q.filter(users.c.id == 7).all()
assert [User(id=7, address=Address(id=1))] == result
)
),
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
eq_(
[
User(id=7, address=None),
User, Address, Order, Item = self.classes(
"User", "Address", "Order", "Item"
)
- q = create_session().query(User).order_by(User.id)
+ q = fixture_session().query(User).order_by(User.id)
def items(*ids):
if no_items:
else:
self.assert_sql_count(testing.db, go, 15)
- sess = create_session()
+ sess = fixture_session()
user = sess.query(User).get(7)
closed_mapper = User.closed_orders.entity
open_mapper = User.open_orders.entity
eq_(
[Order(id=1), Order(id=5)],
- create_session()
+ fixture_session()
.query(closed_mapper)
.with_parent(user, property="closed_orders")
.all(),
)
eq_(
[Order(id=3)],
- create_session()
+ fixture_session()
.query(open_mapper)
.with_parent(user, property="open_orders")
.all(),
),
)
- q = create_session().query(Item)
+ q = fixture_session().query(Item)
assert self.static.item_keyword_result == q.all()
eq_(
),
)
- sess = create_session()
+ sess = fixture_session()
# load address
a1 = (
properties=dict(user=relationship(mapper(User, users))),
)
- sess = create_session(bind=testing.db)
+ sess = fixture_session()
# load address
a1 = (
user=relationship(mapper(User, users), lazy="select")
),
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(Address)
a = q.filter(addresses.c.id == 1).one()
properties={"addresses": relationship(Address, backref="user")},
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
ad = sess.query(Address).filter_by(id=1).one()
assert ad.user.id == 7
},
)
- sess = create_session()
+ sess = fixture_session()
a1 = Address(email_address="a1")
sess.add(a1)
if populate_user:
mapper(Address, addresses, properties={"user": relationship(User)})
- sess = create_session()
+ sess = fixture_session()
ad1 = Address(email_address="somenewaddress", id=12)
sess.add(ad1)
sess.flush()
},
)
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(User).all(),
def test_lazy_doesnt_interfere(self):
A, B, C = self.classes("A", "B", "C")
- session = Session()
+ session = fixture_session()
b = B()
session.add(b)
session.flush()
Person = self.classes.Person
Pet = self.classes.Pet
- s = Session()
+ s = fixture_session()
s.add_all([Person(id=5), Pet(id=1, person_id=5)])
s.commit()
from sqlalchemy.orm import loading
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
-from sqlalchemy.orm import Session
from sqlalchemy.testing import mock
from sqlalchemy.testing.assertions import assert_raises
from sqlalchemy.testing.assertions import assert_raises_message
from sqlalchemy.testing.assertions import eq_
+from sqlalchemy.testing.fixtures import fixture_session
from . import _fixtures
# class GetFromIdentityTest(_fixtures.FixtureTest):
)
mapper(Address, addresses)
- s = Session()
+ s = fixture_session()
def go():
eq_(
def test_cursor_close_w_failed_rowproc(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
q = s.query(User)
def test_row_proc_not_created(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
q = s.query(User.id, User.name)
stmt = select(User.id)
def _fixture(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
u1, u2, u3, u4 = (
User(id=1, name="u1"),
User(id=2, name="u2"),
def test_single_column(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
q = s.query(User.id)
collection = [(1,), (2,), (7,), (8,)]
from sqlalchemy.orm import joinedload
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
-from sqlalchemy.orm import Session
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import AssertsCompiledSQL
from sqlalchemy.testing import eq_
+from sqlalchemy.testing.fixtures import fixture_session
from test.orm import _fixtures
assert_sel_of=None,
):
User = self.classes.User
- s = Session()
+ s = fixture_session()
q = s.query(User).with_for_update(
read=read, nowait=nowait, of=of, key_share=key_share
)
def test_inner_joinedload_w_limit(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
q = (
sess.query(User)
.options(joinedload(User.addresses, innerjoin=True))
def test_inner_joinedload_wo_limit(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
sess.query(User).options(
joinedload(User.addresses, innerjoin=True)
).with_for_update().all()
def test_outer_joinedload_w_limit(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
q = sess.query(User).options(
joinedload(User.addresses, innerjoin=False)
)
def test_outer_joinedload_wo_limit(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
q = sess.query(User).options(
joinedload(User.addresses, innerjoin=False)
)
def test_join_w_subquery(self):
User = self.classes.User
Address = self.classes.Address
- sess = Session()
+ sess = fixture_session()
q1 = sess.query(User).with_for_update().subquery()
sess.query(q1).join(Address).all()
sess.close()
def test_plain(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
sess.query(User).with_for_update().all()
sess.close()
def test_default_update(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User.id).with_for_update(),
"SELECT users.id AS users_id FROM users FOR UPDATE",
def test_not_supported_by_dialect_should_just_use_update(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User.id).with_for_update(read=True),
"SELECT users.id AS users_id FROM users FOR UPDATE",
def test_postgres_read(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User.id).with_for_update(read=True),
"SELECT users.id AS users_id FROM users FOR SHARE",
def test_postgres_read_nowait(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User.id).with_for_update(read=True, nowait=True),
"SELECT users.id AS users_id FROM users FOR SHARE NOWAIT",
def test_postgres_update(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User.id).with_for_update(),
"SELECT users.id AS users_id FROM users FOR UPDATE",
def test_postgres_update_of(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User.id).with_for_update(of=User.id),
"SELECT users.id AS users_id FROM users FOR UPDATE OF users",
def test_postgres_update_of_entity(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User.id).with_for_update(of=User),
"SELECT users.id AS users_id FROM users FOR UPDATE OF users",
User = self.classes.User
Address = self.classes.Address
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User.id, Address.id).with_for_update(
of=[User, Address]
def test_postgres_for_no_key_update(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User.id).with_for_update(key_share=True),
"SELECT users.id AS users_id FROM users FOR NO KEY UPDATE",
def test_postgres_for_no_key_nowait_update(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User.id).with_for_update(key_share=True, nowait=True),
"SELECT users.id AS users_id FROM users FOR NO KEY UPDATE NOWAIT",
def test_postgres_update_of_list(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User.id).with_for_update(
of=[User.id, User.id, User.id]
def test_postgres_update_skip_locked(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User.id).with_for_update(skip_locked=True),
"SELECT users.id AS users_id FROM users FOR UPDATE SKIP LOCKED",
def test_oracle_update(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User.id).with_for_update(),
"SELECT users.id AS users_id FROM users FOR UPDATE",
def test_oracle_update_skip_locked(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User.id).with_for_update(skip_locked=True),
"SELECT users.id AS users_id FROM users FOR UPDATE SKIP LOCKED",
def test_mysql_read(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User.id).with_for_update(read=True),
"SELECT users.id AS users_id FROM users LOCK IN SHARE MODE",
def test_for_update_on_inner_w_joinedload(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User)
.options(joinedload(User.addresses))
def test_for_update_on_inner_w_joinedload_no_render_oracle(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User)
.options(joinedload(User.addresses))
from sqlalchemy.orm import exc as orm_exc
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
-from sqlalchemy.orm import Session
-from sqlalchemy.orm import sessionmaker
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
},
)
- sess = Session()
+ sess = fixture_session()
p1 = Place("place1")
p2 = Place("place2")
p3 = Place("place3")
},
)
- sess = Session()
+ sess = fixture_session()
p1 = Place("place1")
p2 = Place("place2")
p2.parent_places = [p1]
tran.inputs.append(Place("place1"))
tran.outputs.append(Place("place2"))
tran.outputs.append(Place("place3"))
- sess = Session()
+ sess = fixture_session()
sess.add(tran)
sess.commit()
p2 = Place("place2")
p3 = Place("place3")
- sess = Session()
+ sess = fixture_session()
sess.add_all([p3, p1, t1, t2, p2, t3])
t1.inputs.append(p1)
p1 = Place("place1")
t1 = Transition("t1")
p1.transitions.append(t1)
- sess = sessionmaker()()
+ sess = fixture_session()
sess.add_all([p1, t1])
sess.commit()
A, B = self.classes.A, self.classes.B
secondary = self.tables.secondary
- sess = Session()
+ sess = fixture_session()
sess.add_all(
[A(data="a1", bs=[B(data="b1")]), A(data="a2", bs=[B(data="b2")])]
)
A, B = self.classes.A, self.classes.B
secondary = self.tables.secondary
- sess = Session()
+ sess = fixture_session()
sess.add_all([A(data="a1", bs=[B(data="b1"), B(data="b2")])])
sess.commit()
from sqlalchemy.orm import column_property
from sqlalchemy.orm import composite
from sqlalchemy.orm import configure_mappers
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import deferred
from sqlalchemy.orm import dynamic_loader
from sqlalchemy.orm import mapper
from sqlalchemy.testing import is_
from sqlalchemy.testing import ne_
from sqlalchemy.testing.fixtures import ComparableMixin
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from test.orm import _fixtures
properties={"user_name": synonym("_name")},
)
- s = create_session()
+ s = fixture_session()
u = s.query(User).get(7)
eq_(u._name, "jack")
eq_(u._id, 7)
User, users = self.classes.User, self.tables.users
m = self.mapper(User, users)
- session = create_session()
+ session = fixture_session()
session.connection(mapper=m)
def test_incomplete_columns(self):
addresses, Address = self.tables.addresses, self.classes.Address
self.mapper(Address, addresses)
- s = create_session()
+ s = fixture_session()
a = (
s.query(Address)
.from_statement(
m.add_property("name", synonym("_name"))
m.add_property("addresses", relationship(Address))
- sess = create_session(autocommit=False)
+ sess = fixture_session(autocommit=False)
assert sess.query(User).get(7)
u = sess.query(User).filter_by(name="jack").one()
m.add_property("_name", users.c.name)
m.add_property("name", synonym("_name"))
- sess = create_session()
+ sess = fixture_session()
u = sess.query(User).filter_by(name="jack").one()
eq_(u._name, "jack")
eq_(u.name, "jack")
# add property using annotated User.name,
# needs to be deannotated
m.add_property("x", column_property(User.name + "name"))
- s = create_session()
+ s = fixture_session()
q = s.query(m2).select_from(Address).join(Address.foo)
self.assert_compile(
q,
properties={"addresses": relationship(Address, backref="_user")},
)
- sess = create_session()
+ sess = fixture_session()
u1 = sess.query(User).get(7)
u2 = sess.query(User).get(8)
# comparaison ops need to work
primary_key=[users.c.id],
properties={"add_id": addresses.c.id},
)
- result = create_session().query(User).order_by(users.c.id).all()
+ result = fixture_session().query(User).order_by(users.c.id).all()
eq_(result, self.static.user_result[:3])
def test_mapping_to_join_exclude_prop(self):
primary_key=[users.c.id],
exclude_properties=[addresses.c.id],
)
- result = create_session().query(User).order_by(users.c.id).all()
+ result = fixture_session().query(User).order_by(users.c.id).all()
eq_(result, self.static.user_result[:3])
def test_mapping_to_join_no_pk(self):
assert addresses in m._pks_by_table
assert email_bounces not in m._pks_by_table
- sess = create_session()
+ sess = fixture_session()
a = Address(id=10, email_address="e1")
sess.add(a)
sess.flush()
- eq_(select(func.count("*")).select_from(addresses).scalar(), 6)
- eq_(select(func.count("*")).select_from(email_bounces).scalar(), 5)
+ eq_(
+ sess.connection().scalar(
+ select(func.count("*")).select_from(addresses)
+ ),
+ 6,
+ )
+ eq_(
+ sess.connection().scalar(
+ select(func.count("*")).select_from(email_bounces)
+ ),
+ 5,
+ )
def test_mapping_to_outerjoin(self):
"""Mapping to an outer join with a nullable composite primary key."""
properties=dict(address_id=addresses.c.id),
)
- session = create_session()
+ session = fixture_session()
result = session.query(User).order_by(User.id, User.address_id).all()
eq_(
properties=dict(address_id=addresses.c.id),
)
- session = create_session()
+ session = fixture_session()
result = session.query(User).order_by(User.id, User.address_id).all()
eq_(
self.mapper(User, users, properties=dict(orders=relationship(Order)))
- session = create_session()
+ session = fixture_session()
result = (
session.query(User)
.select_from(users.join(orders).join(order_items).join(items))
)
self.mapper(User, s)
- sess = create_session()
+ sess = fixture_session()
result = sess.query(User).order_by(s.c.id).all()
for idx, total in enumerate((14, 16)):
self.mapper(User, users)
- session = create_session()
+ session = fixture_session()
q = session.query(User)
eq_(q.count(), 4)
),
)
- session = create_session()
+ session = fixture_session()
q = (
session.query(Item)
.join("keywords")
assert User.uname.property
assert User.adlist.property
- sess = create_session()
+ sess = fixture_session()
# test RowTuple names
row = sess.query(User.id, User.uname).first()
User, users, properties={"x": synonym("id"), "y": synonym("x")}
)
- s = Session()
+ s = fixture_session()
u = s.query(User).filter(User.y == 8).one()
eq_(u.y, 8)
assert hasattr(User, "name")
assert hasattr(User, "_name")
- sess = create_session()
+ sess = fixture_session()
u = sess.query(User).filter(User.name == "jack").one()
eq_(u.name, "jack")
u.name = "foo"
User()
eq_(recon, [])
- create_session().query(User).first()
+ fixture_session().query(User).first()
eq_(recon, ["go"])
def test_reconstructor_inheritance(self):
C()
eq_(recon, [])
- sess = create_session()
+ sess = fixture_session()
sess.query(A).first()
sess.query(B).first()
sess.query(C).first()
eq_(recon, ["go"])
recon[:] = []
- create_session().query(User).first()
+ fixture_session().query(User).first()
eq_(recon, ["go"])
def test_reconstructor_init_inheritance(self):
eq_(recon, ["A", "B", "C"])
recon[:] = []
- sess = create_session()
+ sess = fixture_session()
sess.query(A).first()
sess.query(B).first()
sess.query(C).first()
User()
eq_(recon, [])
- create_session().query(User).first()
+ fixture_session().query(User).first()
eq_(recon, ["go"])
def test_unmapped_error(self):
# using it with an ORM operation, raises
assert_raises(
- sa.orm.exc.UnmappedClassError, create_session().add, Sub()
+ sa.orm.exc.UnmappedClassError, fixture_session().add, Sub()
)
def test_unmapped_subclass_error_premap(self):
# using it with an ORM operation, raises
assert_raises(
- sa.orm.exc.UnmappedClassError, create_session().add, Sub()
+ sa.orm.exc.UnmappedClassError, fixture_session().add, Sub()
)
def test_oldstyle_mixin(self):
self.mapper(H3, ht3)
self.mapper(H6, ht6)
- s = create_session()
+ s = fixture_session()
s.add_all([H1("abc"), H1("def")])
h1 = H1("ghi")
s.add(h1)
h1.h1s.append(H1())
s.flush()
- eq_(select(func.count("*")).select_from(ht1).scalar(), 4)
+ eq_(s.connection().scalar(select(func.count("*")).select_from(ht1)), 4)
h6 = H6()
h6.h1a = h1
H1, ht1, properties={"h2s": relationship(H2, backref="h1")}
)
self.mapper(H2, ht2)
- s = Session()
+ s = fixture_session()
s.add_all(
[
H1(
)
Map(state="AK", mapper=c)
- sess = create_session()
+ sess = fixture_session()
sess.add(c)
sess.flush()
sess.expunge_all()
User, users = self.classes.User, self.tables.users
tb = users.select().alias()
self.mapper(User, tb)
- s = Session()
+ s = fixture_session()
s.add(User(name="ed"))
s.commit()
from sqlalchemy.orm import attributes
from sqlalchemy.orm import backref
from sqlalchemy.orm import configure_mappers
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import defer
from sqlalchemy.orm import deferred
from sqlalchemy.orm import foreign
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
-from sqlalchemy.orm import sessionmaker
from sqlalchemy.orm import synonym
from sqlalchemy.orm.collections import attribute_mapped_collection
from sqlalchemy.orm.interfaces import MapperOption
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import in_
from sqlalchemy.testing import not_in
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from sqlalchemy.util import OrderedSet
User, users = self.classes.User, self.tables.users
mapper(User, users)
- sess = create_session()
+ sess = fixture_session()
load = self.load_tracker(User)
u = User(id=7, name="fred")
User, users = self.classes.User, self.tables.users
mapper(User, users)
- sess = create_session()
+ sess = fixture_session()
u = User(name="fred")
def go():
User, users = self.classes.User, self.tables.users
mapper(User, users)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
u = User(name="fred")
sess.add(u)
User, users = self.classes.User, self.tables.users
mapper(User, users)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
u = User(id=1, name="fred")
sess.add(u)
)
eq_(load.called, 0)
- sess = create_session()
+ sess = fixture_session()
sess.merge(u)
eq_(load.called, 3)
)
mapper(Address, addresses)
- s = Session()
+ s = fixture_session()
u = User(
id=7,
name="fred",
)
eq_(load.called, 0)
- sess = create_session()
+ sess = fixture_session()
sess.merge(u)
eq_(load.called, 3)
mapper(User, users)
load = self.load_tracker(User)
- sess = create_session()
+ sess = fixture_session()
u = User(id=7, name="fred")
sess.add(u)
sess.flush()
]
),
)
- sess = create_session()
+ sess = fixture_session()
sess.add(u)
sess.flush()
sess.expunge_all()
name="fred",
addresses=OrderedSet([a, Address(id=2, email_address="fred2")]),
)
- sess = create_session()
+ sess = fixture_session()
sess.add(u)
sess.flush()
sess.expunge_all()
)
load = self.load_tracker(User)
self.load_tracker(Address, load)
- sess = create_session()
+ sess = fixture_session()
u = User(id=7, name="fred")
a1 = Address(email_address="foo@bar.com")
mapper(User, dingalings)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
# merge empty stuff. goes in as NULL.
# not sure what this was originally trying to
)
u1 = User(id=7, name="fred")
u1.addresses["foo@bar.com"] = Address(email_address="foo@bar.com")
- sess = create_session()
+ sess = fixture_session()
sess.merge(u1)
sess.flush()
assert list(u1.addresses.keys()) == ["foo@bar.com"]
load = self.load_tracker(User)
self.load_tracker(Address, load)
- sess = create_session()
+ with fixture_session(expire_on_commit=False) as sess, sess.begin():
- # set up data and save
- u = User(
- id=7,
- name="fred",
- addresses=[
- Address(email_address="foo@bar.com"),
- Address(email_address="hoho@la.com"),
- ],
- )
- sess.add(u)
- sess.flush()
+ # set up data and save
+ u = User(
+ id=7,
+ name="fred",
+ addresses=[
+ Address(email_address="foo@bar.com"),
+ Address(email_address="hoho@la.com"),
+ ],
+ )
+ sess.add(u)
# assert data was saved
- sess2 = create_session()
+ sess2 = fixture_session()
u2 = sess2.query(User).get(7)
eq_(
u2,
eq_(load.called, 3)
# new session, merge modified data into session
- sess3 = create_session()
- u3 = sess3.merge(u)
- eq_(load.called, 6)
+ with fixture_session(expire_on_commit=False) as sess3:
+ u3 = sess3.merge(u)
+ eq_(load.called, 6)
- # ensure local changes are pending
- eq_(
- u3,
- User(
- id=7,
- name="fred2",
- addresses=[
- Address(email_address="foo@bar.com"),
- Address(email_address="hoho@lalala.com"),
- ],
- ),
- )
+ # ensure local changes are pending
+ eq_(
+ u3,
+ User(
+ id=7,
+ name="fred2",
+ addresses=[
+ Address(email_address="foo@bar.com"),
+ Address(email_address="hoho@lalala.com"),
+ ],
+ ),
+ )
- # save merged data
- sess3.flush()
+ # save merged data
+ sess3.commit()
# assert modified/merged data was saved
- sess.expunge_all()
- u = sess.query(User).get(7)
- eq_(
- u,
- User(
- id=7,
- name="fred2",
- addresses=[
- Address(email_address="foo@bar.com"),
- Address(email_address="hoho@lalala.com"),
- ],
- ),
- )
- eq_(load.called, 9)
+ with fixture_session() as sess:
+ u = sess.query(User).get(7)
+ eq_(
+ u,
+ User(
+ id=7,
+ name="fred2",
+ addresses=[
+ Address(email_address="foo@bar.com"),
+ Address(email_address="hoho@lalala.com"),
+ ],
+ ),
+ )
+ eq_(load.called, 9)
# merge persistent object into another session
- sess4 = create_session()
- u = sess4.merge(u)
- assert len(u.addresses)
- for a in u.addresses:
- assert a.user is u
+ with fixture_session(expire_on_commit=False) as sess4:
+ u = sess4.merge(u)
+ assert len(u.addresses)
+ for a in u.addresses:
+ assert a.user is u
- def go():
- sess4.flush()
+ def go():
+ sess4.flush()
- # no changes; therefore flush should do nothing
- self.assert_sql_count(testing.db, go, 0)
- eq_(load.called, 12)
+ # no changes; therefore flush should do nothing
+ self.assert_sql_count(testing.db, go, 0)
- # test with "dontload" merge
- sess5 = create_session()
- u = sess5.merge(u, load=False)
- assert len(u.addresses)
- for a in u.addresses:
- assert a.user is u
+ sess4.commit()
- def go():
- sess5.flush()
+ eq_(load.called, 12)
- # no changes; therefore flush should do nothing
- # but also, load=False wipes out any difference in committed state,
- # so no flush at all
- self.assert_sql_count(testing.db, go, 0)
+ # test with "dontload" merge
+ with fixture_session(expire_on_commit=False) as sess5:
+ u = sess5.merge(u, load=False)
+ assert len(u.addresses)
+ for a in u.addresses:
+ assert a.user is u
+
+ def go():
+ sess5.flush()
+
+ # no changes; therefore flush should do nothing
+ # but also, load=False wipes out any difference in committed state,
+ # so no flush at all
+ self.assert_sql_count(testing.db, go, 0)
eq_(load.called, 15)
- sess4 = create_session()
- u = sess4.merge(u, load=False)
- # post merge change
- u.addresses[1].email_address = "afafds"
+ with fixture_session(expire_on_commit=False) as sess4, sess4.begin():
+ u = sess4.merge(u, load=False)
+ # post merge change
+ u.addresses[1].email_address = "afafds"
- def go():
- sess4.flush()
+ def go():
+ sess4.flush()
- # afafds change flushes
- self.assert_sql_count(testing.db, go, 1)
+ # afafds change flushes
+ self.assert_sql_count(testing.db, go, 1)
eq_(load.called, 18)
- sess5 = create_session()
- u2 = sess5.query(User).get(u.id)
- eq_(u2.name, "fred2")
- eq_(u2.addresses[1].email_address, "afafds")
+ with fixture_session(expire_on_commit=False) as sess5:
+ u2 = sess5.query(User).get(u.id)
+ eq_(u2.name, "fred2")
+ eq_(u2.addresses[1].email_address, "afafds")
eq_(load.called, 21)
def test_dont_send_neverset_to_get(self):
mapper(CompositePk, composite_pk_table)
cp1 = CompositePk(j=1, k=1)
- sess = Session()
+ sess = fixture_session()
rec = []
u1 = User(id=5, name="some user")
cp1 = CompositePk(j=1, k=1)
u1.elements.append(cp1)
- sess = Session()
+ sess = fixture_session()
rec = []
properties={"user": relationship(User, cascade="save-update")},
)
mapper(User, users)
- sess = create_session()
+ sess = fixture_session()
u1 = User(name="fred")
a1 = Address(email_address="asdf", user=u1)
sess.add(a1)
load = self.load_tracker(User)
self.load_tracker(Address, load)
- sess = create_session()
+ sess = fixture_session(expire_on_commit=False)
u = User(name="fred")
a1 = Address(email_address="foo@bar")
a2 = Address(email_address="foo@quux")
u.addresses.extend([a1, a2])
sess.add(u)
- sess.flush()
+ sess.commit()
eq_(load.called, 0)
- sess2 = create_session()
+ sess2 = fixture_session()
u2 = sess2.query(User).get(u.id)
eq_(load.called, 1)
eq_(u2.addresses[1].email_address, "addr 2 modified")
eq_(load.called, 3)
- sess3 = create_session()
+ sess3 = fixture_session()
u3 = sess3.query(User).get(u.id)
eq_(load.called, 4)
a1 = Address(id=1, email_address="a1", user=u1)
u2 = User(id=2, name="u2")
- sess = create_session()
+ sess = fixture_session(expire_on_commit=False)
sess.add_all([a1, u2])
- sess.flush()
+ sess.commit()
a1.user = u2
- sess2 = create_session()
- a2 = sess2.merge(a1)
- eq_(attributes.get_history(a2, "user"), ([u2], (), ()))
- assert a2 in sess2.dirty
+ with fixture_session(expire_on_commit=False) as sess2:
+ a2 = sess2.merge(a1)
+ eq_(attributes.get_history(a2, "user"), ([u2], (), ()))
+ assert a2 in sess2.dirty
sess.refresh(a1)
- sess2 = create_session()
- a2 = sess2.merge(a1, load=False)
- eq_(attributes.get_history(a2, "user"), ((), [u1], ()))
- assert a2 not in sess2.dirty
+ with fixture_session(expire_on_commit=False) as sess2:
+ a2 = sess2.merge(a1, load=False)
+ eq_(attributes.get_history(a2, "user"), ((), [u1], ()))
+ assert a2 not in sess2.dirty
def test_many_to_many_cascade(self):
items, Order, orders, order_items, Item = (
load = self.load_tracker(Order)
self.load_tracker(Item, load)
- sess = create_session()
+ with fixture_session(expire_on_commit=False) as sess:
- i1 = Item()
- i1.description = "item 1"
+ i1 = Item()
+ i1.description = "item 1"
- i2 = Item()
- i2.description = "item 2"
+ i2 = Item()
+ i2.description = "item 2"
- o = Order()
- o.description = "order description"
- o.items.append(i1)
- o.items.append(i2)
+ o = Order()
+ o.description = "order description"
+ o.items.append(i1)
+ o.items.append(i2)
- sess.add(o)
- sess.flush()
+ sess.add(o)
+ sess.commit()
eq_(load.called, 0)
- sess2 = create_session()
- o2 = sess2.query(Order).get(o.id)
- eq_(load.called, 1)
+ with fixture_session(expire_on_commit=False) as sess2:
+ o2 = sess2.query(Order).get(o.id)
+ eq_(load.called, 1)
- o.items[1].description = "item 2 modified"
- sess2.merge(o)
- eq_(o2.items[1].description, "item 2 modified")
- eq_(load.called, 3)
+ o.items[1].description = "item 2 modified"
+ sess2.merge(o)
+ eq_(o2.items[1].description, "item 2 modified")
+ eq_(load.called, 3)
- sess3 = create_session()
- o3 = sess3.query(Order).get(o.id)
- eq_(load.called, 4)
+ with fixture_session(expire_on_commit=False) as sess3:
+ o3 = sess3.query(Order).get(o.id)
+ eq_(load.called, 4)
- o.description = "desc modified"
- sess3.merge(o)
- eq_(load.called, 6)
- eq_(o3.description, "desc modified")
+ o.description = "desc modified"
+ sess3.merge(o)
+ eq_(load.called, 6)
+ eq_(o3.description, "desc modified")
def test_one_to_one_cascade(self):
users, Address, addresses, User = (
)
load = self.load_tracker(User)
self.load_tracker(Address, load)
- sess = create_session()
+ sess = fixture_session(expire_on_commit=False)
u = User()
u.id = 7
u.address = a1
sess.add(u)
- sess.flush()
+ sess.commit()
eq_(load.called, 0)
- sess2 = create_session()
+ sess2 = fixture_session()
u2 = sess2.query(User).get(7)
eq_(load.called, 1)
u2.name = "fred2"
)
},
)
- sess = sessionmaker()()
+ sess = fixture_session()
u = User(
id=7,
name="fred",
mapper(User, users)
- sess = create_session()
+ sess = fixture_session()
u = User()
assert_raises_message(
sa.exc.InvalidRequestError,
Address(email_address="ad2"),
],
)
- sess = create_session()
+ sess = fixture_session()
sess.add(u)
sess.flush()
sess.close()
assert "user" in u.addresses[1].__dict__
- sess = create_session()
+ sess = fixture_session()
u2 = sess.merge(u, load=False)
assert "user" in u2.addresses[1].__dict__
eq_(u2.addresses[1].user, User(id=7, name="fred"))
assert "user" not in u2.addresses[1].__dict__
sess.close()
- sess = create_session()
+ sess = fixture_session()
u = sess.merge(u2, load=False)
assert "user" not in u.addresses[1].__dict__
eq_(u.addresses[1].user, User(id=7, name="fred"))
users,
properties={"addresses": relationship(mapper(Address, addresses))},
)
- sess = create_session()
- u = User()
- u.id = 7
- u.name = "fred"
- a1 = Address()
- a1.email_address = "foo@bar.com"
- u.addresses.append(a1)
+ with fixture_session(expire_on_commit=False) as sess:
+ u = User()
+ u.id = 7
+ u.name = "fred"
+ a1 = Address()
+ a1.email_address = "foo@bar.com"
+ u.addresses.append(a1)
- sess.add(u)
- sess.flush()
+ sess.add(u)
+ sess.commit()
- sess2 = create_session()
+ sess2 = fixture_session()
u2 = sess2.query(User).options(sa.orm.joinedload("addresses")).get(7)
- sess3 = create_session()
+ sess3 = fixture_session()
u3 = sess3.merge(u2, load=False) # noqa
def go():
users, User = self.tables.users, self.classes.User
mapper(User, users)
- sess = create_session()
- u = User()
- u.id = 7
- u.name = "fred"
- sess.add(u)
- sess.flush()
+ with fixture_session(expire_on_commit=False) as sess:
+ u = User()
+ u.id = 7
+ u.name = "fred"
+ sess.add(u)
+ sess.commit()
u.name = "ed"
- sess2 = create_session()
+ sess2 = fixture_session()
try:
sess2.merge(u, load=False)
assert False
u2 = sess2.query(User).get(7)
- sess3 = create_session()
+ sess3 = fixture_session()
u3 = sess3.merge(u2, load=False) # noqa
assert not sess3.dirty
},
)
- sess = create_session()
+ sess = fixture_session()
u = User()
u.id = 7
u.name = "fred"
assert u.addresses[0].user is u
- sess2 = create_session()
+ sess2 = fixture_session()
u2 = sess2.merge(u, load=False)
assert not sess2.dirty
)
},
)
- sess = create_session()
- u = User()
- u.id = 7
- u.name = "fred"
- a1 = Address()
- a1.email_address = "foo@bar.com"
- u.addresses.append(a1)
- sess.add(u)
- sess.flush()
+ with fixture_session(expire_on_commit=False) as sess:
+ u = User()
+ u.id = 7
+ u.name = "fred"
+ a1 = Address()
+ a1.email_address = "foo@bar.com"
+ u.addresses.append(a1)
+ sess.add(u)
+ sess.commit()
assert u.addresses[0].user is u
- sess2 = create_session()
- u2 = sess2.merge(u, load=False)
- assert not sess2.dirty
- a2 = u2.addresses[0]
- a2.email_address = "somenewaddress"
- assert not sa.orm.object_mapper(a2)._is_orphan(
- sa.orm.attributes.instance_state(a2)
- )
- sess2.flush()
- sess2.expunge_all()
+ with fixture_session(expire_on_commit=False) as sess2:
+ u2 = sess2.merge(u, load=False)
+ assert not sess2.dirty
+ a2 = u2.addresses[0]
+ a2.email_address = "somenewaddress"
+ assert not sa.orm.object_mapper(a2)._is_orphan(
+ sa.orm.attributes.instance_state(a2)
+ )
+ sess2.commit()
- eq_(
- sess2.query(User).get(u2.id).addresses[0].email_address,
- "somenewaddress",
- )
+ with fixture_session() as sess2:
+ eq_(
+ sess2.query(User).get(u2.id).addresses[0].email_address,
+ "somenewaddress",
+ )
# this use case is not supported; this is with a pending Address
# on the pre-merged object, and we currently don't support
# instances. so if we start supporting 'dirty' with load=False,
# this test will need to pass
- sess = create_session()
+ sess2 = fixture_session()
+ sess = fixture_session()
u = sess.query(User).get(7)
u.addresses.append(Address())
- sess2 = create_session()
+ sess2 = fixture_session()
try:
u2 = sess2.merge(u, load=False)
assert False
mapper(User, users, properties={"uid": synonym("id")})
- sess = create_session()
+ sess = fixture_session()
u = User()
u.name = "ed"
sess.add(u)
self.tables.users,
)
- s = create_session(autoflush=True, autocommit=False)
+ s = fixture_session(autoflush=True, autocommit=False)
mapper(
User,
users,
self.tables.users,
)
- sess = create_session(autoflush=True, autocommit=False)
+ sess = fixture_session(autoflush=True, autocommit=False)
mapper(
User,
users,
u = User(
id=7, name="fred", addresses=[Address(id=1, email_address="fred1")]
)
- sess = create_session(autoflush=True, autocommit=False)
+ sess = fixture_session(autoflush=True, autocommit=False)
sess.add(u)
sess.commit()
mapper(User, users)
u = User(id=7)
- sess = create_session(autoflush=True, autocommit=False)
+ sess = fixture_session(autoflush=True, autocommit=False)
u = sess.merge(u)
assert not bool(attributes.instance_state(u).expired_attributes)
opt1, opt2 = Option(), Option()
- sess = sessionmaker()()
+ sess = fixture_session()
umapper = mapper(User, users)
sess.add_all([User(id=1, name="u1"), User(id=2, name="u2")])
sess.commit()
- sess2 = sessionmaker()()
+ sess2 = fixture_session()
s2_users = sess2.query(User).options(opt2).all()
# test 1. no options are replaced by merge options
- sess = sessionmaker()()
+ sess = fixture_session()
s1_users = sess.query(User).all()
for u in s1_users:
eq_(ustate.load_options, set([opt2]))
# test 2. present options are replaced by merge options
- sess = sessionmaker()()
+ sess = fixture_session()
s1_users = sess.query(User).options(opt1).all()
for u in s1_users:
ustate = attributes.instance_state(u)
Order(description="o3", address=Address(email_address="c")),
]
- sess = Session()
+ sess = fixture_session()
sess.merge(u1)
sess.flush()
Order(description="o3", address=Address(id=1, email_address="c")),
]
- sess = Session()
+ sess = fixture_session()
sess.merge(u1)
sess.flush()
mapper(Order, orders, properties={"address": relationship(Address)})
mapper(Address, addresses)
- sess = Session()
+ sess = fixture_session()
sess.add(Address(id=1, email_address="z"))
sess.commit()
Order(description="o3", address=Address(id=1, email_address="c")),
]
- sess = Session()
+ sess = fixture_session()
sess.merge(u1)
sess.flush()
# address.user_id is 1, you get a load.
def test_persistent_access_none(self):
User, Address = self.classes.User, self.classes.Address
- s = Session()
+ s = fixture_session()
def go():
u1 = User(id=1, addresses=[Address(id=1), Address(id=2)])
def test_persistent_access_one(self):
User, Address = self.classes.User, self.classes.Address
- s = Session()
+ s = fixture_session()
def go():
u1 = User(id=1, addresses=[Address(id=1), Address(id=2)])
def test_persistent_access_two(self):
User, Address = self.classes.User, self.classes.Address
- s = Session()
+ s = fixture_session()
def go():
u1 = User(id=1, addresses=[Address(id=1), Address(id=2)])
# persistent.
def test_pending_access_one(self):
User, Address = self.classes.User, self.classes.Address
- s = Session()
+ s = fixture_session()
def go():
u1 = User(
def test_pending_access_two(self):
User, Address = self.classes.User, self.classes.Address
- s = Session()
+ s = fixture_session()
def go():
u1 = User(
# defer 'excerpt' at mapping level instead of query level
Book, book = self.classes.Book, self.tables.book
mapper(Book, book, properties={"excerpt": deferred(book.c.excerpt)})
- sess = sessionmaker()()
+ sess = fixture_session()
b = Book(
id=1,
def test_deferred_column_query(self):
Book, book = self.classes.Book, self.tables.book
mapper(Book, book)
- sess = sessionmaker()()
+ sess = fixture_session()
b = Book(
id=1,
Data, data = self.classes.Data, self.tables.data
mapper(Data, data)
- sess = sessionmaker()()
+ sess = fixture_session()
d = Data(data=["this", "is", "a", "list"])
sess.add(d)
Data, data = self.classes.Data, self.tables.data
mapper(Data, data)
- sess = sessionmaker()()
+ sess = fixture_session()
d1 = Data(pk1="someval", pk2=None)
Data, data = self.classes.Data, self.tables.data
mapper(Data, data, allow_partial_pks=False)
- sess = sessionmaker()()
+ sess = fixture_session()
d1 = Data(pk1="someval", pk2=None)
},
)
mapper(self.classes.Bug, self.tables.bugs)
- self.sess = sessionmaker()()
+ self.sess = fixture_session()
def _merge_delete_orphan_o2o_with(self, bug):
# create a transient rock with passed bug
inherits=employee_mapper,
polymorphic_identity="engineer",
)
- self.sess = sessionmaker()()
+ self.sess = fixture_session()
def test_merge_polymorphic_on(self):
"""merge() should succeed with a polymorphic object even when
from sqlalchemy import TypeDecorator
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
-from sqlalchemy.orm import Session
from sqlalchemy.orm.session import make_transient
from sqlalchemy.testing import assert_raises
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import expect_warnings
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import ne_
-from sqlalchemy.testing.fixtures import create_session
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from test.orm import _fixtures
mapper(User, users)
- sess = create_session()
+ sess = fixture_session()
u1 = User(username="jack", fullname="jack")
sess.add(u1)
mapper(User, users)
- sess = create_session()
+ sess = fixture_session()
u1 = User(username="jack", fullname="jack")
sess.add(u1)
mapper(User, users)
- sess = create_session()
+ sess = fixture_session()
u1 = User(username="jack", fullname="jack")
sess.add(u1)
mapper(User, users)
- sess = create_session()
+ sess = fixture_session()
u1 = User(username="jack", fullname="jack")
sess.add(u1)
User, users = self.classes.User, self.tables.users
mapper(User, users)
- sess = create_session()
+ sess = fixture_session()
u1 = User(username="jack", fullname="jack")
sess.add(u1)
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
u1 = User(username="jack", fullname="jack")
u1.addresses.append(Address(email="jack1"))
u1.addresses.append(Address(email="jack2"))
properties={"user": relationship(User, passive_updates=False)},
)
- sess = create_session()
+ sess = fixture_session()
u1 = sess.query(User).first()
a1, a2 = sess.query(Address).all()
u1.username = "ed"
},
)
- sess = create_session()
+ sess = fixture_session()
a1 = Address(email="jack1")
a2 = Address(email="jack2")
a3 = Address(email="fred")
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
u1 = User(username="jack", fullname="jack")
sess.add(u1)
sess.flush()
},
)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
a1 = Address(email="jack1")
a2 = Address(email="jack2")
)
mapper(Item, items)
- sess = create_session()
+ sess = fixture_session()
u1 = User(username="jack")
u2 = User(username="fred")
i1 = Item(itemname="item1")
},
)
- s = Session()
+ s = fixture_session()
a1 = Address(email="jack1")
u1 = User(username="jack", fullname="jack")
mapper(User, users)
mapper(Address, addresses, properties={"user": relationship(User)})
- sess = create_session()
+ sess = fixture_session()
u1 = User(id=5, name="u1")
ad1 = Address(email_address="e1", user=u1)
sess.add_all([u1, ad1])
mapper(User, user)
- session = sa.orm.sessionmaker()()
+ session = fixture_session()
a_published = User(1, PUBLISHED, "a")
session.add(a_published)
mapper(User, user)
- session = sa.orm.sessionmaker()()
+ session = fixture_session()
a_published = User(1, PUBLISHED, "a")
session.add(a_published)
},
)
- sess = Session()
+ sess = fixture_session()
n1 = Node(name="n1")
sess.add(n1)
n2 = Node(name="n11", parentnode=n1)
},
)
- sess = Session()
+ sess = fixture_session()
n1 = Node(name="n1")
n1.children.append(Node(name="n11"))
n1.children.append(Node(name="n12"))
},
)
- sess = Session()
+ sess = fixture_session()
n1 = Node(name="n1")
n11 = Node(name="n11", parentnode=n1)
n12 = Node(name="n12", parentnode=n1)
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
u1 = User(username="jack", fullname="jack")
u1.addresses.append(Address(email="jack1"))
u1.addresses.append(Address(email="jack2"))
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
a1 = Address(username="ed", email="ed@host1")
u1 = User(username="ed", addresses=[a1])
u2 = User(username="jack")
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
a1 = Address(username="ed", email="ed@host1")
u1 = User(username="ed", addresses=[a1])
u2 = User(username="jack")
},
)
- sess = create_session()
+ sess = fixture_session()
u1 = User(username="jack")
if uselist:
a1 = Address(user=[u1], email="foo@bar")
},
)
- sess = create_session()
+ sess = fixture_session()
u1 = User(username="jack")
u2 = User(username="ed")
a1 = Address(user=u1, email="foo@bar")
properties={"user": relationship(User, passive_updates=True)},
)
- sess = create_session()
+ sess = fixture_session()
u1 = User(username="ed")
a1 = Address(user=u1, email="ed@host1")
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
a1, a2 = (
Address(username="ed", email="ed@host1"),
Address(username="ed", email="ed@host2"),
def _test_pk(self, passive_updates):
(Engineer,) = self.classes("Engineer")
self._mapping_fixture(False, passive_updates)
- sess = sa.orm.sessionmaker()()
+ sess = fixture_session()
e1 = Engineer(name="dilbert", primary_language="java")
sess.add(e1)
self._mapping_fixture(False, passive_updates)
- sess = sa.orm.sessionmaker()()
+ sess = fixture_session()
m1 = Manager(name="dogbert", paperwork="lots")
e1, e2 = (
self._mapping_fixture(True, passive_updates)
- sess = sa.orm.sessionmaker()()
+ sess = fixture_session()
o1 = Owner(name="dogbert", owner_name="dog")
sess.add(o1)
Owner, Engineer = self.classes("Owner", "Engineer")
self._mapping_fixture(True, passive_updates)
- sess = sa.orm.sessionmaker()()
+ sess = fixture_session()
m1 = Owner(name="dogbert", paperwork="lots", owner_name="dog")
e1, e2 = (
def test_updates_sorted(self):
Data = self.classes.Data
- s = Session()
+ s = fixture_session()
s.add_all(
[
polymorphic_identity="engineer",
)
- sess = sa.orm.sessionmaker()()
+ sess = fixture_session()
e1 = Engineer(name="dilbert", primary_language="java")
sess.add(e1)
from sqlalchemy.testing import fixtures
from sqlalchemy.testing.assertsql import CompiledSQL
from sqlalchemy.testing.entities import ComparableEntity
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from .inheritance._poly_fixtures import _PolymorphicAliasedJoins
from .inheritance._poly_fixtures import _PolymorphicJoins
__dialect__ = "default"
def test_any_one(self):
- sess = Session()
+ sess = fixture_session()
any_ = Company.employees.of_type(Engineer).any(
Engineer.primary_language == "cobol"
)
eq_(sess.query(Company).filter(any_).one(), self.c2)
def test_any_two(self):
- sess = Session()
+ sess = fixture_session()
calias = aliased(Company)
any_ = calias.employees.of_type(Engineer).any(
Engineer.primary_language == "cobol"
eq_(sess.query(calias).filter(any_).one(), self.c2)
def test_any_three(self):
- sess = Session()
+ sess = fixture_session()
any_ = Company.employees.of_type(Boss).any(Boss.golf_swing == "fore")
eq_(sess.query(Company).filter(any_).one(), self.c1)
def test_any_four(self):
- sess = Session()
+ sess = fixture_session()
any_ = Company.employees.of_type(Manager).any(
Manager.manager_name == "pointy"
)
eq_(sess.query(Company).filter(any_).one(), self.c1)
def test_any_five(self):
- sess = Session()
+ sess = fixture_session()
any_ = Company.employees.of_type(Engineer).any(
and_(Engineer.primary_language == "cobol")
)
eq_(sess.query(Company).filter(any_).one(), self.c2)
def test_join_to_subclass_one(self):
- sess = Session()
+ sess = fixture_session()
eq_(
sess.query(Company)
.join(Company.employees.of_type(Engineer))
)
def test_join_to_subclass_two(self):
- sess = Session()
+ sess = fixture_session()
eq_(
sess.query(Company)
.join(Company.employees.of_type(Engineer), "machines")
)
def test_join_to_subclass_three(self):
- sess = Session()
+ sess = fixture_session()
eq_(
sess.query(Company, Engineer)
.join(Company.employees.of_type(Engineer))
)
def test_join_to_subclass_four(self):
- sess = Session()
+ sess = fixture_session()
# test [ticket:2093]
eq_(
sess.query(Company.company_id, Engineer)
)
def test_join_to_subclass_five(self):
- sess = Session()
+ sess = fixture_session()
eq_(
sess.query(Company)
.join(Company.employees.of_type(Engineer))
)
def test_with_polymorphic_join_compile_one(self):
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Company).join(
)
def test_with_polymorphic_join_exec_contains_eager_one(self):
- sess = Session()
+ sess = fixture_session()
def go():
wp = with_polymorphic(
def test_with_polymorphic_join_exec_contains_eager_two(
self, contains_eager_option
):
- sess = Session()
+ sess = fixture_session()
wp = with_polymorphic(Person, [Engineer, Manager], aliased=True)
contains_eager_option = testing.resolve_lambda(
)
def test_with_polymorphic_any(self):
- sess = Session()
+ sess = fixture_session()
wp = with_polymorphic(Person, [Engineer], aliased=True)
eq_(
sess.query(Company.company_id)
)
def test_subqueryload_implicit_withpoly(self):
- sess = Session()
+ sess = fixture_session()
def go():
eq_(
self.assert_sql_count(testing.db, go, 4)
def test_joinedload_implicit_withpoly(self):
- sess = Session()
+ sess = fixture_session()
def go():
eq_(
self.assert_sql_count(testing.db, go, 3)
def test_subqueryload_explicit_withpoly(self):
- sess = Session()
+ sess = fixture_session()
def go():
target = with_polymorphic(Person, Engineer)
self.assert_sql_count(testing.db, go, 4)
def test_joinedload_explicit_withpoly(self):
- sess = Session()
+ sess = fixture_session()
def go():
target = with_polymorphic(Person, Engineer, flat=True)
self.assert_sql_count(testing.db, go, 3)
def test_joinedload_stacked_of_type(self):
- sess = Session()
+ sess = fixture_session()
def go():
eq_(
)
def test_joinedload_explicit_with_unaliased_poly_compile(self):
- sess = Session()
+ sess = fixture_session()
target = with_polymorphic(Person, Engineer)
q = (
sess.query(Company)
)
def test_joinedload_explicit_with_flataliased_poly_compile(self):
- sess = Session()
+ sess = fixture_session()
target = with_polymorphic(Person, Engineer, flat=True)
q = (
sess.query(Company)
Job_P = with_polymorphic(Job, SubJob, aliased=True, flat=True)
- s = Session()
+ s = fixture_session()
q = (
s.query(Job)
.join(DataContainer.jobs)
Job_A = aliased(Job)
- s = Session()
+ s = fixture_session()
q = (
s.query(Job)
.join(DataContainer.jobs)
Job_P = with_polymorphic(Job, SubJob)
- s = Session()
+ s = fixture_session()
q = s.query(DataContainer).join(DataContainer.jobs.of_type(Job_P))
self.assert_compile(
q,
self.classes.SubJob,
)
- s = Session()
+ s = fixture_session()
q = s.query(DataContainer).join(DataContainer.jobs.of_type(SubJob))
# note the of_type() here renders JOIN for the Job->SubJob.
# this is because it's using the SubJob mapper directly within
Job_P = with_polymorphic(Job, SubJob, innerjoin=True)
- s = Session()
+ s = fixture_session()
q = s.query(DataContainer).join(DataContainer.jobs.of_type(Job_P))
self.assert_compile(
q,
Job_A = aliased(Job)
- s = Session()
+ s = fixture_session()
q = s.query(DataContainer).join(DataContainer.jobs.of_type(Job_A))
self.assert_compile(
q,
Job_P = with_polymorphic(Job, SubJob)
- s = Session()
+ s = fixture_session()
q = s.query(DataContainer).join(Job_P, DataContainer.jobs)
self.assert_compile(
q,
Job_P = with_polymorphic(Job, SubJob, flat=True)
- s = Session()
+ s = fixture_session()
q = s.query(DataContainer).join(Job_P, DataContainer.jobs)
self.assert_compile(
q,
Job_P = with_polymorphic(Job, SubJob, aliased=True)
- s = Session()
+ s = fixture_session()
q = s.query(DataContainer).join(Job_P, DataContainer.jobs)
self.assert_compile(
q,
B1 = aliased(B1, name="bbb")
C1 = aliased(C1, name="ccc")
- sess = Session()
+ sess = fixture_session()
abc = sess.query(A1)
if join_of_type:
from sqlalchemy import ForeignKey
from sqlalchemy import Integer
from sqlalchemy import String
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
),
)
- session = create_session()
+ session = fixture_session()
j = Jack(number="101")
session.add(j)
from sqlalchemy.orm import attributes
from sqlalchemy.orm import class_mapper
from sqlalchemy.orm import column_property
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import defaultload
from sqlalchemy.orm import defer
from sqlalchemy.orm import exc as orm_exc
from sqlalchemy.orm import load_only
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
-from sqlalchemy.orm import Session
from sqlalchemy.orm import strategy_options
from sqlalchemy.orm import subqueryload
from sqlalchemy.orm import synonym
from sqlalchemy.testing import fixtures
from sqlalchemy.testing.assertions import assert_raises_message
from sqlalchemy.testing.assertions import eq_
+from sqlalchemy.testing.fixtures import fixture_session
from test.orm import _fixtures
from .inheritance._poly_fixtures import _Polymorphic
from .inheritance._poly_fixtures import Company
def test_gen_path_attr_str_not_mapped(self):
OrderWProp = self.classes.OrderWProp
- sess = Session()
+ sess = fixture_session()
q = sess.query(OrderWProp).options(defer("some_attr"))
assert_raises_message(
SubAddr.sub_attr
)
- sess = Session()
+ sess = fixture_session()
q = sess.query(User)
self._assert_path_result(
l1,
.defer(SubAddr.sub_attr)
)
- sess = Session()
+ sess = fixture_session()
q = sess.query(User)
self._assert_path_result(
l1,
l1 = defaultload(User.addresses.of_type(SubAddr)).defer("sub_attr")
- sess = Session()
+ sess = fixture_session()
q = sess.query(User)
self._assert_path_result(
l1,
.defer("sub_attr")
)
- sess = Session()
+ sess = fixture_session()
q = sess.query(User)
self._assert_path_result(
l1,
SubAddr.dings
)
- sess = Session()
+ sess = fixture_session()
q = sess.query(User)
self._assert_path_result(
l1, q, [(User, "addresses"), (User, "addresses", SubAddr, "dings")]
.joinedload(SubAddr.dings)
)
- sess = Session()
+ sess = fixture_session()
q = sess.query(User)
self._assert_path_result(
l1, q, [(User, "addresses"), (User, "addresses", SubAddr, "dings")]
l1 = defaultload(User.addresses.of_type(SubAddr)).joinedload("dings")
- sess = Session()
+ sess = fixture_session()
q = sess.query(User)
self._assert_path_result(
l1, q, [(User, "addresses"), (User, "addresses", SubAddr, "dings")]
.defer("sub_attr")
)
- sess = Session()
+ sess = fixture_session()
q = sess.query(User)
self._assert_path_result(
l1,
def test_get_path_one_level_string(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
q = sess.query(User)
opt = self._option_fixture("addresses")
def test_get_path_one_level_attribute(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
q = sess.query(User)
opt = self._option_fixture(User.addresses)
# ensure "current path" is fully consumed before
# matching against current entities.
# see [ticket:2098]
- sess = Session()
+ sess = fixture_session()
q = sess.query(User)
opt = self._option_fixture("email_address", "id")
q = sess.query(Address)._with_current_path(
def test_get_path_one_level_with_unrelated(self):
Order = self.classes.Order
- sess = Session()
+ sess = fixture_session()
q = sess.query(Order)
opt = self._option_fixture("addresses")
self._assert_path_result(opt, q, [])
self.classes.Order,
)
- sess = Session()
+ sess = fixture_session()
q = sess.query(User)
opt = self._option_fixture("orders.items.keywords")
self.classes.Order,
)
- sess = Session()
+ sess = fixture_session()
q = sess.query(User)
opt = self._option_fixture(User.orders, Order.items, Item.keywords)
self.classes.Order,
)
- sess = Session()
+ sess = fixture_session()
q = sess.query(Item)._with_current_path(
self._make_path_registry([User, "orders", Order, "items"])
)
self.classes.Order,
)
- sess = Session()
+ sess = fixture_session()
q = sess.query(Item)._with_current_path(
self._make_path_registry([User, "orders", Order, "items"])
)
self.classes.Order,
)
- sess = Session()
+ sess = fixture_session()
q = sess.query(Item)._with_current_path(
self._make_path_registry([User, "orders", Order, "items"])
)
self.classes.Order,
)
- sess = Session()
+ sess = fixture_session()
q = sess.query(Item)._with_current_path(
self._make_path_registry([User, "orders", Order, "items"])
)
self.classes.Order,
)
- sess = Session()
+ sess = fixture_session()
q = sess.query(Item)._with_current_path(
self._make_path_registry(
[inspect(aliased(User)), "orders", Order, "items"]
)
ac = aliased(User)
- sess = Session()
+ sess = fixture_session()
q = sess.query(Item)._with_current_path(
self._make_path_registry([inspect(ac), "orders", Order, "items"])
)
def test_from_base_to_subclass_attr(self):
Dingaling, Address = self.classes.Dingaling, self.classes.Address
- sess = Session()
+ sess = fixture_session()
class SubAddr(Address):
pass
def test_from_subclass_to_subclass_attr(self):
Dingaling, Address = self.classes.Dingaling, self.classes.Address
- sess = Session()
+ sess = fixture_session()
class SubAddr(Address):
pass
def test_from_base_to_base_attr_via_subclass(self):
Dingaling, Address = self.classes.Dingaling, self.classes.Address
- sess = Session()
+ sess = fixture_session()
class SubAddr(Address):
pass
def test_of_type(self):
User, Address = self.classes.User, self.classes.Address
- sess = Session()
+ sess = fixture_session()
class SubAddr(Address):
pass
def test_of_type_string_attr(self):
User, Address = self.classes.User, self.classes.Address
- sess = Session()
+ sess = fixture_session()
class SubAddr(Address):
pass
self.classes.Address,
)
- sess = Session()
+ sess = fixture_session()
class SubAddr(Address):
pass
def test_aliased_single(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
ualias = aliased(User)
q = sess.query(ualias)
opt = self._option_fixture(ualias.addresses)
def test_with_current_aliased_single(self):
User, Address = self.classes.User, self.classes.Address
- sess = Session()
+ sess = fixture_session()
ualias = aliased(User)
q = sess.query(ualias)._with_current_path(
self._make_path_registry([Address, "user"])
def test_with_current_aliased_single_nonmatching_option(self):
User, Address = self.classes.User, self.classes.Address
- sess = Session()
+ sess = fixture_session()
ualias = aliased(User)
q = sess.query(User)._with_current_path(
self._make_path_registry([Address, "user"])
def test_with_current_aliased_single_nonmatching_entity(self):
User, Address = self.classes.User, self.classes.Address
- sess = Session()
+ sess = fixture_session()
ualias = aliased(User)
q = sess.query(ualias)._with_current_path(
self._make_path_registry([Address, "user"])
Item = self.classes.Item
Order = self.classes.Order
opt = self._option_fixture(Order.items)
- sess = Session()
+ sess = fixture_session()
q = sess.query(Item, Order)
self._assert_path_result(opt, q, [(Order, "items")])
Item = self.classes.Item
Order = self.classes.Order
opt = self._option_fixture("items")
- sess = Session()
+ sess = fixture_session()
q = sess.query(Item, Order)
self._assert_path_result(opt, q, [])
Item = self.classes.Item
Order = self.classes.Order
opt = self._option_fixture("items")
- sess = Session()
+ sess = fixture_session()
q = sess.query(Item.id, Order.id)
self._assert_path_result(opt, q, [])
Item = self.classes.Item
Order = self.classes.Order
opt = self._option_fixture(User.orders)
- sess = Session()
+ sess = fixture_session()
q = sess.query(Item)._with_current_path(
self._make_path_registry([User, "orders", Order, "items"])
)
def test_chained(self):
User = self.classes.User
Order = self.classes.Order
- sess = Session()
+ sess = fixture_session()
q = sess.query(User)
opt = self._option_fixture(User.orders).joinedload("items")
self._assert_path_result(
User = self.classes.User
Order = self.classes.Order
Item = self.classes.Item
- sess = Session()
+ sess = fixture_session()
q = sess.query(User)
opt = self._option_fixture("orders.items").joinedload("keywords")
self._assert_path_result(
User = self.classes.User
Order = self.classes.Order
Item = self.classes.Item
- sess = Session()
+ sess = fixture_session()
q = sess.query(User)
opt = self._option_fixture(User.orders, Order.items).joinedload(
"keywords"
BaseCls, SubClass, Related, SubRelated = self.classes(
"BaseCls", "SubClass", "Related", "SubRelated"
)
- sess = Session()
+ sess = fixture_session()
q = sess.query(Related)._with_current_path(
self._make_path_registry([inspect(SubClass), "related"])
Item = self.classes.Item
context = (
- create_session()
+ fixture_session()
.query(*entity_list)
.options(joinedload(option))
._compile_state()
assert_raises_message(
orm_exc.LoaderStrategyException,
message,
- create_session()
+ fixture_session()
.query(*entity_list)
.options(*options)
._compile_state,
assert_raises_message(
sa.exc.ArgumentError,
message,
- create_session()
+ fixture_session()
.query(*entity_list)
.options(*options)
._compile_state,
assert_raises_message(
sa.exc.ArgumentError,
message,
- create_session()
+ fixture_session()
.query(column)
.options(joinedload(eager_option))
._compile_state,
class OptionsNoPropTestInh(_Polymorphic):
def test_missing_attr_wpoly_subclasss(self):
- s = Session()
+ s = fixture_session()
wp = with_polymorphic(Person, [Manager], flat=True)
)
def test_missing_attr_of_type_subclass(self):
- s = Session()
+ s = fixture_session()
assert_raises_message(
sa.exc.ArgumentError,
)
def test_missing_attr_of_type_subclass_name_matches(self):
- s = Session()
+ s = fixture_session()
# the name "status" is present on Engineer also, make sure
# that doesn't get mixed up here
)
def test_missing_str_attr_of_type_subclass(self):
- s = Session()
+ s = fixture_session()
assert_raises_message(
sa.exc.ArgumentError,
)
def test_missing_attr_of_type_wpoly_subclass(self):
- s = Session()
+ s = fixture_session()
wp = with_polymorphic(Person, [Manager], flat=True)
)
def test_missing_attr_is_missing_of_type_for_alias(self):
- s = Session()
+ s = fixture_session()
pa = aliased(Person)
opt.__setstate__(state)
- query = create_session().query(User)
+ query = fixture_session().query(User)
attr = {}
load = opt._bind_loader(
[
opt.__setstate__(state)
- query = create_session().query(User)
+ query = fixture_session().query(User)
attr = {}
load = opt._bind_loader(
[
def _assert_attrs(self, opts, expected):
User = self.classes.User
- query = create_session().query(User)
+ query = fixture_session().query(User)
attr = {}
for opt in opts:
defaultload(User.orders).defer(Order.description),
]
- sess = Session()
+ sess = fixture_session()
self._assert_opts(sess.query(User), sub_opt, non_sub_opts)
def test_two(self):
defaultload(User.orders).defer(Order.description),
]
- sess = Session()
+ sess = fixture_session()
self._assert_opts(sess.query(User), sub_opt, non_sub_opts)
def test_three(self):
)
sub_opt = defaultload(User.orders).options(defer("*"))
non_sub_opts = [defaultload(User.orders).defer("*")]
- sess = Session()
+ sess = fixture_session()
self._assert_opts(sess.query(User), sub_opt, non_sub_opts)
def test_four(self):
.defaultload(Item.keywords)
.defer(Keyword.name),
]
- sess = Session()
+ sess = fixture_session()
self._assert_opts(sess.query(User), sub_opt, non_sub_opts)
def test_four_strings(self):
.defaultload(Item.keywords)
.defer(Keyword.name),
]
- sess = Session()
+ sess = fixture_session()
self._assert_opts(sess.query(User), sub_opt, non_sub_opts)
def test_five(self):
joinedload(User.orders),
defaultload(User.orders).load_only(Order.description),
]
- sess = Session()
+ sess = fixture_session()
self._assert_opts(sess.query(User), sub_opt, non_sub_opts)
def test_five_strings(self):
joinedload(User.orders),
defaultload(User.orders).load_only(Order.description),
]
- sess = Session()
+ sess = fixture_session()
self._assert_opts(sess.query(User), sub_opt, non_sub_opts)
def test_invalid_one(self):
joinedload(User.orders).joinedload(Item.keywords),
defaultload(User.orders).joinedload(Order.items),
]
- sess = Session()
+ sess = fixture_session()
self._assert_opts(sess.query(User), sub_opt, non_sub_opts)
def test_invalid_two(self):
joinedload(User.orders).joinedload(Item.keywords),
defaultload(User.orders).joinedload(Order.items),
]
- sess = Session()
+ sess = fixture_session()
self._assert_opts(sess.query(User), sub_opt, non_sub_opts)
def test_not_implemented_fromload(self):
)
def go():
- sess = create_session()
+ sess = fixture_session()
u = (
sess.query(User)
.order_by(User.id)
),
)
- sess = create_session()
+ sess = fixture_session()
result = (
sess.query(User)
.order_by(User.id)
),
)
- sess = create_session()
+ sess = fixture_session()
u = (
sess.query(User)
.options(sa.orm.joinedload("addresses"))
),
)
- sess = create_session()
+ sess = fixture_session()
u = (
sess.query(User)
.options(sa.orm.lazyload("addresses"))
),
)
- sess = create_session()
+ sess = fixture_session()
# first test straight eager load, 1 statement
def go():
# then assert the data, which will launch 3 more lazy loads
# (previous users in session fell out of scope and were removed from
# session's identity map)
- r = users.select().order_by(users.c.id).execute()
+ r = sess.connection().execute(users.select().order_by(users.c.id))
ctx = sess.query(User)._compile_context()
),
)
- sess = create_session()
+ sess = fixture_session()
# first test straight eager load, 1 statement
def go():
# then select just from users. run it into instances.
# then assert the data, which will launch 6 more lazy loads
- r = users.select().execute()
+ r = sess.connection().execute(users.select())
ctx = sess.query(User)._compile_context()
),
)
- sess = create_session()
+ sess = fixture_session()
result = (
sess.query(User)
.order_by(User.id)
)
mapper(Item, items)
- sess = create_session()
+ sess = fixture_session()
oalias = aliased(Order)
opt1 = sa.orm.joinedload(User.orders, Order.items)
from sqlalchemy.orm import aliased
from sqlalchemy.orm import attributes
from sqlalchemy.orm import clear_mappers
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import exc as orm_exc
from sqlalchemy.orm import instrumentation
from sqlalchemy.orm import lazyload
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
-from sqlalchemy.orm import Session
-from sqlalchemy.orm import sessionmaker
from sqlalchemy.orm import state as sa_state
from sqlalchemy.orm import subqueryload
from sqlalchemy.orm import with_polymorphic
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.pickleable import Address
from sqlalchemy.testing.pickleable import Child1
from sqlalchemy.testing.pickleable import Child2
properties={"dingaling": relationship(Dingaling)},
)
mapper(Dingaling, dingalings)
- sess = create_session()
+ sess = fixture_session()
u1 = User(name="ed")
u1.addresses.append(Address(email_address="ed@bar.com"))
sess.add(u1)
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
u1 = User(name="ed")
u1.addresses.append(Address(email_address="ed@bar.com"))
"email_address": sa.orm.deferred(addresses.c.email_address)
},
)
- sess = create_session()
- u1 = User(name="ed")
- u1.addresses.append(Address(email_address="ed@bar.com"))
- sess.add(u1)
- sess.flush()
- sess.expunge_all()
- u1 = sess.query(User).get(u1.id)
- assert "name" not in u1.__dict__
- assert "addresses" not in u1.__dict__
+ with fixture_session(expire_on_commit=False) as sess:
+ u1 = User(name="ed")
+ u1.addresses.append(Address(email_address="ed@bar.com"))
+ sess.add(u1)
+ sess.commit()
+
+ with fixture_session() as sess:
+ u1 = sess.query(User).get(u1.id)
+ assert "name" not in u1.__dict__
+ assert "addresses" not in u1.__dict__
u2 = pickle.loads(pickle.dumps(u1))
- sess2 = create_session()
- sess2.add(u2)
- eq_(u2.name, "ed")
- eq_(
- u2,
- User(name="ed", addresses=[Address(email_address="ed@bar.com")]),
- )
+ with fixture_session() as sess2:
+ sess2.add(u2)
+ eq_(u2.name, "ed")
+ eq_(
+ u2,
+ User(
+ name="ed", addresses=[Address(email_address="ed@bar.com")]
+ ),
+ )
u2 = pickle.loads(pickle.dumps(u1))
- sess2 = create_session()
- u2 = sess2.merge(u2, load=False)
- eq_(u2.name, "ed")
- eq_(
- u2,
- User(name="ed", addresses=[Address(email_address="ed@bar.com")]),
- )
+ with fixture_session() as sess2:
+ u2 = sess2.merge(u2, load=False)
+ eq_(u2.name, "ed")
+ eq_(
+ u2,
+ User(
+ name="ed", addresses=[Address(email_address="ed@bar.com")]
+ ),
+ )
def test_instance_lazy_relation_loaders(self):
users, addresses = (self.tables.users, self.tables.addresses)
)
mapper(Address, addresses)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="ed", addresses=[Address(email_address="ed@bar.com")])
sess.add(u1)
u1 = sess.query(User).options(lazyload(User.addresses)).first()
u2 = pickle.loads(pickle.dumps(u1))
- sess = Session()
+ sess = fixture_session()
sess.add(u2)
assert u2.addresses
)
mapper(Address, addresses)
- sess = create_session()
- u1 = User(name="ed")
- u1.addresses.append(Address(email_address="ed@bar.com"))
- sess.add(u1)
- sess.flush()
- sess.expunge_all()
-
- u1 = (
- sess.query(User)
- .options(
- sa.orm.defer("name"), sa.orm.defer("addresses.email_address")
+ with fixture_session(expire_on_commit=False) as sess:
+ u1 = User(name="ed")
+ u1.addresses.append(Address(email_address="ed@bar.com"))
+ sess.add(u1)
+ sess.commit()
+
+ with fixture_session(expire_on_commit=False) as sess:
+ u1 = (
+ sess.query(User)
+ .options(
+ sa.orm.defer("name"),
+ sa.orm.defer("addresses.email_address"),
+ )
+ .get(u1.id)
)
- .get(u1.id)
- )
- assert "name" not in u1.__dict__
- assert "addresses" not in u1.__dict__
+ assert "name" not in u1.__dict__
+ assert "addresses" not in u1.__dict__
u2 = pickle.loads(pickle.dumps(u1))
- sess2 = create_session()
- sess2.add(u2)
- eq_(u2.name, "ed")
- assert "addresses" not in u2.__dict__
- ad = u2.addresses[0]
- assert "email_address" not in ad.__dict__
- eq_(ad.email_address, "ed@bar.com")
- eq_(
- u2,
- User(name="ed", addresses=[Address(email_address="ed@bar.com")]),
- )
+ with fixture_session() as sess2:
+ sess2.add(u2)
+ eq_(u2.name, "ed")
+ assert "addresses" not in u2.__dict__
+ ad = u2.addresses[0]
+ assert "email_address" not in ad.__dict__
+ eq_(ad.email_address, "ed@bar.com")
+ eq_(
+ u2,
+ User(
+ name="ed", addresses=[Address(email_address="ed@bar.com")]
+ ),
+ )
u2 = pickle.loads(pickle.dumps(u1))
- sess2 = create_session()
- u2 = sess2.merge(u2, load=False)
- eq_(u2.name, "ed")
- assert "addresses" not in u2.__dict__
- ad = u2.addresses[0]
+ with fixture_session() as sess2:
+ u2 = sess2.merge(u2, load=False)
+ eq_(u2.name, "ed")
+ assert "addresses" not in u2.__dict__
+ ad = u2.addresses[0]
- # mapper options now transmit over merge(),
- # new as of 0.6, so email_address is deferred.
- assert "email_address" not in ad.__dict__
+ # mapper options now transmit over merge(),
+ # new as of 0.6, so email_address is deferred.
+ assert "email_address" not in ad.__dict__
- eq_(ad.email_address, "ed@bar.com")
- eq_(
- u2,
- User(name="ed", addresses=[Address(email_address="ed@bar.com")]),
- )
+ eq_(ad.email_address, "ed@bar.com")
+ eq_(
+ u2,
+ User(
+ name="ed", addresses=[Address(email_address="ed@bar.com")]
+ ),
+ )
def test_pickle_protocols(self):
users, addresses = (self.tables.users, self.tables.addresses)
)
mapper(Address, addresses)
- sess = sessionmaker()()
+ sess = fixture_session()
u1 = User(name="ed")
u1.addresses.append(Address(email_address="ed@bar.com"))
sess.add(u1)
def test_09_pickle(self):
users = self.tables.users
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
sess.add(User(id=1, name="ed"))
sess.commit()
sess.close()
state.__setstate__(state_09)
eq_(state.expired_attributes, {"name", "id"})
- sess = Session()
+ sess = fixture_session()
sess.add(inst)
eq_(inst.name, "ed")
# test identity_token expansion
def test_11_pickle(self):
users = self.tables.users
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
u1 = User(id=1, name="ed")
sess.add(u1)
sess.commit()
eq_(opt2.__getstate__()["path"], serialized)
def test_load(self):
- s = Session()
+ s = fixture_session()
with_poly = with_polymorphic(Person, [Engineer, Manager], flat=True)
emp = (
)
eu = EmailUser(name="user1", email_address="foo@bar.com")
- sess = create_session()
- sess.add(eu)
- sess.flush()
- sess.expunge_all()
+ with fixture_session() as sess:
+ sess.add(eu)
+ sess.commit()
- eu = sess.query(User).first()
- eu2 = pickle.loads(pickle.dumps(eu))
- sess2 = create_session()
- sess2.add(eu2)
- assert "email_address" not in eu2.__dict__
- eq_(eu2.email_address, "foo@bar.com")
+ with fixture_session() as sess:
+ eu = sess.query(User).first()
+ eu2 = pickle.loads(pickle.dumps(eu))
+ sess2 = fixture_session()
+ sess2.add(eu2)
+ assert "email_address" not in eu2.__dict__
+ eq_(eu2.email_address, "foo@bar.com")
class TupleLabelTest(_fixtures.FixtureTest):
) # m2o
def test_tuple_labeling(self):
- sess = create_session()
+ sess = fixture_session()
# test pickle + all the protocols !
for pickled in False, -1, 0, 1, 2:
from sqlalchemy import Integer
from sqlalchemy import literal
from sqlalchemy import literal_column
-from sqlalchemy import MetaData
from sqlalchemy import null
from sqlalchemy import or_
from sqlalchemy import select
from sqlalchemy.orm import Bundle
from sqlalchemy.orm import column_property
from sqlalchemy.orm import contains_eager
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import defer
from sqlalchemy.orm import joinedload
from sqlalchemy.orm import lazyload
from sqlalchemy.testing.assertions import assert_raises
from sqlalchemy.testing.assertions import assert_raises_message
from sqlalchemy.testing.assertions import eq_
-from sqlalchemy.testing.assertions import eq_ignore_whitespace
from sqlalchemy.testing.assertions import expect_warnings
from sqlalchemy.testing.assertsql import CompiledSQL
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from sqlalchemy.util import collections_abc
def test_with_session(self):
User = self.classes.User
- s1 = Session()
- s2 = Session()
+ s1 = fixture_session()
+ s2 = fixture_session()
q1 = s1.query(User)
q2 = q1.with_session(s2)
assert q2.session is s2
class OnlyReturnTuplesTest(QueryTest):
def test_single_entity_false(self):
User = self.classes.User
- query = create_session().query(User).only_return_tuples(False)
+ query = fixture_session().query(User).only_return_tuples(False)
is_true(query.is_single_entity)
row = query.first()
assert isinstance(row, User)
def test_single_entity_true(self):
User = self.classes.User
- query = create_session().query(User).only_return_tuples(True)
+ query = fixture_session().query(User).only_return_tuples(True)
is_false(query.is_single_entity)
row = query.first()
assert isinstance(row, collections_abc.Sequence)
def test_multiple_entity_false(self):
User = self.classes.User
- query = create_session().query(User.id, User).only_return_tuples(False)
+ query = (
+ fixture_session().query(User.id, User).only_return_tuples(False)
+ )
is_false(query.is_single_entity)
row = query.first()
assert isinstance(row, collections_abc.Sequence)
def test_multiple_entity_true(self):
User = self.classes.User
- query = create_session().query(User.id, User).only_return_tuples(True)
+ query = fixture_session().query(User.id, User).only_return_tuples(True)
is_false(query.is_single_entity)
row = query.first()
assert isinstance(row, collections_abc.Sequence)
mapper(User, users, properties={"uname": users.c.name})
row = (
- create_session()
+ fixture_session()
.query(User.id, User.uname)
.filter(User.id == 7)
.first()
mapper(User, users)
- s = Session()
+ s = fixture_session()
q = testing.resolve_lambda(test_case, **locals())
mapper(User, users)
- s = Session(testing.db)
+ s = fixture_session()
q = testing.resolve_lambda(test_case, **locals())
mapper(User, users)
- s = Session()
+ s = fixture_session()
q = testing.resolve_lambda(test_case, **locals())
mapper(User, users, properties={"addresses": relationship(Address)})
mapper(Address, addresses)
- s = Session()
+ s = fixture_session()
row = s.query(User).only_return_tuples(True).first()
eq_(row._mapping[User], row[0])
mapper(User, users)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
user_alias = aliased(User)
user_alias_id_label = user_alias.id.label("foo")
address_alias = aliased(Address, name="aalias")
mapper(User, users)
- s = Session()
+ s = fixture_session()
q = s.query(User, type_coerce(users.c.id, MyType).label("foo")).filter(
User.id == 7
)
eq_(row, (User(id=7), [7]))
-class BindSensitiveStringifyTest(fixtures.TestBase):
- def _fixture(self):
- # building a totally separate metadata /mapping here
- # because we need to control if the MetaData is bound or not
-
- class User(object):
- pass
-
- m = MetaData()
- user_table = Table(
- "users",
- m,
- Column("id", Integer, primary_key=True),
- Column("name", String(50)),
- )
-
- mapper(User, user_table)
- return User
-
- def _dialect_fixture(self):
- class MyDialect(default.DefaultDialect):
- default_paramstyle = "qmark"
-
- from sqlalchemy.engine import base
-
- return base.Engine(mock.Mock(), MyDialect(), mock.Mock())
-
- def _test(self, bound_session, session_present, expect_bound):
- if bound_session:
- eng = self._dialect_fixture()
- else:
- eng = None
-
- User = self._fixture()
-
- s = Session(eng if bound_session else None)
- q = s.query(User).filter(User.id == 7)
- if not session_present:
- q = q.with_session(None)
-
- eq_ignore_whitespace(
- str(q),
- "SELECT users.id AS users_id, users.name AS users_name "
- "FROM users WHERE users.id = ?"
- if expect_bound
- else "SELECT users.id AS users_id, users.name AS users_name "
- "FROM users WHERE users.id = :id_1",
- )
-
- def test_query_bound_session(self):
- self._test(True, True, True)
-
- def test_query_no_session(self):
- self._test(False, False, False)
-
- def test_query_unbound_session(self):
- self._test(False, True, False)
-
-
class GetTest(QueryTest):
def test_loader_options(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
u1 = s.query(User).options(joinedload(User.addresses)).get(8)
eq_(len(u1.__dict__["addresses"]), 3)
def test_loader_options_future(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
u1 = s.get(User, 8, options=[joinedload(User.addresses)])
eq_(len(u1.__dict__["addresses"]), 3)
def test_get_composite_pk_keyword_based_no_result(self):
CompositePk = self.classes.CompositePk
- s = Session()
+ s = fixture_session()
is_(s.query(CompositePk).get({"i": 100, "j": 100}), None)
def test_get_composite_pk_keyword_based_result(self):
CompositePk = self.classes.CompositePk
- s = Session()
+ s = fixture_session()
one_two = s.query(CompositePk).get({"i": 1, "j": 2})
eq_(one_two.i, 1)
eq_(one_two.j, 2)
def test_get_composite_pk_keyword_based_wrong_keys(self):
CompositePk = self.classes.CompositePk
- s = Session()
+ s = fixture_session()
q = s.query(CompositePk)
assert_raises(sa_exc.InvalidRequestError, q.get, {"i": 1, "k": 2})
def test_get_composite_pk_keyword_based_too_few_keys(self):
CompositePk = self.classes.CompositePk
- s = Session()
+ s = fixture_session()
q = s.query(CompositePk)
assert_raises(sa_exc.InvalidRequestError, q.get, {"i": 1})
def test_get_composite_pk_keyword_based_too_many_keys(self):
CompositePk = self.classes.CompositePk
- s = Session()
+ s = fixture_session()
q = s.query(CompositePk)
assert_raises(
sa_exc.InvalidRequestError, q.get, {"i": 1, "j": "2", "k": 3}
def test_get(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
assert s.query(User).get(19) is None
u = s.query(User).get(7)
u2 = s.query(User).get(7)
def test_get_future(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
assert s.get(User, 19) is None
u = s.get(User, 7)
u2 = s.get(User, 7)
def test_get_composite_pk_no_result(self):
CompositePk = self.classes.CompositePk
- s = Session()
+ s = fixture_session()
assert s.query(CompositePk).get((100, 100)) is None
def test_get_composite_pk_result(self):
CompositePk = self.classes.CompositePk
- s = Session()
+ s = fixture_session()
one_two = s.query(CompositePk).get((1, 2))
assert one_two.i == 1
assert one_two.j == 2
def test_get_too_few_params(self):
CompositePk = self.classes.CompositePk
- s = Session()
+ s = fixture_session()
q = s.query(CompositePk)
assert_raises(sa_exc.InvalidRequestError, q.get, 7)
def test_get_too_few_params_tuple(self):
CompositePk = self.classes.CompositePk
- s = Session()
+ s = fixture_session()
q = s.query(CompositePk)
assert_raises(sa_exc.InvalidRequestError, q.get, (7,))
def test_get_too_many_params(self):
CompositePk = self.classes.CompositePk
- s = Session()
+ s = fixture_session()
q = s.query(CompositePk)
assert_raises(sa_exc.InvalidRequestError, q.get, (7, 10, 100))
def test_get_against_col(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
q = s.query(User.id)
assert_raises(sa_exc.InvalidRequestError, q.get, (5,))
PK (i.e. map to an outerjoin) works with get()."""
UserThing = outerjoin_mapping
- sess = create_session()
+ sess = fixture_session()
u10 = sess.query(UserThing).get((10, None))
eq_(u10, UserThing(id=10))
def test_get_fully_null_pk(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
q = s.query(User)
assert_raises_message(
sa_exc.SAWarning,
def test_get_fully_null_composite_pk(self, outerjoin_mapping):
UserThing = outerjoin_mapping
- s = Session()
+ s = fixture_session()
q = s.query(UserThing)
assert_raises_message(
User, Address = self.classes.User, self.classes.Address
- s = create_session()
+ s = fixture_session()
q = s.query(User).join("addresses").filter(Address.user_id == 8)
assert_raises(sa_exc.InvalidRequestError, q.get, 7)
User, Address = self.classes.User, self.classes.Address
- s = create_session()
+ s = fixture_session()
s.query(User).get(7)
m = mapper(SomeUser, s)
assert s.primary_key == m.primary_key
- sess = create_session()
+ sess = fixture_session()
assert sess.query(SomeUser).get(7).name == "jack"
def test_load(self):
User, Address = self.classes.User, self.classes.Address
- s = create_session()
+ s = fixture_session(autoflush=False)
assert s.query(User).populate_existing().get(19) is None
assert u2.name == "jack"
assert a not in u2.addresses
- @testing.provide_metadata
@testing.requires.unicode_connections
- def test_unicode(self, connection):
- """test that Query.get properly sets up the type for the bind
- parameter. using unicode would normally fail on postgresql, mysql and
- oracle unless it is converted to an encoded string"""
-
- metadata = self.metadata
+ def test_unicode(self, metadata, connection):
table = Table(
"unicode_data",
metadata,
def test_populate_existing(self):
User, Address = self.classes.User, self.classes.Address
- s = create_session()
+ s = fixture_session(autoflush=False)
userlist = s.query(User).all()
def test_populate_existing_future(self):
User, Address = self.classes.User, self.classes.Address
- s = Session(testing.db, autoflush=False)
+ s = fixture_session(autoflush=False)
userlist = s.query(User).all()
stmt = select(User).execution_options(
populate_existing=True, autoflush=False, yield_per=10
)
- s = Session(testing.db)
+ s = fixture_session()
m1 = mock.Mock()
def test_no_limit_offset(self, test_case):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q = testing.resolve_lambda(test_case, User=User, s=s)
def test_no_from(self):
users, User = self.tables.users, self.classes.User
- s = create_session()
+ s = fixture_session()
q = s.query(User).select_from(users)
assert_raises(sa_exc.InvalidRequestError, q.select_from, users)
def test_invalid_select_from(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q = s.query(User)
assert_raises(sa_exc.ArgumentError, q.select_from, User.id == 5)
assert_raises(sa_exc.ArgumentError, q.select_from, User.id)
self.tables.users,
)
- s = create_session()
+ s = fixture_session()
q = s.query(User)
assert_raises(sa_exc.ArgumentError, q.from_statement, User.id == 5)
assert_raises(
def test_invalid_column(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q = s.query(User)
assert_raises(sa_exc.ArgumentError, q.add_columns, object())
def test_invalid_column_tuple(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q = s.query(User)
assert_raises(sa_exc.ArgumentError, q.add_columns, (1, 1))
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q = s.query(User).distinct()
assert_raises(sa_exc.InvalidRequestError, q.select_from, User)
assert_raises(
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q = s.query(User).order_by(User.id)
assert_raises(sa_exc.InvalidRequestError, q.select_from, User)
assert_raises(
def test_only_full_mapper_zero(self):
User, Address = self.classes.User, self.classes.Address
- s = create_session()
+ s = fixture_session()
q = s.query(User, Address)
assert_raises(sa_exc.InvalidRequestError, q.get, 5)
def test_entity_or_mapper_zero_from_context(self):
User, Address = self.classes.User, self.classes.Address
- s = create_session()
+ s = fixture_session()
q = s.query(User, Address)._compile_state()
is_(q._mapper_zero(), inspect(User))
def test_from_statement(self, test_case):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q = testing.resolve_lambda(test_case, User=User, s=s)
def test_from_statement_text(self, meth, test_case):
User = self.classes.User
- s = Session()
+ s = fixture_session()
q = s.query(User)
q = q.from_statement(text("x"))
ua,
)
- s = Session()
+ s = fixture_session()
assert_raises_message(
sa_exc.ArgumentError,
"SQL expression element or literal value expected, got .*User",
if entity is not None:
# specify a lead entity, so that when we are testing
# correlation, the correlation actually happens
- sess = Session()
+ sess = fixture_session()
lead = sess.query(entity)
context = lead._compile_context()
context.compile_state.statement._label_style = (
self, clause, expected, from_, onclause, checkparams=None
):
dialect = default.DefaultDialect()
- sess = Session()
+ sess = fixture_session()
lead = sess.query(from_).join(onclause, aliased=True)
full = lead.filter(clause)
context = lead._compile_context()
lhs = testing.resolve_lambda(lhs, User=User)
rhs = testing.resolve_lambda(rhs, User=User)
- create_session().query(User)
+ fixture_session().query(User)
self._test(py_op(lhs, rhs), res % sql_op)
@testing.combinations(
def test_comparison(self, py_op, fwd_op, rev_op, fixture):
User = self.classes.User
- create_session().query(User)
+ fixture_session().query(User)
ualias = aliased(User)
lhs, rhs, l_sql, r_sql = fixture(User=User, ualias=ualias)
self.classes.Address,
self.classes.Dingaling,
)
- sess = Session()
+ sess = fixture_session()
q = sess.query(User).filter(
User.addresses.any(
def test_function_element_column_labels(self):
users = self.tables.users
- sess = Session()
+ sess = fixture_session()
class max_(expression.FunctionElement):
name = "max"
def test_truly_unlabeled_sql_expressions(self):
users = self.tables.users
- sess = Session()
+ sess = fixture_session()
class not_named_max(expression.ColumnElement):
name = "not_named_max"
self.classes.Address,
)
- session = create_session()
+ session = fixture_session()
s = (
session.query(User)
.filter(
User = self.classes.User
Address = self.classes.Address
- session = create_session()
+ session = fixture_session()
q = session.query(User.id).filter(User.id == 7).scalar_subquery()
def test_subquery_no_eagerloads(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(User).options(joinedload(User.addresses)).subquery(),
def test_exists_no_eagerloads(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(
def test_named_subquery(self):
User = self.classes.User
- session = create_session()
+ session = fixture_session()
a1 = session.query(User.id).filter(User.id == 7).subquery("foo1")
a2 = session.query(User.id).filter(User.id == 7).subquery(name="foo2")
a3 = session.query(User.id).filter(User.id == 7).subquery()
def test_labeled_subquery(self):
User = self.classes.User
- session = create_session()
+ session = fixture_session()
a1 = (
session.query(User.id)
.filter(User.id == 7)
User = self.classes.User
ua = aliased(User)
- session = create_session()
+ session = fixture_session()
a1 = (
session.query(User.id, ua.id, ua.name)
.filter(User.id == ua.id)
def test_label(self):
User = self.classes.User
- session = create_session()
+ session = fixture_session()
q = session.query(User.id).filter(User.id == 7).label("foo")
self.assert_compile(
def test_scalar_subquery(self):
User = self.classes.User
- session = create_session()
+ session = fixture_session()
q = session.query(User.id).filter(User.id == 7).scalar_subquery()
def test_param_transfer(self):
User = self.classes.User
- session = create_session()
+ session = fixture_session()
q = (
session.query(User.id)
def test_in(self):
User, Address = self.classes.User, self.classes.Address
- session = create_session()
+ session = fixture_session()
s = (
session.query(User.id)
.join(User.addresses)
def test_union(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q1 = s.query(User).filter(User.name == "ed").with_labels()
q2 = s.query(User).filter(User.name == "fred").with_labels()
def test_select(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
# this is actually not legal on most DBs since the subquery has no
# alias
def test_join(self):
User, Address = self.classes.User, self.classes.Address
- s = create_session()
+ s = fixture_session()
# TODO: do we want aliased() to detect a query and convert to
# subquery() automatically ?
def test_group_by_plain(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q1 = s.query(User.id, User.name).group_by(User.name)
self.assert_compile(
def test_group_by_append(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q1 = s.query(User.id, User.name).group_by(User.name)
def test_group_by_cancellation(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q1 = s.query(User.id, User.name).group_by(User.name)
# test cancellation by using None, replacement with something else
def test_group_by_cancelled_still_present(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q1 = s.query(User.id, User.name).group_by(User.name).group_by(None)
def test_order_by_plain(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q1 = s.query(User.id, User.name).order_by(User.name)
self.assert_compile(
def test_order_by_append(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q1 = s.query(User.id, User.name).order_by(User.name)
def test_order_by_cancellation(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q1 = s.query(User.id, User.name).order_by(User.name)
# test cancellation by using None, replacement with something else
def test_order_by_cancellation_false(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q1 = s.query(User.id, User.name).order_by(User.name)
# test cancellation by using None, replacement with something else
def test_order_by_cancelled_allows_assertions(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q1 = s.query(User.id, User.name).order_by(User.name).order_by(None)
def test_legacy_order_by_cancelled_allows_assertions(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q1 = s.query(User.id, User.name).order_by(User.name).order_by(False)
self._func_fixture()
User = self.classes.User
- s = Session()
+ s = fixture_session()
u1 = aliased(User)
self.assert_compile(
self._func_fixture(label=True)
User = self.classes.User
- s = Session()
+ s = fixture_session()
u1 = aliased(User)
self.assert_compile(
self._func_fixture()
User = self.classes.User
- s = Session()
+ s = fixture_session()
u1 = aliased(User)
self.assert_compile(
User, Address = self.classes("User", "Address")
self._fixture(label=True)
- s = Session()
+ s = fixture_session()
q = s.query(User).order_by("email_ad")
self.assert_compile(
q,
User, Address = self.classes("User", "Address")
self._fixture(label=True)
- s = Session()
+ s = fixture_session()
ua = aliased(User)
q = s.query(ua).order_by("email_ad")
self._fixture(label=True)
ua = aliased(User)
- s = Session()
+ s = fixture_session()
q = s.query(ua).order_by(ua.ead)
self.assert_compile(
q,
self._fixture(label=True)
ua = aliased(User)
- s = Session()
+ s = fixture_session()
q = s.query(ua.ead).order_by(ua.ead)
self.assert_compile(
q,
self._fixture(label=True)
ua = aliased(User)
- s = Session()
+ s = fixture_session()
q = s.query(User.ead, ua.ead).order_by(User.ead, ua.ead)
self.assert_compile(
q,
self._fixture(label=True, polymorphic=True)
ua = aliased(User)
- s = Session()
+ s = fixture_session()
q = s.query(ua, User.id).order_by(ua.ead)
self.assert_compile(
q,
self._fixture(label=False)
ua = aliased(User)
- s = Session()
+ s = fixture_session()
q = s.query(ua).order_by(ua.ead)
self.assert_compile(
q,
self._fixture(label=False)
ua = aliased(User)
- s = Session()
+ s = fixture_session()
q = s.query(ua.ead).order_by(ua.ead)
self.assert_compile(
q,
self._fixture(label=False)
ua = aliased(User)
- s = Session()
+ s = fixture_session()
q = s.query(User.ead, ua.ead).order_by(User.ead, ua.ead)
self.assert_compile(
q,
User, Address = self.classes("User", "Address")
self._fixture(label=True)
- s = Session()
+ s = fixture_session()
q = s.query(User).order_by(User.ead)
# this one is a bit of a surprise; this is compiler
# label-order-by logic kicking in, but won't work in more
User, Address = self.classes("User", "Address")
self._fixture(label=True)
- s = Session()
+ s = fixture_session()
q = s.query(User).options(defer(User.ead)).order_by(User.ead)
self.assert_compile(
q,
# this use case isn't exactly needed in this form, however it tests
# that we resolve for multiple __clause_element__() calls as is needed
# by systems like composites
- sess = Session()
+ sess = fixture_session()
eq_(
sess.query(Comparator(User.id))
.order_by(Comparator(User.id))
def test_first(self):
User = self.classes.User
- assert User(id=7) == create_session().query(User).first()
+ assert User(id=7) == fixture_session().query(User).first()
assert (
- create_session().query(User).filter(User.id == 27).first() is None
+ fixture_session().query(User).filter(User.id == 27).first() is None
)
def test_negative_indexes_raise(self):
User = self.classes.User
- sess = create_session(future=True)
+ sess = fixture_session(future=True)
q = sess.query(User).order_by(User.id)
with expect_raises_message(
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User).order_by(User.id)
self.assert_sql(
def test_first_against_expression_offset(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(User)
.order_by(User.id)
def test_full_slice_against_expression_offset(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(User)
.order_by(User.id)
def test_full_slice_against_integer_offset(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User).order_by(User.id).offset(2)
self.assert_sql(
def test_start_slice_against_expression_offset(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User).order_by(User.id).offset(literal_column("2"))
self.assert_sql(
def test_basic(self):
User = self.classes.User
- users = create_session().query(User).all()
+ users = fixture_session().query(User).all()
eq_([User(id=7), User(id=8), User(id=9), User(id=10)], users)
@testing.requires.offset
def test_limit_offset(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
assert [User(id=8), User(id=9)] == sess.query(User).order_by(
User.id
def test_select_with_bindparam_offset_limit(self):
"""Does a query allow bindparam for the limit?"""
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q1 = (
sess.query(self.classes.User)
.order_by(self.classes.User.id)
@testing.requires.bound_limit_offset
def test_select_with_bindparam_offset_limit_w_cast(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
eq_(
list(
sess.query(User)
def test_exists(self):
User = self.classes.User
- sess = create_session(testing.db)
+ sess = fixture_session()
assert sess.query(exists().where(User.id == 9)).scalar()
assert not sess.query(exists().where(User.id == 29)).scalar()
def test_one_filter(self):
User = self.classes.User
- assert [User(id=8), User(id=9)] == create_session().query(User).filter(
- User.name.endswith("ed")
- ).all()
+ assert [User(id=8), User(id=9)] == fixture_session().query(
+ User
+ ).filter(User.name.endswith("ed")).all()
def test_contains(self):
"""test comparing a collection to an object instance."""
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
address = sess.query(Address).get(3)
assert [User(id=8)] == sess.query(User).filter(
User.addresses.contains(address)
def test_clause_element_ok(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(User).filter(User.addresses),
"SELECT users.id AS users_id, users.name AS users_name "
unique"""
User, Address = self.classes.User, self.classes.Address
- sess = Session()
+ sess = fixture_session()
a1, a2 = sess.query(Address).order_by(Address.id)[0:2]
self.assert_compile(
sess.query(User)
# SQL compilation
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
assert [User(id=8), User(id=9)] == sess.query(User).filter(
User.addresses.any(Address.email_address.like("%ed%"))
# SQL compilation
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
# test that any() doesn't overcorrelate
assert [User(id=7), User(id=8)] == sess.query(User).join(
self.classes.Address,
)
- sess = create_session()
+ sess = fixture_session()
assert [Address(id=5)] == sess.query(Address).filter(
Address.user.has(name="fred")
).all()
def test_contains_m2m(self):
Item, Order = self.classes.Item, self.classes.Order
- sess = create_session()
+ sess = fixture_session()
item = sess.query(Item).get(3)
eq_(
self.classes.Address,
)
- sess = create_session()
+ sess = fixture_session()
assert_raises_message(
sa.exc.ArgumentError,
"Mapped instance expected for relationship comparison to object.",
self.classes.Address,
)
- sess = create_session()
+ sess = fixture_session()
user = sess.query(User).get(8)
assert [Address(id=2), Address(id=3), Address(id=4)] == sess.query(
Address
def test_filter_by(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
user = sess.query(User).get(8)
assert [Address(id=2), Address(id=3), Address(id=4)] == sess.query(
Address
def test_filter_by_tables(self):
users = self.tables.users
addresses = self.tables.addresses
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(users)
.filter_by(name="ed")
def test_empty_filters(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q1 = sess.query(User)
def test_filter_by_no_property(self):
addresses = self.tables.addresses
- sess = create_session()
+ sess = fixture_session()
assert_raises_message(
sa.exc.InvalidRequestError,
'Entity namespace for "addresses" has no property "name"',
self.classes.Address,
)
- sess = create_session()
+ sess = fixture_session()
# scalar
eq_(
eq_(
[(7,), (8,), (9,), (10,)],
- create_session()
+ fixture_session()
.query(User.id)
.filter_by()
.order_by(User.id)
)
eq_(
[(7,), (8,), (9,), (10,)],
- create_session()
+ fixture_session()
.query(User.id)
.filter_by(**{})
.order_by(User.id)
def test_text_coerce(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
self.assert_compile(
s.query(User).filter(text("name='ed'")),
"SELECT users.id AS users_id, users.name "
)
def test_filter_by_non_entity(self):
- s = create_session()
+ s = fixture_session()
e = sa.func.count(123)
assert_raises_message(
sa_exc.InvalidRequestError,
def test_has_composite_secondary(self):
A, D = self.classes("A", "D")
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(A).filter(A.d.has(D.id == 1)),
"SELECT a.id AS a_id, a.b_id AS a_b_id FROM a WHERE EXISTS "
def test_has_many_to_one(self):
B, C = self.classes("B", "C")
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(B).filter(B.c.has(C.id == 1)),
"SELECT b.id AS b_id, b.c_id AS b_c_id FROM b WHERE "
def test_any_many_to_many(self):
B, D = self.classes("B", "D")
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(B).filter(B.d.any(D.id == 1)),
"SELECT b.id AS b_id, b.c_id AS b_c_id FROM b WHERE "
def test_any_one_to_many(self):
B, C = self.classes("B", "C")
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(C).filter(C.bs.any(B.id == 1)),
"SELECT c.id AS c_id, c.d_id AS c_d_id FROM c WHERE "
def test_any_many_to_many_doesnt_overcorrelate(self):
B, D = self.classes("B", "D")
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(B).join(B.d).filter(B.d.any(D.id == 1)),
def test_has_doesnt_overcorrelate(self):
B, C = self.classes("B", "C")
- s = Session()
+ s = fixture_session()
self.assert_compile(
s.query(B).join(B.c).filter(B.c.has(C.id == 1)),
def test_has_doesnt_get_aliased_join_subq(self):
B, C = self.classes("B", "C")
- s = Session()
+ s = fixture_session()
ca = aliased(C)
self.assert_compile(
def test_any_many_to_many_doesnt_get_aliased_join_subq(self):
B, D = self.classes("B", "D")
- s = Session()
+ s = fixture_session()
da = aliased(D)
self.assert_compile(
class HasMapperEntitiesTest(QueryTest):
def test_entity(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
q = s.query(User)
def test_cols(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
q = s.query(User.id)
def test_cols_set_entities(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
q = s.query(User.id)
def test_entity_set_entities(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
q = s.query(User)
def test_union(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
fred = s.query(User).filter(User.name == "fred")
ed = s.query(User).filter(User.name == "ed")
User, Address = self.classes.User, self.classes.Address
- s = create_session()
+ s = fixture_session()
q1 = (
s.query(User, Address)
.join(User.addresses)
User = self.classes.User
- s = Session()
+ s = fixture_session()
q1 = s.query(User, literal("x"))
q2 = s.query(User, literal_column("'y'"))
q3 = q1.union(q2)
def test_union_literal_expressions_results(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
x_literal = literal("x")
q1 = s.query(User, x_literal)
def test_union_labeled_anonymous_columns(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
c1, c2 = column("c1"), column("c2")
q1 = s.query(User, c1.label("foo"), c1.label("bar"))
def test_order_by_anonymous_col(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
c1, c2 = column("c1"), column("c2")
f = c1.label("foo")
def test_union_mapped_colnames_preserved_across_subquery(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
q1 = s.query(User.name)
q2 = s.query(User.name)
def test_intersect(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
fred = s.query(User).filter(User.name == "fred")
ed = s.query(User).filter(User.name == "ed")
def test_eager_load(self):
User, Address = self.classes.User, self.classes.Address
- s = create_session()
+ s = fixture_session()
fred = s.query(User).filter(User.name == "fred")
ed = s.query(User).filter(User.name == "ed")
def test_sum(self):
Order = self.classes.Order
- sess = create_session()
+ sess = fixture_session()
orders = sess.query(Order).filter(Order.id.in_([2, 3, 4]))
eq_(
orders.with_entities(
def test_apply(self):
Order = self.classes.Order
- sess = create_session()
+ sess = fixture_session()
assert sess.query(func.sum(Order.user_id * Order.address_id)).filter(
Order.id.in_([2, 3, 4])
).one() == (79,)
def test_having(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
assert [User(name="ed", id=8)] == sess.query(User).order_by(
User.id
).group_by(User).join("addresses").having(
def test_exists(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q1 = sess.query(User)
self.assert_compile(
def test_exists_col_warning(self):
User = self.classes.User
Address = self.classes.Address
- sess = create_session()
+ sess = fixture_session()
q1 = sess.query(User, Address).filter(User.id == Address.user_id)
self.assert_compile(
def test_exists_w_select_from(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q1 = sess.query().select_from(User).exists()
self.assert_compile(
def test_basic(self):
users, User = self.tables.users, self.classes.User
- s = create_session()
+ s = fixture_session()
eq_(s.query(User).count(), 4)
def test_basic_future(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
eq_(
s.execute(select(func.count()).select_from(User)).scalar(),
def test_count_char(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
# '*' is favored here as the most common character,
# it is reported that Informix doesn't like count(1),
# rumors about Oracle preferring count(1) don't appear
def test_multiple_entity(self):
User, Address = self.classes.User, self.classes.Address
- s = create_session()
+ s = fixture_session()
q = s.query(User, Address).join(Address, true())
eq_(q.count(), 20) # cartesian product
def test_multiple_entity_future(self):
User, Address = self.classes.User, self.classes.Address
- s = create_session()
+ s = fixture_session()
stmt = select(User, Address).join(Address, true())
def test_nested(self):
User, Address = self.classes.User, self.classes.Address
- s = create_session()
+ s = fixture_session()
q = s.query(User, Address).join(Address, true()).limit(2)
eq_(q.count(), 2)
def test_nested_future(self):
User, Address = self.classes.User, self.classes.Address
- s = create_session()
+ s = fixture_session()
stmt = select(User, Address).join(Address, true()).limit(2)
eq_(
User, Address = self.classes.User, self.classes.Address
- s = create_session()
+ s = fixture_session()
q = s.query(func.count(distinct(User.name)))
eq_(q.count(), 1)
User, Address = self.classes.User, self.classes.Address
- s = create_session()
+ s = fixture_session()
stmt = select(func.count(distinct(User.name)))
eq_(
eq_(
[User(id=7), User(id=8), User(id=9), User(id=10)],
- create_session().query(User).order_by(User.id).distinct().all(),
+ fixture_session().query(User).order_by(User.id).distinct().all(),
)
eq_(
[User(id=7), User(id=9), User(id=8), User(id=10)],
- create_session()
+ fixture_session()
.query(User)
.distinct()
.order_by(desc(User.name))
expr = (User.id.op("+")(2)).label("label")
- sess = create_session()
+ sess = fixture_session()
q = sess.query(expr).select_from(User).order_by(desc(expr)).distinct()
expr = User.id + literal(1)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(expr).select_from(User).order_by(asc(expr)).distinct()
# no double col in the select list,
expr = (User.id + literal(1)).label("label")
- sess = create_session()
+ sess = fixture_session()
q = sess.query(expr).select_from(User).order_by(asc(expr)).distinct()
# no double col in the select list,
expr = (User.id + literal(1)).label("label")
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(expr)
.select_from(User)
"""
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
subq = (
sess.query(User, Address.email_address)
"""
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(User, Address.email_address)
.join("addresses")
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
# test that it works on embedded joinedload/LIMIT subquery
q = (
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
subq = (
sess.query(
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(
def test_columns_augmented_sql_one(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
subq = (
sess.query(
def test_columns_augmented_sql_union_one(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(
def test_columns_augmented_sql_union_two(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(
def test_columns_augmented_sql_two(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(User)
def test_columns_augmented_sql_three(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(User.id, User.name.label("foo"), Address.id)
def test_columns_augmented_distinct_on(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
subq = (
sess.query(
def test_columns_augmented_sql_three_using_label_reference(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(User.id, User.name.label("foo"), Address.id)
def test_columns_augmented_sql_illegal_label_reference(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User.id, User.name.label("foo"), Address.id).distinct(
"not a label"
def test_columns_augmented_sql_four(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(User)
class PrefixSuffixWithTest(QueryTest, AssertsCompiledSQL):
def test_one_prefix(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
query = sess.query(User.name).prefix_with("PREFIX_1")
expected = "SELECT PREFIX_1 " "users.name AS users_name FROM users"
self.assert_compile(query, expected, dialect=default.DefaultDialect())
def test_one_suffix(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
query = sess.query(User.name).suffix_with("SUFFIX_1")
# trailing space for some reason
expected = "SELECT users.name AS users_name FROM users SUFFIX_1 "
def test_many_prefixes(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
query = sess.query(User.name).prefix_with("PREFIX_1", "PREFIX_2")
expected = (
"SELECT PREFIX_1 PREFIX_2 " "users.name AS users_name FROM users"
def test_chained_prefixes(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
query = (
sess.query(User.name)
.prefix_with("PREFIX_1")
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q = iter(
sess.query(User)
.yield_per(1)
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
@event.listens_for(sess, "do_orm_execute")
def check(ctx):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
@event.listens_for(sess, "do_orm_execute")
def check(ctx):
self._eagerload_mappings()
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User).options(joinedload("addresses")).yield_per(1)
assert_raises_message(
sa_exc.InvalidRequestError,
self._eagerload_mappings()
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User).options(subqueryload("addresses")).yield_per(1)
assert_raises_message(
sa_exc.InvalidRequestError,
self._eagerload_mappings(addresses_lazy="subquery")
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User).yield_per(1)
assert_raises_message(
sa_exc.InvalidRequestError,
def test_joinedload_m2o_ok(self):
self._eagerload_mappings(user_lazy="joined")
Address = self.classes.Address
- sess = create_session()
+ sess = fixture_session()
q = sess.query(Address).yield_per(1)
q.all()
self._eagerload_mappings()
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(User)
.options(subqueryload("addresses"))
def test_m2o_joinedload_not_others(self):
self._eagerload_mappings(addresses_lazy="joined")
Address = self.classes.Address
- sess = create_session()
+ sess = fixture_session()
q = (
sess.query(Address)
.options(lazyload("*"), joinedload("user"))
dialect = mysql.dialect()
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User).with_hint(
def test_statement_hints(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
stmt = (
sess.query(User)
.with_statement_hint("test hint one")
assert_raises_message(
sa_exc.ArgumentError,
"Textual SQL expression",
- create_session().query(User).from_statement,
+ fixture_session().query(User).from_statement,
"select * from users order by id",
)
User = self.classes.User
eq_(
- create_session()
+ fixture_session()
.query(User)
.from_statement(text("select * from users order by id"))
.first(),
User(id=7),
)
eq_(
- create_session()
+ fixture_session()
.query(User)
.from_statement(
text("select * from users where name='nonexistent'")
def test_select_star_future(self):
User = self.classes.User
- sess = Session(testing.db)
+ sess = fixture_session()
eq_(
sess.execute(
select(User).from_statement(
# ordering doesn't matter
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q = s.query(User).from_statement(
text(
"select name, 27 as foo, id as users_id from users order by id"
# ordering doesn't matter
User = self.classes.User
- s = create_session(testing.db)
+ s = fixture_session()
q = select(User).from_statement(
text(
"select name, 27 as foo, id as users_id from users order by id"
User = self.classes.User
Address = self.classes.Address
- s = create_session()
+ s = fixture_session()
q = s.query(User, Address).from_statement(
text(
"select users.name AS users_name, users.id AS users_id, "
User = self.classes.User
Address = self.classes.Address
- s = create_session(testing.db)
+ s = fixture_session()
q = select(User, Address).from_statement(
text(
"select users.name AS users_name, users.id AS users_id, "
User = self.classes.User
Address = self.classes.Address
- s = create_session()
+ s = fixture_session()
q = (
s.query(User)
.from_statement(
User = self.classes.User
Address = self.classes.Address
- s = create_session(testing.db)
+ s = fixture_session()
q = (
select(User)
.from_statement(
User = self.classes.User
Address = self.classes.Address
- s = create_session()
+ s = fixture_session()
q = (
s.query(User)
.from_statement(
User = self.classes.User
Address = self.classes.Address
- s = create_session(testing.db)
+ s = fixture_session()
q = (
select(User)
.from_statement(
users = self.tables.users
addresses = self.tables.addresses
- s = create_session()
+ s = fixture_session()
q = s.query(User.name, User.id, Address.id).from_statement(
text(
"select users.name AS users_name, users.id AS users_id, "
if add_columns:
text_clause = text_clause.columns(User.id, User.name)
- s = create_session()
+ s = fixture_session()
q = (
s.query(User)
.from_statement(text_clause)
User = self.classes.User
eq_(
- create_session().query(User).filter(text("id in (8, 9)")).all(),
+ fixture_session().query(User).filter(text("id in (8, 9)")).all(),
[User(id=8), User(id=9)],
)
eq_(
- create_session()
+ fixture_session()
.query(User)
.filter(text("name='fred'"))
.filter(text("id=9"))
[User(id=9)],
)
eq_(
- create_session()
+ fixture_session()
.query(User)
.filter(text("name='fred'"))
.filter(User.id == 9)
def test_whereclause_future(self):
User = self.classes.User
- s = create_session(testing.db)
+ s = fixture_session()
eq_(
s.execute(select(User).filter(text("id in (8, 9)")))
.scalars()
sa_exc.ArgumentError,
r"Textual SQL expression 'id in \(:id1, :id2\)' "
"should be explicitly declared",
- create_session().query(User).filter,
+ fixture_session().query(User).filter,
"id in (:id1, :id2)",
)
def test_plain_textual_column(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
self.assert_compile(
s.query(User.id, text("users.name")),
def test_via_select(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
eq_(
s.query(User)
.from_statement(
def test_via_textasfrom_from_statement(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
eq_(
s.query(User)
def test_columns_via_textasfrom_from_statement(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
eq_(
s.query(User.id, User.name)
def test_via_textasfrom_use_mapped_columns(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
eq_(
s.query(User)
def test_via_textasfrom_select_from(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
eq_(
s.query(User)
def test_group_by_accepts_text(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q = s.query(User).group_by(text("name"))
self.assert_compile(
def test_order_by_w_eager_one(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
# from 1.0.0 thru 1.0.2, the "name" symbol here was considered
# to be part of the things we need to ORDER BY and it was being
def test_order_by_w_eager_two(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
q = (
s.query(User)
def test_order_by_w_eager_three(self):
User = self.classes.User
- s = create_session()
+ s = fixture_session()
self.assert_compile(
s.query(User)
def test_order_by_w_eager_four(self):
User = self.classes.User
Address = self.classes.Address
- s = create_session()
+ s = fixture_session()
self.assert_compile(
s.query(User)
User = self.classes.User
Address = self.classes.Address
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User, Address.email_address.label("email_address"))
def test_filter(self):
User = self.classes.User
- self._test(Session().query(User.id).filter, "myid == 5", "myid == 5")
+ self._test(
+ fixture_session().query(User.id).filter, "myid == 5", "myid == 5"
+ )
def test_having(self):
User = self.classes.User
- self._test(Session().query(User.id).having, "myid == 5", "myid == 5")
+ self._test(
+ fixture_session().query(User.id).having, "myid == 5", "myid == 5"
+ )
def test_from_statement(self):
User = self.classes.User
self._test(
- Session().query(User.id).from_statement,
+ fixture_session().query(User.id).from_statement,
"select id from user",
"select id from user",
)
self.classes.Order,
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
u1 = q.filter_by(name="jack").one()
def test_select_from(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
u1 = sess.query(User).get(7)
q = sess.query(Address).select_from(Address).with_parent(u1)
self.assert_compile(
def test_from_entity_standalone_fn(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
u1 = sess.query(User).get(7)
q = sess.query(User, Address).filter(
with_parent(u1, "addresses", from_entity=Address)
def test_from_entity_query_entity(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
u1 = sess.query(User).get(7)
q = sess.query(User, Address).with_parent(
u1, "addresses", from_entity=Address
def test_select_from_alias(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
u1 = sess.query(User).get(7)
a1 = aliased(Address)
q = sess.query(a1).with_parent(u1)
def test_select_from_alias_explicit_prop(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
u1 = sess.query(User).get(7)
a1 = aliased(Address)
q = sess.query(a1).with_parent(u1, "addresses")
def test_select_from_alias_from_entity(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
u1 = sess.query(User).get(7)
a1 = aliased(Address)
a2 = aliased(Address)
def test_select_from_alias_of_type(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
u1 = sess.query(User).get(7)
a1 = aliased(Address)
a2 = aliased(Address)
def test_noparent(self):
Item, User = self.classes.Item, self.classes.User
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
u1 = q.filter_by(name="jack").one()
def test_m2m(self):
Item, Keyword = self.classes.Item, self.classes.Keyword
- sess = create_session()
+ sess = fixture_session()
i1 = sess.query(Item).filter_by(id=2).one()
k = sess.query(Keyword).with_parent(i1).all()
assert [
def test_with_transient(self):
User, Order = self.classes.User, self.classes.Order
- sess = Session()
+ sess = fixture_session()
q = sess.query(User)
u1 = q.filter_by(name="jack").one()
def test_with_pending_autoflush(self):
Order, User = self.classes.Order, self.classes.User
- sess = Session()
+ sess = fixture_session()
o1 = sess.query(Order).first()
opending = Order(id=20, user_id=o1.user_id)
def test_with_pending_no_autoflush(self):
Order, User = self.classes.Order, self.classes.User
- sess = Session(autoflush=False)
+ sess = fixture_session(autoflush=False)
o1 = sess.query(Order).first()
opending = Order(user_id=o1.user_id)
"""bindparams used in the 'parent' query are unique"""
User, Address = self.classes.User, self.classes.Address
- sess = Session()
+ sess = fixture_session()
u1, u2 = sess.query(User).order_by(User.id)[0:2]
q1 = sess.query(Address).with_parent(u1, "addresses")
def test_unique_binds_or(self):
User, Address = self.classes.User, self.classes.Address
- sess = Session()
+ sess = fixture_session()
u1, u2 = sess.query(User).order_by(User.id)[0:2]
self.assert_compile(
self._fixture1()
User, Address = self.classes.User, self.classes.Address
- sess = Session()
+ sess = fixture_session()
q = sess.query(Address).filter(Address.user == User())
assert_raises_message(
self._fixture1()
User, Address = self.classes.User, self.classes.Address
- sess = Session()
+ sess = fixture_session()
q = sess.query(Address).filter(Address.user == User(id=None))
with expect_warnings("Got None for value of column "):
self._fixture1()
User, Address = self.classes.User, self.classes.Address
- sess = Session()
+ sess = fixture_session()
u1 = User()
# id is not set, so evaluates to NEVER_SET
self._fixture1()
User, Address = self.classes.User, self.classes.Address
- s = Session()
+ s = fixture_session()
q = s.query(Address).filter(
Address.special_user == User(id=None, name=None)
)
self.classes.Dingaling,
self.classes.HasDingaling,
)
- s = Session()
+ s = fixture_session()
d = Dingaling(id=1)
s.add(d)
s.flush()
self.classes.Dingaling,
self.classes.HasDingaling,
)
- s = Session()
+ s = fixture_session()
d = Dingaling()
s.add(d)
s.flush()
self.classes.Dingaling,
self.classes.HasDingaling,
)
- s = Session()
+ s = fixture_session()
d = Dingaling(data="some data")
s.add(d)
s.commit()
self._fixture1()
User, Address = self.classes.User, self.classes.Address
- sess = Session()
+ sess = fixture_session()
q = sess.query(User).with_parent(Address(user_id=None), "user")
with expect_warnings("Got None for value of column"):
self._fixture1()
User, Address = self.classes.User, self.classes.Address
- s = Session()
+ s = fixture_session()
q = s.query(User).with_parent(
Address(user_id=None, email_address=None), "special_user"
)
self._fixture1()
User, Address = self.classes.User, self.classes.Address
- s = Session()
+ s = fixture_session()
q = s.query(Address).filter(Address.user != User(id=None))
with expect_warnings("Got None for value of column"):
self.assert_compile(
self._fixture1()
User, Address = self.classes.User, self.classes.Address
- s = Session()
+ s = fixture_session()
# this one does *not* warn because we do the criteria
# without deferral
def test_options(self):
User, Order = self.classes.User, self.classes.Order
- s = create_session()
+ s = fixture_session()
def go():
result = (
def test_options_syn_of_syn(self):
User, Order = self.classes.User, self.classes.Order
- s = create_session()
+ s = fixture_session()
def go():
result = (
def test_options_syn_of_syn_string(self):
User, Order = self.classes.User, self.classes.Order
- s = create_session()
+ s = fixture_session()
def go():
result = (
[User.orders_syn, Order.items_syn],
[User.orders_syn_2, Order.items_syn],
):
- q = create_session().query(User)
+ q = fixture_session().query(User)
for path in j:
q = q.join(path)
q = q.filter_by(id=3)
("name_syn", "orders_syn"),
("name_syn", "orders_syn_2"),
):
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
u1 = q.filter_by(**{nameprop: "jack"}).one()
def test_froms_aliased_col(self):
Address, User = self.classes.Address, self.classes.User
- sess = create_session()
+ sess = fixture_session()
ua = aliased(User)
q = sess.query(ua.name_syn).join(Address, ua.id == Address.user_id)
def test_one(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
assert_raises_message(
sa.orm.exc.NoResultFound,
def test_one_or_none(self):
User, Address = self.classes.User, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
eq_(sess.query(User).filter(User.id == 99).one_or_none(), None)
def test_scalar(self):
User = self.classes.User
- sess = create_session()
+ sess = fixture_session()
eq_(sess.query(User.id).filter_by(id=7).scalar(), 7)
eq_(sess.query(User.id, User.name).filter_by(id=7).scalar(), 7)
def test_option_building(self):
User = self.classes.User
- sess = create_session(bind=testing.db, autocommit=False)
+ sess = fixture_session(autocommit=False)
q1 = sess.query(User)
eq_(q1._execution_options, dict())
def test_get_options(self):
User = self.classes.User
- sess = create_session(bind=testing.db, autocommit=False)
+ sess = fixture_session(autocommit=False)
q = sess.query(User).execution_options(foo="bar", stream_results=True)
eq_(q.get_execution_options(), dict(foo="bar", stream_results=True))
result.close()
return iter([])
- sess = create_session(
- bind=testing.db, autocommit=False, query_cls=TQuery
- )
+ sess = fixture_session(autocommit=False, query_cls=TQuery)
q1 = sess.query(User).execution_options(**execution_options)
q1.all()
return d
def test_one(self):
- s = Session()
+ s = fixture_session()
c = column("x", Boolean)
self.assert_compile(
s.query(c).filter(c),
)
def test_two(self):
- s = Session()
+ s = fixture_session()
c = column("x", Boolean)
self.assert_compile(
s.query(c).filter(c),
)
def test_three(self):
- s = Session()
+ s = fixture_session()
c = column("x", Boolean)
self.assert_compile(
s.query(c).filter(~c),
)
def test_four(self):
- s = Session()
+ s = fixture_session()
c = column("x", Boolean)
self.assert_compile(
s.query(c).filter(~c),
)
def test_five(self):
- s = Session()
+ s = fixture_session()
c = column("x", Boolean)
self.assert_compile(
s.query(c).having(c),
def test_single_entity_q(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session, expect_mapped_bind=True):
session.query(User).all()
def test_aliased_entity_q(self):
User = self.classes.User
u = aliased(User)
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session, expect_mapped_bind=True):
session.query(u).all()
def test_sql_expr_entity_q(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session, expect_mapped_bind=True):
session.query(User.id).all()
def test_sql_expr_subquery_from_entity(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session, expect_mapped_bind=True):
subq = session.query(User.id).subquery()
session.query(subq).all()
@testing.requires.boolean_col_expressions
def test_sql_expr_exists_from_entity(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session, expect_mapped_bind=True):
subq = session.query(User.id).exists()
session.query(subq).all()
def test_sql_expr_cte_from_entity(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session, expect_mapped_bind=True):
cte = session.query(User.id).cte()
subq = session.query(cte).subquery()
def test_sql_expr_bundle_cte_from_entity(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session, expect_mapped_bind=True):
cte = session.query(User.id, User.name).cte()
subq = session.query(cte).subquery()
def test_count(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session, expect_mapped_bind=True):
session.query(User).count()
def test_single_col(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session, expect_mapped_bind=True):
session.query(User.name).all()
def test_single_col_from_subq(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session, expect_mapped_bind=True):
subq = session.query(User.id, User.name).subquery()
session.query(subq.c.name).all()
def test_aggregate_fn(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session, expect_mapped_bind=True):
session.query(func.max(User.name)).all()
def test_case(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session, expect_mapped_bind=True):
session.query(case([(User.name == "x", "C")], else_="W")).all()
def test_cast(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session, expect_mapped_bind=True):
session.query(cast(User.name, String())).all()
def test_type_coerce(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session, expect_mapped_bind=True):
session.query(type_coerce(User.name, String())).all()
def test_binary_op(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session, expect_mapped_bind=True):
session.query(User.name + "x").all()
@testing.requires.boolean_col_expressions
def test_boolean_op(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session, expect_mapped_bind=True):
session.query(User.name == "x").all()
def test_bulk_update_no_sync(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session):
session.query(User).filter(User.id == 15).update(
{"name": "foob"}, synchronize_session=False
def test_bulk_delete_no_sync(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session):
session.query(User).filter(User.id == 15).delete(
synchronize_session=False
def test_bulk_update_fetch_sync(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session):
session.query(User).filter(User.id == 15).update(
{"name": "foob"}, synchronize_session="fetch"
def test_bulk_delete_fetch_sync(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session):
session.query(User).filter(User.id == 15).delete(
synchronize_session="fetch"
"score",
column_property(func.coalesce(self.tables.users.c.name, None)),
)
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session, expect_mapped_bind=True):
session.query(func.max(User.score)).scalar()
def test_plain_table(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session, expect_mapped_bind=False):
session.query(inspect(User).local_table).all()
User = self.classes.User
# TODO: this test is dumb
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session, expect_mapped_bind=False):
session.query(inspect(User).local_table).from_self().all()
def test_plain_table_count(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session, expect_mapped_bind=False):
session.query(inspect(User).local_table).count()
User = self.classes.User
table = inspect(User).local_table
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session, expect_mapped_bind=False):
session.query(table).select_from(table).all()
.scalar_subquery()
),
)
- session = Session()
+ session = fixture_session()
with self._assert_bind_args(session):
session.query(func.max(User.score)).scalar()
def _test_get(self, fixture):
User = self.classes.User
- s = Session(query_cls=fixture())
+ s = fixture_session(query_cls=fixture())
assert s.query(User).get(19) is None
u = s.query(User).get(7)
def _test_o2m_lazyload(self, fixture):
User, Address = self.classes("User", "Address")
- s = Session(query_cls=fixture())
+ s = fixture_session(query_cls=fixture())
u1 = s.query(User).filter(User.id == 7).first()
eq_(u1.addresses, [Address(id=1)])
def _test_m2o_lazyload(self, fixture):
User, Address = self.classes("User", "Address")
- s = Session(query_cls=fixture())
+ s = fixture_session(query_cls=fixture())
a1 = s.query(Address).filter(Address.id == 1).first()
eq_(a1.user, User(id=7))
def _test_expr(self, fixture):
User, Address = self.classes("User", "Address")
- s = Session(query_cls=fixture())
+ s = fixture_session(query_cls=fixture())
q = s.query(func.max(User.id).label("max"))
eq_(q.scalar(), 10)
# see #4269. not documented but already out there.
User, Address = self.classes("User", "Address")
- s = Session(query_cls=fixture())
+ s = fixture_session(query_cls=fixture())
q = Query(func.max(User.id).label("max")).with_session(s)
eq_(q.scalar(), 10)
from sqlalchemy.orm import column_property
from sqlalchemy.orm import composite
from sqlalchemy.orm import configure_mappers
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import exc as orm_exc
from sqlalchemy.orm import foreign
from sqlalchemy.orm import joinedload
from sqlalchemy.orm import remote
from sqlalchemy.orm import selectinload
from sqlalchemy.orm import Session
-from sqlalchemy.orm import sessionmaker
from sqlalchemy.orm import subqueryload
from sqlalchemy.orm import synonym
from sqlalchemy.orm.interfaces import MANYTOONE
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import in_
from sqlalchemy.testing import is_
-from sqlalchemy.testing import startswith_
from sqlalchemy.testing.assertsql import assert_engine
from sqlalchemy.testing.assertsql import CompiledSQL
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from test.orm import _fixtures
cls.classes.D,
)
- session = create_session(connection)
+ session = Session(connection)
a = A(name="a1")
b = B(name="b1")
c = C(name="c1", a_row=a)
def test_DeleteRootTable(self):
A = self.classes.A
- session = create_session()
+ session = fixture_session()
a = session.query(A).filter_by(name="a1").one()
session.delete(a)
def test_DeleteMiddleTable(self):
C = self.classes.C
- session = create_session()
+ session = fixture_session()
c = session.query(C).filter_by(name="c1").one()
session.delete(c)
def test_joinedload_doesnt_produce_bogus_event(self):
A, B = self._fixture()
- sess = Session()
+ sess = fixture_session()
b1 = B()
sess.add(b1)
def test_init_doesnt_produce_scalar_event(self):
A, B = self._fixture()
- sess = Session()
+ sess = fixture_session()
b1 = B()
sess.add(b1)
def test_init_doesnt_produce_collection_event(self):
A, B = self._fixture(uselist=True)
- sess = Session()
+ sess = fixture_session()
b1 = B()
sess.add(b1)
def test_scalar_relationship_overrides_fk(self):
A, B = self._fixture()
- sess = Session()
+ sess = fixture_session()
b1 = B()
sess.add(b1)
def test_collection_relationship_overrides_fk(self):
A, B = self._fixture(uselist=True)
- sess = Session()
+ sess = fixture_session()
b1 = B()
sess.add(b1)
def _fixture(self):
Entity = self.classes.Entity
- sess = Session()
+ sess = fixture_session()
sess.add_all(
[
Entity("/foo"),
def test_plain_join_descendants(self):
self._descendants_fixture(data=False)
Entity = self.classes.Entity
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(Entity).join(Entity.descendants, aliased=True),
"SELECT entity.path AS entity_path FROM entity JOIN entity AS "
def _test_no_warning(self, overwrites=False):
configure_mappers()
self._test_relationships()
- sess = Session()
+ sess = fixture_session()
self._setup_data(sess)
self._test_lazy_relations(sess)
self._test_join_aliasing(sess)
},
)
- sess = create_session()
+ sess = fixture_session()
b = B(id=0)
a = A(id=0, b=b)
configure_mappers()
assert A.b.property.strategy.use_get
- sess = create_session()
+ with fixture_session() as sess:
+ a1 = A()
+ sess.add(a1)
+ sess.commit()
- a1 = A()
- sess.add(a1)
- sess.flush()
- sess.close()
- a1 = sess.query(A).first()
- a1.b = B()
- sess.flush()
+ with fixture_session() as sess:
+ a1 = sess.query(A).first()
+ a1.b = B()
+ sess.commit()
def test_no_delete_PK_AtoB(self):
"""A cant be deleted without B because B would have no PK value."""
a1 = A()
a1.bs.append(B())
- sess = create_session()
- sess.add(a1)
- sess.flush()
-
- sess.delete(a1)
- try:
+ with fixture_session() as sess:
+ sess.add(a1)
sess.flush()
- assert False
- except AssertionError as e:
- startswith_(
- str(e),
+
+ sess.delete(a1)
+
+ assert_raises_message(
+ AssertionError,
"Dependency rule tried to blank-out "
"primary key column 'tableB.id' on instance ",
+ sess.flush,
)
def test_no_delete_PK_BtoA(self):
b1 = B()
a1 = A()
b1.a = a1
- sess = create_session()
- sess.add(b1)
- sess.flush()
- b1.a = None
- try:
+ with fixture_session() as sess:
+ sess.add(b1)
sess.flush()
- assert False
- except AssertionError as e:
- startswith_(
- str(e),
+ b1.a = None
+ assert_raises_message(
+ AssertionError,
"Dependency rule tried to blank-out "
"primary key column 'tableB.id' on instance ",
+ sess.flush,
)
@testing.fails_on_everything_except(
"sqlite", testing.requires.mysql_non_strict
)
- def test_nullPKsOK_BtoA(self):
+ def test_nullPKsOK_BtoA(self, metadata, connection):
A, tableA = self.classes.A, self.tables.tableA
# postgresql cant handle a nullable PK column...?
tableC = Table(
"tablec",
- tableA.metadata,
+ metadata,
Column("id", Integer, primary_key=True),
Column(
"a_id",
Integer,
- ForeignKey("tableA.id"),
+ ForeignKey(tableA.c.id),
primary_key=True,
nullable=True,
),
)
- tableC.create()
+ tableC.create(connection)
class C(fixtures.BasicEntity):
pass
c1 = C()
c1.id = 5
c1.a = None
- sess = create_session()
- sess.add(c1)
- # test that no error is raised.
- sess.flush()
+ with fixture_session() as sess:
+ sess.add(c1)
+ # test that no error is raised.
+ sess.flush()
def test_delete_cascade_BtoA(self):
"""No 'blank the PK' error when the child is to
b1 = B()
a1 = A()
b1.a = a1
- sess = create_session()
- sess.add(b1)
- sess.flush()
- sess.delete(b1)
- sess.flush()
- assert a1 not in sess
- assert b1 not in sess
- sess.expunge_all()
+ with fixture_session() as sess:
+ sess.add(b1)
+ sess.flush()
+ sess.delete(b1)
+ sess.flush()
+ assert a1 not in sess
+ assert b1 not in sess
+
sa.orm.clear_mappers()
def test_delete_cascade_AtoB(self):
a1 = A()
b1 = B()
a1.bs.append(b1)
- sess = create_session()
- sess.add(a1)
- sess.flush()
+ with fixture_session() as sess:
+ sess.add(a1)
+ sess.flush()
+
+ sess.delete(a1)
+ sess.flush()
+ assert a1 not in sess
+ assert b1 not in sess
- sess.delete(a1)
- sess.flush()
- assert a1 not in sess
- assert b1 not in sess
- sess.expunge_all()
sa.orm.clear_mappers()
def test_delete_manual_AtoB(self):
a1 = A()
b1 = B()
a1.bs.append(b1)
- sess = create_session()
- sess.add(a1)
- sess.add(b1)
- sess.flush()
+ with fixture_session() as sess:
+ sess.add(a1)
+ sess.add(b1)
+ sess.flush()
- sess.delete(a1)
- sess.delete(b1)
- sess.flush()
- assert a1 not in sess
- assert b1 not in sess
- sess.expunge_all()
+ sess.delete(a1)
+ sess.delete(b1)
+ sess.flush()
+ assert a1 not in sess
+ assert b1 not in sess
def test_delete_manual_BtoA(self):
tableB, A, B, tableA = (
b1 = B()
a1 = A()
b1.a = a1
- sess = create_session()
- sess.add(b1)
- sess.add(a1)
- sess.flush()
- sess.delete(b1)
- sess.delete(a1)
- sess.flush()
- assert a1 not in sess
- assert b1 not in sess
+ with fixture_session() as sess:
+ sess.add(b1)
+ sess.add(a1)
+ sess.flush()
+ sess.delete(b1)
+ sess.delete(a1)
+ sess.flush()
+ assert a1 not in sess
+ assert b1 not in sess
class UniqueColReferenceSwitchTest(fixtures.MappedTest):
mapper(A, table_a)
mapper(B, table_b, properties={"a": relationship(A, backref="bs")})
- session = create_session()
+ session = fixture_session()
a1, a2 = A(ident="uuid1"), A(ident="uuid2")
session.add_all([a1, a2])
a1.bs = [B(), B()]
),
)
- session = create_session()
+ session = fixture_session()
con = Container()
con.policyNum = "99"
con.policyEffDate = datetime.date.today()
mapper(TagInstance, tag_foo)
- sess = create_session()
+ sess = fixture_session()
t1 = Tag(data="some tag")
t1.foo.append(TagInstance(data="iplc_case"))
t1.foo.append(TagInstance(data="not_iplc_case"))
)
mapper(Address, addresses)
- sess = sessionmaker()()
+ sess = fixture_session()
u1 = User(name="u1", addresses=[Address(email="a1")])
sess.add(u1)
sess.commit()
def test_mapping(self):
Subscriber, Address = self.classes.Subscriber, self.classes.Address
- sess = create_session()
+ sess = fixture_session()
assert Subscriber.addresses.property.direction is ONETOMANY
assert Address.customer.property.direction is MANYTOONE
},
)
- sess = create_session()
+ sess = fixture_session()
u1 = User(name="u1")
a1 = Address(email_address="foo")
c1 = C()
a1.bs.append(b1)
a1.bs.append(c1)
- sess = create_session()
+ sess = fixture_session()
try:
sess.add(a1)
assert False
c1 = C()
a1.bs.append(b1)
a1.bs.append(c1)
- sess = create_session()
+ sess = fixture_session()
sess.add(a1)
sess.add(b1)
sess.add(c1)
c1 = C()
a1.bs.append(b1)
a1.bs.append(c1)
- sess = create_session()
+ sess = fixture_session()
sess.add(a1)
sess.add(b1)
sess.add(c1)
b1 = B()
d1 = D()
d1.a = b1
- sess = create_session()
+ sess = fixture_session()
sess.add(b1)
sess.add(d1)
assert_raises_message(
b1 = B()
d1 = D()
d1.a = b1
- sess = create_session()
+ sess = fixture_session()
assert_raises_message(
AssertionError, "doesn't handle objects of type", sess.add, d1
)
c.col1 = "cid"
a.t2s.append(b)
a.t2s.append(c)
- sess = create_session()
+ sess = fixture_session()
sess.add(a)
sess.flush()
- eq_(select(func.count("*")).select_from(t3).scalar(), 2)
+ eq_(
+ sess.connection().scalar(select(func.count("*")).select_from(t3)),
+ 2,
+ )
a.t2s.remove(c)
sess.flush()
- eq_(select(func.count("*")).select_from(t3).scalar(), 1)
+ eq_(
+ sess.connection().scalar(select(func.count("*")).select_from(t3)),
+ 1,
+ )
class CustomOperatorTest(fixtures.MappedTest, AssertsCompiledSQL):
)
mapper(B, self.tables.b)
self.assert_compile(
- Session().query(A).join(A.bs),
+ fixture_session().query(A).join(A.bs),
"SELECT a.id AS a_id, a.foo AS a_foo "
"FROM a JOIN b ON a.foo &* b.foo",
)
configure_mappers()
- sess = create_session()
+ sess = fixture_session()
a1 = A()
b1 = B(as_=[a1])
c3 = C3()
c3.data = "c1data"
c3.t2 = c2b
- sess = create_session()
+ sess = fixture_session()
sess.add(c1)
sess.add(c3)
sess.flush()
c3 = C3()
c3.data = "c1data"
c3.t2 = c2b
- sess = create_session()
+ sess = fixture_session()
sess.add_all((c1, c3))
sess.flush()
mapper(Bar, bars)
- sess = create_session()
- sess.add_all(
- (
- Foo(id=4),
- Foo(id=9),
- Bar(id=1, fid=2),
- Bar(id=2, fid=3),
- Bar(id=3, fid=6),
- Bar(id=4, fid=7),
+ with fixture_session() as sess:
+ sess.add_all(
+ (
+ Foo(id=4),
+ Foo(id=9),
+ Bar(id=1, fid=2),
+ Bar(id=2, fid=3),
+ Bar(id=3, fid=6),
+ Bar(id=4, fid=7),
+ )
)
- )
- sess.flush()
+ sess.commit()
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(Foo).filter_by(id=4).one(),
Foo(id=4, bars=[Bar(fid=2), Bar(fid=3)]),
)
mapper(Bar, bars)
- sess = create_session()
+ sess = fixture_session()
b1 = Bar(id=1, data="b1")
b2 = Bar(id=2, data="b2")
b3 = Bar(id=3, data="b3")
)
mapper(Bar, bars)
- sess = create_session()
+ sess = fixture_session()
f1 = Foo(id=1, data="f1")
f2 = Foo(id=2, data="f2")
b1 = Bar(fid1=1, data="b1")
)
mapper(T3, t3)
- sess = create_session()
+ sess = fixture_session()
sess.add(T2(data="t2", t1=T1(data="t1"), t3s=[T3(data="t3")]))
sess.flush()
sess.expunge_all()
def test_lazyload(self):
Venue = self.classes.Venue
- s = Session()
+ s = fixture_session()
v1 = s.query(Venue).filter_by(name="parent1").one()
eq_(
[d.name for d in v1.descendants],
def test_joinedload(self):
Venue = self.classes.Venue
- s = Session()
+ s = fixture_session()
def go():
v1 = (
)
is_(T1.t2s.property.direction, ONETOMANY)
eq_(T1.t2s.property.local_remote_pairs, [(t1.c.id, t2.c.t1id)])
- sess = create_session()
+ sess = fixture_session()
a1 = T1(id="number1", data="a1")
a2 = T1(id="number2", data="a2")
b1 = T2(data="b1", t1id="NuMbEr1")
},
)
- sess = create_session()
+ sess = fixture_session()
a1 = T1(id="number1", data="a1")
a2 = T1(id="number2", data="a2")
b1 = T2(data="b1", t1id="NuMbEr1")
)
mapper(T2, t2)
- sess = create_session()
+ sess = fixture_session()
a1 = T1(id="NuMbeR1", data="a1")
a2 = T1(id="NuMbeR2", data="a2")
b1 = T2(data="b1", t1id="number1")
},
)
- sess = create_session()
+ sess = fixture_session()
a1 = T1(id="NuMbeR1", data="a1")
a2 = T1(id="NuMbeR2", data="a2")
b1 = T2(data="b1", t1id="number1")
def test_render_join(self):
A = self.classes.A
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(A).join(A.d),
"SELECT a.id AS a_id, a.name AS a_name, a.b_id AS a_b_id "
def test_render_joinedload(self):
A = self.classes.A
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(A).options(joinedload(A.d)),
"SELECT a.id AS a_id, a.name AS a_name, a.b_id AS a_b_id, "
def test_render_lazyload(self):
A = self.classes.A
- sess = Session()
+ sess = fixture_session()
a1 = sess.query(A).filter(A.name == "a1").first()
def go():
def test_join(self):
A, D = self.classes.A, self.classes.D
- sess = Session()
+ sess = fixture_session()
for a, d in sess.query(A, D).outerjoin(A.d):
eq_(self.mapping[a.name], d.name if d is not None else None)
def test_joinedload(self):
A = self.classes.A
- sess = Session()
+ sess = fixture_session()
for a in sess.query(A).options(joinedload(A.d)):
d = a.d
def test_lazyload(self):
A = self.classes.A
- sess = Session()
+ sess = fixture_session()
for a in sess.query(A):
d = a.d
run_deletes = None
def _test_attribute(self, obj, attrname, newvalue):
- sess = Session()
+ sess = fixture_session()
sess.add(obj)
oldvalue = getattr(obj, attrname)
sess.commit()
},
)
- s = Session()
+ s = fixture_session()
a1 = Address(email_address="a1")
u1 = User(name="u1", addresses=[a1])
users,
properties=dict(addresses=relationship(Address, lazy="raise")),
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
result = [None]
def go():
mapper(Address, addresses)
mapper(User, users, properties=dict(addresses=relationship(Address)))
- q = create_session().query(User)
+ q = fixture_session().query(User)
result = [None]
def go():
users,
properties=dict(addresses=relationship(Address, lazy="raise")),
)
- q = create_session().query(User).options(sa.orm.lazyload("addresses"))
+ q = fixture_session().query(User).options(sa.orm.lazyload("addresses"))
result = [None]
def go():
)
mapper(Address, addresses, properties={"user": relationship(User)})
mapper(User, users)
- s = Session()
+ s = fixture_session()
a1 = (
s.query(Address)
.filter_by(id=1)
)
mapper(Address, addresses, properties={"user": relationship(User)})
mapper(User, users)
- s = Session()
+ s = fixture_session()
a1 = (
s.query(Address)
.filter_by(id=1)
},
)
mapper(User, users)
- s = Session()
+ s = fixture_session()
u1 = s.query(User).first() # noqa
a1 = (
s.query(Address)
properties=dict(addresses=relationship(Address, backref="user")),
)
q = (
- create_session()
+ fixture_session()
.query(User, Address)
.join(Address, User.id == Address.user_id)
)
properties=dict(addresses=relationship(Address, backref="user")),
)
q = (
- create_session()
+ fixture_session()
.query(User, Address)
.join(Address, User.id == Address.user_id)
)
)
mapper(Address, addresses_table)
- session = create_session()
+ session = fixture_session()
session.query(User).filter(
User.addresses.any(Address.email_address == "ed@foo.bar")
def test_query_join(self):
A, B = self.classes("A", "B")
- s = Session()
+ s = fixture_session()
with assert_engine(testing.db) as asserter_:
rows = s.query(A.id, B.id).join(A.bs).order_by(A.id, B.id).all()
def test_eager_join(self):
A, B = self.classes("A", "B")
- s = Session()
+ s = fixture_session()
with assert_engine(testing.db) as asserter_:
a2 = (
def test_exists(self):
A, B = self.classes("A", "B")
- s = Session()
+ s = fixture_session()
with assert_engine(testing.db) as asserter_:
eq_(set(id_ for id_, in s.query(A.id).filter(A.bs.any())), {1, 2})
def test_eager_selectin(self):
A, B = self.classes("A", "B")
- s = Session()
+ s = fixture_session()
with assert_engine(testing.db) as asserter_:
a2 = (
def test_basic(self):
table2, table1 = self.tables.table2, self.tables.table1
- Session = scoped_session(sa.orm.sessionmaker())
+ Session = scoped_session(sa.orm.sessionmaker(testing.db))
class CustomQuery(query.Query):
pass
from sqlalchemy.testing import AssertsCompiledSQL
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
mapper(Subset, selectable, primary_key=[selectable.c.x])
self.assert_compile(
- Session().query(Subset),
+ fixture_session().query(Subset),
"SELECT anon_1.x AS anon_1_x, anon_1.y AS anon_1_y, "
"anon_1.z AS anon_1_z FROM (SELECT x, y, z) AS anon_1",
use_default_dialect=True,
from sqlalchemy import testing
from sqlalchemy.orm import aliased
from sqlalchemy.orm import clear_mappers
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import defaultload
from sqlalchemy.orm import defer
from sqlalchemy.orm import deferred
from sqlalchemy.testing.assertsql import AllOf
from sqlalchemy.testing.assertsql import assert_engine
from sqlalchemy.testing.assertsql import CompiledSQL
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from test.orm import _fixtures
)
},
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User).options(selectinload(User.addresses))
def go():
- sess = create_session()
+ sess = fixture_session()
u = aliased(User)
for i in range(3):
def go():
- sess = create_session()
+ sess = fixture_session()
u = aliased(User)
for i in range(3):
def go():
- sess = create_session()
+ sess = fixture_session()
u = aliased(User)
)
},
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User).options(selectinload(User.addresses))
)
},
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User).options(selectinload(User.addresses))
properties={"addresses": relationship(Address, lazy="dynamic")},
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
# previously this would not raise, but would emit
# the query needlessly and put the result nowhere.
),
)
- q = create_session().query(Item).order_by(Item.id)
+ q = fixture_session().query(Item).order_by(Item.id)
def go():
eq_(self.static.item_keyword_result, q.all())
),
)
- q = create_session().query(Item).order_by(Item.id)
+ q = fixture_session().query(Item).order_by(Item.id)
def go():
eq_(
),
)
- q = create_session().query(Item).order_by(Item.id)
+ q = fixture_session().query(Item).order_by(Item.id)
def go():
ka = aliased(Keyword)
)
},
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
eq_(
[
User(id=7, addresses=[Address(id=1)]),
)
},
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
eq_(
[
User(id=7, addresses=[Address(id=1)]),
),
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
result = (
q.filter(User.id == Address.user_id)
.order_by(Address.email_address)
)
),
)
- sess = create_session()
+ sess = fixture_session()
eq_(
[
User(id=7, addresses=[Address(id=1)]),
def _do_query_tests(self, opts, count):
Order, User = self.classes.Order, self.classes.User
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
self.static.user_item_keyword_result[2:3],
)
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(User)
.options(*opts)
)
is_(sa.orm.class_mapper(Address).get_property("user").lazy, "selectin")
- sess = create_session()
+ sess = fixture_session()
eq_(
self.static.user_address_result,
sess.query(User).order_by(User.id).all(),
)
is_(sa.orm.class_mapper(Address).get_property("user").lazy, "selectin")
- sess = create_session()
+ sess = fixture_session()
eq_(
self.static.user_address_result,
sess.query(User).order_by(User.id).all(),
User, Address, Order, Item = self.classes(
"User", "Address", "Order", "Item"
)
- q = create_session().query(User).order_by(User.id)
+ q = fixture_session().query(User).order_by(User.id)
def items(*ids):
if no_items:
},
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
result = q.order_by(User.id).limit(2).offset(1).all()
)
),
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
def go():
result = q.filter(users.c.id == 7).all()
)
),
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
def go():
result = q.filter(users.c.id == 10).all()
user=relationship(mapper(User, users), lazy="selectin")
),
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(Address)
def go():
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
q = sess.query(Order).filter(Order.id.in_([4, 5])).order_by(Order.id)
o4, o5 = q.all()
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(Order).filter(Order.id.in_([4, 5])).order_by(Order.id)
o4, o5 = q.all()
)
),
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
result = q.filter(users.c.id == 10).all()
u1 = result[0]
},
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
def go():
eq_(
properties={"order": relationship(Order, uselist=False)},
)
mapper(Order, orders)
- s = create_session()
+ s = fixture_session()
assert_raises(
sa.exc.SAWarning,
s.query(User).options(selectinload(User.order)).all,
)
mapper(Dingaling, self.tables.dingalings)
- sess = Session(autoflush=False)
+ sess = fixture_session(autoflush=False)
return User, Address, Dingaling, sess
def _collection_to_collection_fixture(self):
)
mapper(Item, self.tables.items)
- sess = Session(autoflush=False)
+ sess = fixture_session(autoflush=False)
return User, Order, Item, sess
def _eager_config_fixture(self):
properties={"addresses": relationship(Address, lazy="selectin")},
)
mapper(Address, self.tables.addresses)
- sess = Session(autoflush=False)
+ sess = fixture_session(autoflush=False)
return User, Address, sess
def _deferred_config_fixture(self):
},
)
mapper(Address, self.tables.addresses)
- sess = Session(autoflush=False)
+ sess = fixture_session(autoflush=False)
return User, Address, sess
def test_runs_query_on_refresh(self):
)
mapper(B, b)
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
Paperwork(description="tps report #2"),
]
e2.paperwork = [Paperwork(description="tps report #3")]
- sess = create_session(connection)
+ sess = Session(connection)
sess.add_all([e1, e2])
sess.flush()
def test_correct_select_nofrom(self):
- sess = create_session()
+ sess = fixture_session()
# use Person.paperwork here just to give the least
# amount of context
q = (
)
def test_correct_select_existingfrom(self):
- sess = create_session()
+ sess = fixture_session()
# use Person.paperwork here just to give the least
# amount of context
q = (
def test_correct_select_with_polymorphic_no_alias(self):
# test #3106
- sess = create_session()
+ sess = fixture_session()
wp = with_polymorphic(Person, [Engineer])
q = (
def test_correct_select_with_polymorphic_alias(self):
# test #3106
- sess = create_session()
+ sess = fixture_session()
wp = with_polymorphic(Person, [Engineer], aliased=True)
q = (
def test_correct_select_with_polymorphic_flat_alias(self):
# test #3106
- sess = create_session()
+ sess = fixture_session()
wp = with_polymorphic(Person, [Engineer], aliased=True, flat=True)
q = (
Company, Programmer, Manager, GolfSwing, Language = self.classes(
"Company", "Programmer", "Manager", "GolfSwing", "Language"
)
- sess = Session()
+ sess = fixture_session()
company = (
sess.query(Company)
.filter(Company.id == 1)
Company, Programmer, Manager, GolfSwing, Language = self.classes(
"Company", "Programmer", "Manager", "GolfSwing", "Language"
)
- sess = Session()
+ sess = fixture_session()
company = (
sess.query(Company)
.filter(Company.id == 2)
Company, Programmer, Manager, GolfSwing, Language = self.classes(
"Company", "Programmer", "Manager", "GolfSwing", "Language"
)
- sess = Session()
+ sess = fixture_session()
rows = (
sess.query(Company)
.options(
def test_load_o2m(self):
A, B = self.classes("A", "B")
- session = Session()
+ session = fixture_session()
def go():
q = (
def test_load_m2o(self):
A, B = self.classes("A", "B")
- session = Session()
+ session = fixture_session()
def go():
q = session.query(B).options(selectinload(B.a)).order_by(B.id)
def test_odd_number_chunks(self):
A, B = self.classes("A", "B")
- session = Session()
+ session = fixture_session()
def go():
with mock.patch(
import random
- session = Session()
+ session = fixture_session()
yield_per = random.randint(8, 105)
offset = random.randint(0, 19)
def test_dont_emit_for_redundant_m2o(self):
A, B = self.classes("A", "B")
- session = Session()
+ session = fixture_session()
def go():
with mock.patch(
@classmethod
def insert_data(cls, connection):
c1 = cls._fixture()
- sess = create_session(connection)
+ sess = Session(connection)
sess.add(c1)
sess.flush()
)
def test_chained_selectin_subclass(self):
- s = Session()
+ s = fixture_session()
q = s.query(Company).options(
selectinload(Company.employees.of_type(Engineer))
.selectinload(Engineer.machines)
)
},
)
- sess = create_session()
+ sess = fixture_session()
n1 = Node(data="n1")
n1.append(Node(data="n11"))
n1.append(Node(data="n12"))
)
},
)
- sess = create_session()
+ sess = fixture_session()
n1 = Node(data="n1")
n1.append(Node(data="n11"))
n1.append(Node(data="n12"))
"data": deferred(nodes.c.data),
},
)
- sess = create_session()
+ sess = fixture_session()
n1 = Node(data="n1")
n1.append(Node(data="n11"))
n1.append(Node(data="n12"))
nodes,
properties={"children": relationship(Node, order_by=nodes.c.id)},
)
- sess = create_session()
+ sess = fixture_session()
n1 = Node(data="n1")
n1.append(Node(data="n11"))
n1.append(Node(data="n12"))
nodes,
properties={"children": relationship(Node, lazy="selectin")},
)
- sess = create_session()
+ sess = fixture_session()
n1 = Node(data="n1")
n1.append(Node(data="n11"))
n1.append(Node(data="n12"))
attr1 = Foo.foo.of_type(r)
attr2 = r.foo
- s = Session()
+ s = fixture_session()
q = (
s.query(Foo)
.filter(Foo.id == 2)
def test_o2m(self):
A, A2, B, C1o2m, C2o2m = self.classes("A", "A2", "B", "C1o2m", "C2o2m")
- s = Session()
+ s = fixture_session()
# A -J-> B -L-> C1
# A -J-> B -S-> C2
def test_m2o(self):
A, A2, B, C1m2o, C2m2o = self.classes("A", "A2", "B", "C1m2o", "C2m2o")
- s = Session()
+ s = fixture_session()
# A -J-> B -L-> C1
# A -J-> B -S-> C2
def test_load(self):
(EmployerUser,) = self.classes("EmployerUser")
- s = Session()
+ s = fixture_session()
q = s.query(EmployerUser)
def test_missing_rec(self):
A, B = self.classes("A", "B")
- s = Session()
+ s = fixture_session()
eq_(
s.query(A).options(selectinload(A.b)).order_by(A.id).all(),
[
def test_use_join_parent_criteria(self):
A, B = self.classes("A", "B")
- s = Session()
+ s = fixture_session()
q = (
s.query(A)
.filter(A.id.in_([1, 3]))
def test_use_join_parent_criteria_degrade_on_defer(self):
A, B = self.classes("A", "B")
- s = Session()
+ s = fixture_session()
q = (
s.query(A)
.filter(A.id.in_([1, 3]))
def test_use_join(self):
A, B = self.classes("A", "B")
- s = Session()
+ s = fixture_session()
q = s.query(A).options(selectinload(A.b)).order_by(A.id)
results = self.assert_sql_execution(
testing.db,
def test_use_join_omit_join_false(self):
A, B = self.classes("A", "B")
- s = Session()
+ s = fixture_session()
q = s.query(A).options(selectinload(A.b_no_omit_join)).order_by(A.id)
results = self.assert_sql_execution(
testing.db,
def test_use_join_parent_degrade_on_defer(self):
A, B = self.classes("A", "B")
- s = Session()
+ s = fixture_session()
q = s.query(A).options(defer(A.b_id), selectinload(A.b)).order_by(A.id)
results = self.assert_sql_execution(
testing.db,
GenericParent, ParentA, ParentB, ChildA, ChildB = self.classes(
"GenericParent", "ParentA", "ParentB", "ChildA", "ChildB"
)
- session = Session()
+ session = fixture_session()
parent_types = with_polymorphic(GenericParent, [ParentA, ParentB])
# the cache spoil did not use full=True which kept the lead
# entities around.
- sess = Session()
+ sess = fixture_session()
foo_polymorphic = with_polymorphic(Foo, [SubFoo], aliased=True)
credit_adjustment_load = selectinload(
from sqlalchemy.testing import is_true
from sqlalchemy.testing import mock
from sqlalchemy.testing import pickleable
-from sqlalchemy.testing.fixtures import create_session
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from sqlalchemy.testing.util import gc_collect
mapper(User, users)
- s1 = Session()
+ s1 = fixture_session()
u1 = User()
s1.add(u1)
- s2 = Session()
+ s2 = fixture_session()
u2 = User()
s2.add(u2)
mapper(User, users)
- s1 = Session()
+ s1 = fixture_session()
u1 = User()
s1.add(u1)
- s2 = Session()
+ s2 = fixture_session()
u2 = User()
s2.add(u2)
users, User = self.tables.users, self.classes.User
mapper(User, users)
- sess = create_session()
+ sess = fixture_session(autoflush=False)
sess.add(User(name="test"))
sess.flush()
users, User = self.tables.users, self.classes.User
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="test")
sess.add(u1)
sess.commit()
users, User = self.tables.users, self.classes.User
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
u1 = User(id=1, name="test")
sess.add(u1)
sess.commit()
users, User = self.tables.users, self.classes.User
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
u1 = User(id=1, name="test")
sess.add(u1)
assert_raises_message(
users, User = self.tables.users, self.classes.User
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
u1 = User(id=1, name="test")
sess.add(u1)
sess.commit()
__prefer_requires__ = ("independent_connections",)
def test_info(self):
- s = Session()
+ s = fixture_session()
eq_(s.info, {})
maker = sessionmaker(info={"global": True, "s1": 5})
User, users = self.classes.User, self.tables.users
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
u = User()
u.name = "ed"
mapper(User, users)
- sess = sessionmaker()()
+ sess = fixture_session()
u1 = User(name="u1")
sess.add(u1)
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
sess.add(u1)
sess.commit()
User, users = self.classes.User, self.tables.users
mapper(User, users)
- with create_session(autocommit=False, autoflush=True) as sess:
+ with fixture_session(autocommit=False, autoflush=True) as sess:
u = User()
u.name = "ed"
sess.add(u)
self.tables.users,
)
- s = create_session()
+ s = fixture_session()
mapper(
User,
users,
assert user in s
assert user not in s.dirty
- s2 = create_session()
+ s2 = fixture_session()
assert_raises_message(
sa.exc.InvalidRequestError,
"is already attached to session",
users = self.tables.users
mapper(User, users)
- s1 = Session()
- s2 = Session()
+ s1 = fixture_session()
+ s2 = fixture_session()
u1 = User(id=1, name="u1")
make_transient_to_detached(u1) # shorthand for actually persisting it
mapper(User, users)
- with create_session() as s:
+ with fixture_session() as s:
s.execute(users.delete())
u1 = User(name="ed")
s.add(u1)
)
mapper(Address, addresses)
- session = Session()
+ session = fixture_session()
@event.listens_for(session, "after_flush")
def load_collections(session, flush_context):
users, User = self.tables.users, pickleable.User
mapper(User, users)
- sess1 = create_session()
- sess2 = create_session()
+ sess1 = fixture_session()
+ sess2 = fixture_session()
u1 = User(name="u1")
sess1.add(u1)
assert_raises_message(
mapper(User, users)
Session = sessionmaker()
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
sess.add(u1)
def test_no_double_save(self):
users = self.tables.users
- sess = create_session()
+ sess = fixture_session()
class Foo(object):
def __init__(self):
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
sess.add_all([User(name="u1"), User(name="u2"), User(name="u3")])
sess.commit()
users, User = self.tables.users, self.classes.User
m = mapper(User, users)
- s = Session()
+ s = fixture_session()
@event.listens_for(m, "after_update")
def e(mapper, conn, target):
users, User = self.tables.users, self.classes.User
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
sess.add(User(name="x"))
sess.commit()
users, User = self.tables.users, self.classes.User
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="x")
sess.add(u1)
users, User = self.tables.users, self.classes.User
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
sess.add(User(name="x"))
sess.commit()
"""
User, Address = self.classes("User", "Address")
- sess = create_session(autoflush=True, autocommit=False)
+ sess = fixture_session(autoflush=True, autocommit=False)
u = User(name="ed", addresses=[Address(email_address="foo")])
sess.add(u)
eq_(
def test_deferred_expression_obj_was_gced(self):
User, Address = self.classes("User", "Address")
- sess = create_session(autoflush=True, autocommit=False)
+ sess = fixture_session(
+ autoflush=True, autocommit=False, expire_on_commit=False
+ )
u = User(name="ed", addresses=[Address(email_address="foo")])
sess.add(u)
User, Address = self.classes("User", "Address")
- sess = create_session(autoflush=True, autocommit=False)
+ sess = fixture_session(
+ autoflush=True, autocommit=False, expire_on_commit=False
+ )
u = User(name="ed", addresses=[Address(email_address="foo")])
sess.add(u)
sess.commit()
def test_deferred_expression_obj_was_never_flushed(self):
User, Address = self.classes("User", "Address")
- sess = create_session(autoflush=True, autocommit=False)
+ sess = fixture_session(autoflush=True, autocommit=False)
u = User(name="ed", addresses=[Address(email_address="foo")])
assert_raises_message(
def test_deferred_expression_unflushed_obj_became_detached_unexpired(self):
User, Address = self.classes("User", "Address")
- sess = create_session(autoflush=True, autocommit=False)
+ sess = fixture_session(autoflush=True, autocommit=False)
u = User(name="ed", addresses=[Address(email_address="foo")])
q = sess.query(Address).filter(Address.user == u)
def test_deferred_expression_unflushed_obj_became_detached_expired(self):
User, Address = self.classes("User", "Address")
- sess = create_session(autoflush=True, autocommit=False)
+ sess = fixture_session(autoflush=True, autocommit=False)
u = User(name="ed", addresses=[Address(email_address="foo")])
q = sess.query(Address).filter(Address.user == u)
def test_deferred_expr_unflushed_obj_became_detached_expired_by_key(self):
User, Address = self.classes("User", "Address")
- sess = create_session(autoflush=True, autocommit=False)
+ sess = fixture_session(autoflush=True, autocommit=False)
u = User(name="ed", addresses=[Address(email_address="foo")])
q = sess.query(Address).filter(Address.user == u)
def test_deferred_expression_expired_obj_became_detached_expired(self):
User, Address = self.classes("User", "Address")
- sess = create_session(
+ sess = fixture_session(
autoflush=True, autocommit=False, expire_on_commit=True
)
u = User(name="ed", addresses=[Address(email_address="foo")])
mapper(Address, addresses)
mapper(User, users, properties={"addresses": relationship(Address)})
- sess = create_session(autocommit=False, autoflush=True)
+ sess = fixture_session(autocommit=False, autoflush=True)
u = sess.query(User).get(8)
newad = Address(email_address="a new address")
u.addresses.append(newad)
},
)
- session = create_session()
+ session = fixture_session()
u = session.query(User).filter_by(id=7).one()
# get everything to load in both directions
User = self.classes.User
u1 = User()
u1.name = "ed"
- sess = Session()
+ sess = fixture_session()
sess.add(u1)
sess.flush()
return sess, u1
u1.name = "ed"
self._assert_modified(u1)
self._assert_no_cycle(u1)
- sess = Session()
+ sess = fixture_session()
sess.add(u1)
self._assert_cycle(u1)
sess.flush()
def test_move_persistent_clean(self):
sess, u1 = self._persistent_fixture()
sess.close()
- s2 = Session()
+ s2 = fixture_session()
s2.add(u1)
self._assert_no_cycle(u1)
self._assert_not_modified(u1)
self._assert_modified(u1)
sess.close()
self._assert_no_cycle(u1)
- s2 = Session()
+ s2 = fixture_session()
s2.add(u1)
self._assert_cycle(u1)
self._assert_modified(u1)
del sess
gc_collect()
self._assert_cycle(u1)
- s2 = Session()
+ s2 = fixture_session()
s2.add(u1)
self._assert_cycle(u1)
self._assert_modified(u1)
users, User = self.tables.users, self.classes.User
- s = create_session()
+ s = fixture_session()
mapper(User, users)
s.add(User(name="ed"))
def test_weakref_pickled(self):
users, User = self.tables.users, pickleable.User
- s = create_session()
+ s = fixture_session()
mapper(User, users)
s.add(User(name="ed"))
self.classes.User,
)
- s = sessionmaker()()
+ s = fixture_session()
mapper(
User,
users,
self.classes.User,
)
- s = sessionmaker()()
+ s = fixture_session()
mapper(
User,
users,
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
sess.add(u1)
# can't add u1 to Session,
# already belongs to u2
- s2 = Session()
+ s2 = fixture_session()
assert_raises_message(
sa.exc.InvalidRequestError,
r".*is already attached to session",
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="u1")
sess.add(u1)
def test_is_modified(self):
User, Address = self._default_mapping_fixture()
- s = create_session()
+ s = fixture_session()
# save user
u = User(name="fred")
User, Address = self._default_mapping_fixture()
- s = Session()
+ s = fixture_session()
u = User(name="fred", addresses=[Address(email_address="foo")])
s.add(u)
s.commit()
def test_is_modified_syn(self):
User, users = self.classes.User, self.tables.users
- s = sessionmaker()()
+ s = fixture_session()
mapper(User, users, properties={"uname": sa.orm.synonym("name")})
u = User(uname="fred")
)
def raises_(method, *args, **kw):
- x_raises_(create_session(), method, *args, **kw)
+ x_raises_(fixture_session(), method, *args, **kw)
for name in [
"__contains__",
self._map_it(OK)
- s = create_session()
+ s = fixture_session()
s.add(OK())
x_raises_(s, "flush", (user_arg,))
def raises_(method, *args, **kw):
watchdog.add(method)
- callable_ = getattr(Session(), method)
+ callable_ = getattr(
+ Session(),
+ method,
+ )
if is_class:
assert_raises(
sa.orm.exc.UnmappedClassError, callable_, *args, **kw
self._map_it(Mapped)
m1 = Mapped()
- s = create_session()
+ s = fixture_session()
with mock.patch.object(s, "_validate_persistent"):
assert_raises_message(
User = self.classes.User
Address = self.classes.Address
- s = Session()
+ s = fixture_session()
event.listen(User, "after_insert", fn)
u1 = User(name="u1", addresses=[Address(name="a1")])
from sqlalchemy.orm import backref
from sqlalchemy.orm import clear_mappers
from sqlalchemy.orm import close_all_sessions
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import deferred
from sqlalchemy.orm import joinedload
from sqlalchemy.orm import mapper
from sqlalchemy.testing import is_true
from sqlalchemy.testing.assertsql import CompiledSQL
from sqlalchemy.testing.entities import ComparableEntity
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from test.orm import _fixtures
)
},
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User).options(subqueryload(User.addresses))
},
)
query_cache = {}
- sess = create_session()
+ sess = fixture_session()
u1 = (
sess.query(User)
User, Dingaling, Address = self.user_dingaling_fixture()
for i in range(3):
- sess = create_session()
+ sess = fixture_session()
u = aliased(User)
User, Dingaling, Address = self.user_dingaling_fixture()
for i in range(3):
- sess = create_session()
+ sess = fixture_session()
u = aliased(User)
User, Dingaling, Address = self.user_dingaling_fixture()
for i in range(3):
- sess = create_session()
+ sess = fixture_session()
u = aliased(User)
q = sess.query(u).options(
)
},
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User).options(subqueryload(User.addresses))
)
},
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User).options(subqueryload(User.addresses))
properties={"addresses": relationship(Address, lazy="dynamic")},
)
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
# previously this would not raise, but would emit
# the query needlessly and put the result nowhere.
),
)
- q = create_session().query(Item).order_by(Item.id)
+ q = fixture_session().query(Item).order_by(Item.id)
def go():
eq_(self.static.item_keyword_result, q.all())
),
)
- q = create_session().query(Item).order_by(Item.id)
+ q = fixture_session().query(Item).order_by(Item.id)
def go():
eq_(
),
)
- q = create_session().query(Item).order_by(Item.id)
+ q = fixture_session().query(Item).order_by(Item.id)
def go():
ka = aliased(Keyword)
)
},
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
eq_(
[
User(id=7, addresses=[Address(id=1)]),
)
},
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
eq_(
[
User(id=7, addresses=[Address(id=1)]),
),
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
result = (
q.filter(User.id == Address.user_id)
.order_by(Address.email_address)
)
),
)
- sess = create_session()
+ sess = fixture_session()
eq_(
[
User(id=7, addresses=[Address(id=1)]),
def _do_query_tests(self, opts, count):
Order, User = self.classes.Order, self.classes.User
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
self.static.user_item_keyword_result[2:3],
)
- sess = create_session()
+ sess = fixture_session()
eq_(
sess.query(User)
.options(*opts)
)
is_(sa.orm.class_mapper(Address).get_property("user").lazy, "subquery")
- sess = create_session()
+ sess = fixture_session()
eq_(
self.static.user_address_result,
sess.query(User).order_by(User.id).all(),
)
is_(sa.orm.class_mapper(Address).get_property("user").lazy, "subquery")
- sess = create_session()
+ sess = fixture_session()
eq_(
self.static.user_address_result,
sess.query(User).order_by(User.id).all(),
properties=dict(addresses=relationship(Address, lazy="subquery")),
)
- sess = create_session()
+ sess = fixture_session()
self.assert_compile(
sess.query(User, literal_column("1")),
User, Address, Order, Item = self.classes(
"User", "Address", "Order", "Item"
)
- q = create_session().query(User).order_by(User.id)
+ q = fixture_session().query(User).order_by(User.id)
def items(*ids):
if no_items:
},
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(User)
result = q.order_by(User.id).limit(2).offset(1).all()
},
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
eq_(
[
User(id=7, addresses=[Address(id=1)]),
)
),
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
def go():
result = q.filter(users.c.id == 7).all()
user=relationship(mapper(User, users), lazy="subquery")
),
)
- sess = create_session()
+ sess = fixture_session()
q = sess.query(Address)
def go():
},
)
- q = create_session().query(User)
+ q = fixture_session().query(User)
def go():
eq_(
properties={"order": relationship(Order, uselist=False)},
)
mapper(Order, orders)
- s = create_session()
+ s = fixture_session()
assert_raises(
sa.exc.SAWarning,
s.query(User).options(subqueryload(User.order)).all,
)
mapper(Dingaling, self.tables.dingalings)
- sess = Session(autoflush=False)
+ sess = fixture_session(autoflush=False)
return User, Address, Dingaling, sess
def _collection_to_collection_fixture(self):
)
mapper(Item, self.tables.items)
- sess = Session(autoflush=False)
+ sess = fixture_session(autoflush=False)
return User, Order, Item, sess
def _eager_config_fixture(self):
properties={"addresses": relationship(Address, lazy="subquery")},
)
mapper(Address, self.tables.addresses)
- sess = Session(autoflush=False)
+ sess = fixture_session(autoflush=False)
return User, Address, sess
def _deferred_config_fixture(self):
},
)
mapper(Address, self.tables.addresses)
- sess = Session(autoflush=False)
+ sess = fixture_session(autoflush=False)
return User, Address, sess
def test_runs_query_on_refresh(self):
)
mapper(B, b)
- sess = create_session()
+ sess = fixture_session()
def go():
eq_(
),
]
e2.paperwork = [Paperwork(description="tps report #3")]
- sess = create_session(connection)
+ sess = Session(connection)
sess.add_all([e1, e2])
sess.flush()
def test_correct_subquery_nofrom(self):
- sess = create_session()
+ sess = fixture_session()
# use Person.paperwork here just to give the least
# amount of context
q = (
)
def test_correct_subquery_existingfrom(self):
- sess = create_session()
+ sess = fixture_session()
# use Person.paperwork here just to give the least
# amount of context
q = (
)
def test_correct_subquery_multilevel(self):
- sess = create_session()
+ sess = fixture_session()
# use Person.paperwork here just to give the least
# amount of context
q = (
def test_correct_subquery_with_polymorphic_no_alias(self):
# test #3106
- sess = create_session()
+ sess = fixture_session()
wp = with_polymorphic(Person, [Engineer])
q = (
def test_correct_subquery_with_polymorphic_alias(self):
# test #3106
- sess = create_session()
+ sess = fixture_session()
wp = with_polymorphic(Person, [Engineer], aliased=True)
q = (
def test_correct_subquery_with_polymorphic_flat_alias(self):
# test #3106
- sess = create_session()
+ sess = fixture_session()
wp = with_polymorphic(Person, [Engineer], aliased=True, flat=True)
q = (
@classmethod
def insert_data(cls, connection):
c1 = cls._fixture()
- sess = create_session(connection)
+ sess = Session(connection)
sess.add(c1)
sess.flush()
)
def test_chained_subq_subclass(self):
- s = Session()
+ s = fixture_session()
q = s.query(Company).options(
subqueryload(Company.employees.of_type(Engineer))
.subqueryload(Engineer.machines)
)
},
)
- sess = create_session()
+ sess = fixture_session()
n1 = Node(data="n1")
n1.append(Node(data="n11"))
n1.append(Node(data="n12"))
)
},
)
- sess = create_session()
+ sess = fixture_session()
n1 = Node(data="n1")
n1.append(Node(data="n11"))
n1.append(Node(data="n12"))
"data": deferred(nodes.c.data),
},
)
- sess = create_session()
+ sess = fixture_session()
n1 = Node(data="n1")
n1.append(Node(data="n11"))
n1.append(Node(data="n12"))
nodes,
properties={"children": relationship(Node, order_by=nodes.c.id)},
)
- sess = create_session()
+ sess = fixture_session()
n1 = Node(data="n1")
n1.append(Node(data="n11"))
n1.append(Node(data="n12"))
nodes,
properties={"children": relationship(Node, lazy="subquery")},
)
- sess = create_session()
+ sess = fixture_session()
n1 = Node(data="n1")
n1.append(Node(data="n11"))
n1.append(Node(data="n12"))
mapper(SubT2, None, inherits=T2, polymorphic_identity="subt2")
# testing a particular endless loop condition in eager load setup
- create_session().query(SubT).all()
+ fixture_session().query(SubT).all()
class CyclicalInheritingEagerTestTwo(
def test_from_subclass(self):
Director = self.classes.Director
- s = create_session()
+ s = fixture_session()
with self.sql_execution_asserter(testing.db) as asserter:
s.query(Director).options(subqueryload("*")).all()
Movie(title="Manhattan", credits=[Credit(), Credit()]),
Movie(title="Sweet and Lowdown", credits=[Credit()]),
]
- sess = create_session(connection)
+ sess = Session(connection)
sess.add_all([d])
sess.flush()
# Director.photos
expect_distinct = director_strategy_level in (True, None)
- s = create_session(testing.db)
+ s = fixture_session()
with self.sql_execution_asserter(testing.db) as asserter:
result = (
Movie = self.classes.Movie
Credit = self.classes.Credit
- s = create_session(testing.db)
+ s = fixture_session()
with self.sql_execution_asserter(testing.db) as asserter:
result = (
Parent = self.classes.Parent
Child = self.classes.Child
- s = Session()
+ s = fixture_session()
# here we have
# Parent->subqueryload->Child->joinedload->parent->noload->children.
attr1 = Foo.foo.of_type(r)
attr2 = r.foo
- s = Session()
+ s = fixture_session()
q = (
s.query(Foo)
.filter(Foo.id == 2)
def test_o2m(self):
A, A2, B, C1o2m, C2o2m = self.classes("A", "A2", "B", "C1o2m", "C2o2m")
- s = Session()
+ s = fixture_session()
# A -J-> B -L-> C1
# A -J-> B -S-> C2
def test_m2o(self):
A, A2, B, C1m2o, C2m2o = self.classes("A", "A2", "B", "C1m2o", "C2m2o")
- s = Session()
+ s = fixture_session()
# A -J-> B -L-> C1
# A -J-> B -S-> C2
def test_subq_w_from_self_one(self):
A, B, C = self.classes("A", "B", "C")
- s = Session()
+ s = fixture_session()
cache = {}
A, B, C = self.classes("A", "B", "C")
- s = Session()
+ s = fixture_session()
cache = {}
for i in range(3):
from sqlalchemy import testing
from sqlalchemy.orm import attributes
from sqlalchemy.orm import class_mapper
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import exc as orm_exc
from sqlalchemy.orm import mapper
from sqlalchemy.orm import sync
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
def _fixture(self):
A, B = self.classes.A, self.classes.B
- session = create_session()
+ session = fixture_session()
uowcommit = self._get_test_uow(session)
a_mapper = class_mapper(A)
b_mapper = class_mapper(B)
from sqlalchemy import text
from sqlalchemy.future import Engine
from sqlalchemy.orm import attributes
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import exc as orm_exc
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import is_
from sqlalchemy.testing import is_not
from sqlalchemy.testing import mock
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.util import gc_collect
from test.orm._fixtures import FixtureTest
def test_no_close_transaction_on_flush(self):
User, users = self.classes.User, self.tables.users
- c = testing.db.connect()
- try:
+ with testing.db.connect() as c:
mapper(User, users)
- s = create_session(bind=c)
+ s = Session(bind=c)
s.begin()
tran = s._legacy_transaction()
s.add(User(name="first"))
s.flush()
assert s._legacy_transaction() is tran
tran.close()
- finally:
- c.close()
@engines.close_open_connections
def test_subtransaction_on_external_subtrans(self):
mapper(User, users)
conn = testing.db.connect()
trans = conn.begin()
- sess = create_session(bind=conn, autocommit=False, autoflush=True)
+ sess = Session(bind=conn, autocommit=False, autoflush=True)
sess.begin(subtransactions=True)
u = User(name="ed")
sess.add(u)
mapper(User, users)
conn = testing.db.connect()
trans = conn.begin()
- sess = create_session(bind=conn, autocommit=False, autoflush=True)
+ sess = Session(bind=conn, autocommit=False, autoflush=True)
u = User(name="ed")
sess.add(u)
sess.flush()
try:
conn = testing.db.connect()
trans = conn.begin()
- sess = create_session(bind=conn, autocommit=False, autoflush=True)
+ sess = Session(bind=conn, autocommit=False, autoflush=True)
u1 = User(name="u1")
sess.add(u1)
sess.flush()
conn = engine.connect()
conn.begin()
- sess = create_session(bind=conn, autocommit=False, autoflush=True)
+ sess = Session(bind=conn, autocommit=False, autoflush=True)
u = User(name="ed")
sess.add(u)
sess.flush()
conn = engine.connect()
conn.begin()
- sess = create_session(bind=conn, autocommit=False, autoflush=True)
+ sess = Session(bind=conn, autocommit=False, autoflush=True)
u = User(name="ed")
sess.add(u)
sess.flush()
with engine.connect() as conn:
conn.begin()
- sess = create_session(bind=conn, autocommit=False, autoflush=True)
+ sess = Session(bind=conn, autocommit=False, autoflush=True)
u1 = User(name="u1")
sess.add(u1)
sess.flush()
mapper(User, users)
- session = create_session(bind=testing.db)
+ session = fixture_session()
session.begin()
session.begin_nested()
u1 = User(name="u1")
mapper(User, users)
- session = create_session(bind=testing.db)
+ session = fixture_session()
session.begin()
u1 = User(name="u1")
session.add(u1)
def test_heavy_nesting(self):
users = self.tables.users
- session = create_session(bind=testing.db)
+ session = fixture_session()
session.begin()
session.connection().execute(users.insert().values(name="user1"))
session.begin(subtransactions=True)
users = self.tables.users
engine = Engine._future_facade(testing.db)
- session = create_session(engine, autocommit=False)
+ session = Session(engine, autocommit=False)
session.begin()
session.connection().execute(users.insert().values(name="user1"))
mapper(User, users)
- s1 = create_session(bind=testing.db, autocommit=False)
- s2 = create_session(bind=testing.db, autocommit=False)
+ s1 = fixture_session(autocommit=False)
+ s2 = fixture_session(autocommit=False)
u1 = User(name="u1")
s1.add(u1)
s1.flush()
mapper(Address, addresses)
engine2 = engines.testing_engine()
- sess = create_session(autocommit=True, autoflush=False, twophase=True)
+ sess = fixture_session(autocommit=True, autoflush=False, twophase=True)
sess.bind_mapper(User, testing.db)
sess.bind_mapper(Address, engine2)
sess.begin()
sess.commit()
sess.close()
engine2.dispose()
- eq_(select(func.count("*")).select_from(users).scalar(), 1)
- eq_(select(func.count("*")).select_from(addresses).scalar(), 1)
+ with testing.db.connect() as conn:
+ eq_(conn.scalar(select(func.count("*")).select_from(users)), 1)
+ eq_(conn.scalar(select(func.count("*")).select_from(addresses)), 1)
@testing.requires.independent_connections
def test_invalidate(self):
User, users = self.classes.User, self.tables.users
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
u = User(name="u1")
sess.add(u)
sess.flush()
User, users = self.classes.User, self.tables.users
mapper(User, users)
- sess = create_session(autocommit=False, autoflush=True)
+ sess = fixture_session(autocommit=False, autoflush=True)
sess.begin(subtransactions=True)
u = User(name="u1")
sess.add(u)
User, users = self.classes.User, self.tables.users
mapper(User, users)
- sess = create_session()
+ sess = fixture_session()
sess.begin()
u = User(name="u1")
User, users = self.classes.User, self.tables.users
mapper(User, users)
- sess = create_session(autocommit=False)
+ sess = fixture_session(autocommit=False)
u = User(name="u1")
sess.add(u)
sess.flush()
User, users = self.classes.User, self.tables.users
mapper(User, users)
- sess = create_session(testing.db, autocommit=False, future=True)
+ sess = fixture_session(autocommit=False, future=True)
u = User(name="u1")
sess.add(u)
sess.flush()
mapper(User, users)
- sess = create_session(autocommit=True)
+ sess = fixture_session(autocommit=True)
sess.begin()
sess.begin_nested()
mapper(User, users)
- sess = create_session(autocommit=True)
+ sess = fixture_session(autocommit=True)
sess.begin()
sess.begin_nested()
mapper(User, users)
- sess = create_session(autocommit=False)
+ sess = fixture_session(autocommit=False)
sess.begin_nested()
users, User = self.tables.users, self.classes.User
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
to_flush = [User(name="ed"), User(name="jack"), User(name="wendy")]
users, User = self.tables.users, self.classes.User
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
@event.listens_for(sess, "after_flush_postexec")
def add_another_user(session, ctx):
users, User = self.tables.users, self.classes.User
mapper(User, users)
- sess = create_session(autocommit=True)
+ sess = fixture_session(autocommit=True)
sess.begin()
sess.begin(subtransactions=True)
sess.add(User(name="u1"))
sess.close()
def test_no_sql_during_commit(self):
- sess = create_session(bind=testing.db, autocommit=False)
+ sess = fixture_session(autocommit=False)
@event.listens_for(sess, "after_commit")
def go(session):
)
def test_no_sql_during_prepare(self):
- sess = create_session(bind=testing.db, autocommit=False, twophase=True)
+ sess = fixture_session(autocommit=False, twophase=True)
sess.prepare()
)
def test_no_sql_during_rollback(self):
- sess = create_session(bind=testing.db, autocommit=False)
+ sess = fixture_session(autocommit=False)
sess.connection()
eq_(session.is_active, True)
def test_no_prepare_wo_twophase(self):
- sess = create_session(bind=testing.db, autocommit=False)
+ sess = fixture_session(autocommit=False)
assert_raises_message(
sa_exc.InvalidRequestError,
)
def test_closed_status_check(self):
- sess = create_session()
+ sess = fixture_session()
trans = sess.begin()
trans.rollback()
assert_raises_message(
)
def test_deactive_status_check(self):
- sess = create_session()
+ sess = fixture_session()
trans = sess.begin()
trans2 = sess.begin(subtransactions=True)
trans2.rollback()
)
def test_deactive_status_check_w_exception(self):
- sess = create_session()
+ sess = fixture_session()
trans = sess.begin()
trans2 = sess.begin(subtransactions=True)
try:
users, User = self.tables.users, self.classes.User
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
u1 = User(id=1, name="u1")
sess.add(u1)
sess.commit()
users, User = self.tables.users, self.classes.User
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
u1 = User(id=1, name="u1")
sess.add(u1)
sess.commit()
User, users = self.classes.User, self.tables.users
mapper(User, users)
- session = create_session(autocommit=False)
+ session = fixture_session(autocommit=False)
session.add(User(name="ed"))
session._legacy_transaction().commit()
User, users = self.classes.User, self.tables.users
mapper(User, users)
- session = create_session(testing.db, autocommit=False, future=True)
+ session = fixture_session(autocommit=False, future=True)
session.add(User(name="ed"))
session._legacy_transaction().commit()
class _LocalFixture(FixtureTest):
run_setup_mappers = "once"
run_inserts = None
- session = sessionmaker()
@classmethod
def setup_mappers(cls):
def test_attrs_on_rollback(self):
User = self.classes.User
- sess = self.session()
+ sess = fixture_session()
u1 = sess.query(User).get(7)
u1.name = "ed"
sess.rollback()
def test_commit_persistent(self):
User = self.classes.User
- sess = self.session()
+ sess = fixture_session()
u1 = sess.query(User).get(7)
u1.name = "ed"
sess.flush()
def test_concurrent_commit_persistent(self):
User = self.classes.User
- s1 = self.session()
+ s1 = fixture_session()
u1 = s1.query(User).get(7)
u1.name = "ed"
s1.commit()
- s2 = self.session()
+ s2 = fixture_session()
u2 = s2.query(User).get(7)
assert u2.name == "ed"
u2.name = "will"
def test_expunge_pending_on_rollback(self):
User = self.classes.User
- sess = self.session()
+ sess = fixture_session()
u2 = User(name="newuser")
sess.add(u2)
assert u2 in sess
def test_trans_pending_cleared_on_commit(self):
User = self.classes.User
- sess = self.session()
+ sess = fixture_session()
u2 = User(name="newuser")
sess.add(u2)
assert u2 in sess
def test_update_deleted_on_rollback(self):
User = self.classes.User
- s = self.session()
+ s = fixture_session()
u1 = User(name="ed")
s.add(u1)
s.commit()
def test_gced_delete_on_rollback(self):
User, users = self.classes.User, self.tables.users
- s = self.session()
+ s = fixture_session()
u1 = User(name="ed")
s.add(u1)
s.commit()
def test_trans_deleted_cleared_on_rollback(self):
User = self.classes.User
- s = self.session()
+ s = fixture_session()
u1 = User(name="ed")
s.add(u1)
s.commit()
def test_update_deleted_on_rollback_cascade(self):
User, Address = self.classes.User, self.classes.Address
- s = self.session()
+ s = fixture_session()
u1 = User(name="ed", addresses=[Address(email_address="foo")])
s.add(u1)
s.commit()
def test_update_deleted_on_rollback_orphan(self):
User, Address = self.classes.User, self.classes.Address
- s = self.session()
+ s = fixture_session()
u1 = User(name="ed", addresses=[Address(email_address="foo")])
s.add(u1)
s.commit()
def test_commit_pending(self):
User = self.classes.User
- sess = self.session()
+ sess = fixture_session()
u1 = User(name="newuser")
sess.add(u1)
sess.flush()
def test_concurrent_commit_pending(self):
User = self.classes.User
- s1 = self.session()
+ s1 = fixture_session()
u1 = User(name="edward")
s1.add(u1)
s1.commit()
- s2 = self.session()
+ s2 = fixture_session()
u2 = s2.query(User).filter(User.name == "edward").one()
u2.name = "will"
s2.commit()
@testing.requires.two_phase_transactions
def test_rollback_on_prepare(self):
User = self.classes.User
- s = self.session(twophase=True)
+ s = fixture_session(twophase=True)
u = User(name="ed")
s.add(u)
def test_pk_violation(self):
User, Address = self.classes.User, self.classes.Address
- s = self.session()
+ s = fixture_session()
a1 = Address(email_address="foo")
u1 = User(id=1, name="ed", addresses=[a1])
@testing.requires.savepoints
def test_pk_violation_with_savepoint(self):
User, Address = self.classes.User, self.classes.Address
- s = self.session()
+ s = fixture_session()
a1 = Address(email_address="foo")
u1 = User(id=1, name="ed", addresses=[a1])
s.add(u1)
@testing.requires.savepoints
def test_savepoint_rollback(self):
User = self.classes.User
- s = self.session()
+ s = fixture_session()
u1 = User(name="ed")
u2 = User(name="jack")
s.add_all([u1, u2])
@testing.requires.savepoints
def test_savepoint_delete(self):
User = self.classes.User
- s = self.session()
+ s = fixture_session()
u1 = User(name="ed")
s.add(u1)
s.commit()
@testing.requires.savepoints
def test_savepoint_commit(self):
User = self.classes.User
- s = self.session()
+ s = fixture_session()
u1 = User(name="ed")
u2 = User(name="jack")
s.add_all([u1, u2])
@testing.requires.savepoints
def test_savepoint_rollback_collections(self):
User, Address = self.classes.User, self.classes.Address
- s = self.session()
+ s = fixture_session()
u1 = User(name="ed", addresses=[Address(email_address="foo")])
s.add(u1)
s.commit()
@testing.requires.savepoints
def test_savepoint_commit_collections(self):
User, Address = self.classes.User, self.classes.Address
- s = self.session()
+ s = fixture_session()
u1 = User(name="ed", addresses=[Address(email_address="foo")])
s.add(u1)
s.commit()
@testing.requires.savepoints
def test_expunge_pending_on_rollback(self):
User = self.classes.User
- sess = self.session()
+ sess = fixture_session()
sess.begin_nested()
u2 = User(name="newuser")
@testing.requires.savepoints
def test_update_deleted_on_rollback(self):
User = self.classes.User
- s = self.session()
+ s = fixture_session()
u1 = User(name="ed")
s.add(u1)
s.commit()
@testing.requires.savepoints_w_release
def test_savepoint_lost_still_runs(self):
User = self.classes.User
- s = self.session(bind=self.bind)
+ s = fixture_session()
trans = s.begin_nested()
s.connection()
u1 = User(name="ed")
def test_no_expire_on_commit(self):
User, users = self.classes.User, self.tables.users
- sess = sessionmaker(expire_on_commit=False)()
+ sess = fixture_session(expire_on_commit=False)
u1 = User(name="ed")
sess.add(u1)
sess.commit()
__backend__ = True
def test_begin_nested_requires_trans(self):
- sess = create_session(autocommit=True)
+ sess = fixture_session(autocommit=True)
assert_raises(sa_exc.InvalidRequestError, sess.begin_nested)
def test_begin_preflush(self):
User = self.classes.User
- sess = create_session(autocommit=True)
+ sess = fixture_session(autocommit=True)
u1 = User(name="ed")
sess.add(u1)
def test_accounting_commit_fails_add(self):
User = self.classes.User
- sess = create_session(autocommit=True)
+ sess = fixture_session(autocommit=True)
fail = False
def test_accounting_commit_fails_delete(self):
User = self.classes.User
- sess = create_session(autocommit=True)
+ sess = fixture_session(autocommit=True)
fail = False
when autocommit=True/expire_on_commit=True."""
User = self.classes.User
- sess = create_session(autocommit=True, expire_on_commit=True)
+ sess = fixture_session(autocommit=True, expire_on_commit=True)
u1 = User(id=1, name="ed")
sess.add(u1)
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
def go():
with sess.begin_nested():
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
with sess.begin():
sess.add(User(name="u1"))
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
def go():
with sess.begin():
mapper(User, users)
- session = sessionmaker()()
+ session = fixture_session()
u1, u2, u3 = User(name="u1"), User(name="u2"), User(name="u3")
u1 = User(name="u1")
- s = Session()
+ s = fixture_session()
s.add(u1)
s.flush()
del u1
u1 = User(name="u1")
u2 = User(name="u2")
- s = Session()
+ s = fixture_session()
s.add_all([u1, u2])
s.commit()
u1 = User(name="u1")
- s = Session()
+ s = fixture_session()
s.add(u1)
s.commit()
u2 = User(name="u2")
u3 = User(name="u3")
- s = Session()
+ s = fixture_session()
s.add_all([u1, u2, u3])
s.commit()
u1 = User(name="u1")
- s = Session()
+ s = fixture_session()
s.add(u1)
s.commit()
from sqlalchemy import testing
from sqlalchemy.inspection import inspect
from sqlalchemy.orm import column_property
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import exc as orm_exc
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing.assertsql import AllOf
from sqlalchemy.testing.assertsql import CompiledSQL
from sqlalchemy.testing.assertsql import Conditional
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from sqlalchemy.util import OrderedDict
),
)
- session = create_session(autocommit=False)
+ session = fixture_session(autocommit=False)
u = User(name="u1")
a = Address(email_address="u1@e")
t1 = Test(id=1, txt=txt)
self.assert_(t1.txt == txt)
- session = create_session(autocommit=False)
+ session = fixture_session(autocommit=False)
session.add(t1)
session.commit()
t1 = Test(txt=txt)
t1.t2s.append(Test2())
t1.t2s.append(Test2())
- session = create_session(autocommit=False)
+ session = fixture_session(autocommit=False, expire_on_commit=False)
session.add(t1)
session.commit()
session.close()
- session = create_session()
+ session = fixture_session()
t1 = session.query(Test).filter_by(id=t1.id).one()
assert len(t1.t2s) == 2
b1 = B()
a1.t2s.append(b1)
- session = create_session()
+ session = fixture_session()
session.add(a1)
session.flush()
session.expunge_all()
a1 = A(b=5)
b1 = B(e=7)
- session = create_session()
+ session = fixture_session()
session.add_all((a1, b1))
session.flush()
session.expunge_all()
mapper(Foo, t1)
- s = create_session()
+ s = fixture_session()
f1 = Foo(data=data)
s.add(f1)
e = Entry(name="entry1", value="this is entry 1", multi_rev=2)
- session = create_session()
+ session = fixture_session()
session.add(e)
session.flush()
session.expunge_all()
e = Entry(pk_col_1="pk1", pk_col_2="pk1_related", data="im the data")
- session = create_session()
+ session = fixture_session()
session.add(e)
session.flush()
data="some more data",
)
- session = create_session()
+ session = fixture_session()
session.add(e)
session.flush()
ps = PersonSite(site="asdf")
p.sites.append(ps)
- session = create_session()
+ session = fixture_session()
session.add(p)
session.flush()
- p_count = (
- select(func.count("*"))
- .where(people.c.person == "im the key")
- .scalar()
+ conn = session.connection()
+ p_count = conn.scalar(
+ select(func.count("*")).where(people.c.person == "im the key")
)
eq_(p_count, 1)
eq_(
- select(func.count("*"))
- .where(peoplesites.c.person == "im the key")
- .scalar(),
+ conn.scalar(
+ select(func.count("*")).where(
+ peoplesites.c.person == "im the key"
+ )
+ ),
1,
)
u = User(name="test")
- session = create_session()
+ session = fixture_session()
session.add(u)
session.flush()
u = User(name="test")
- session = create_session()
+ session = fixture_session()
session.add(u)
session.flush()
u = User(name="test", counter=sa.select(5).scalar_subquery())
- session = create_session()
+ session = fixture_session()
session.add(u)
session.flush()
PkDefault = self.classes.PkDefault
pk = PkDefault(id=literal(5) + 10, data="some data")
- session = Session()
+ session = fixture_session()
session.add(pk)
session.flush()
bool,
None == sa.false(), # noqa
)
- s = create_session()
+ s = fixture_session()
hb = HasBoolean(value=None)
s.add(hb)
s.flush()
u = User(id=5, name="test", counter=Thing(3))
- session = create_session()
+ session = fixture_session()
session.add(u)
session.flush()
)
},
)
- session = create_session()
- mc = MyClass()
- mc.children.append(MyOtherClass())
- mc.children.append(MyOtherClass())
- mc.children.append(MyOtherClass())
- mc.children.append(MyOtherClass())
+ with fixture_session() as session:
+ mc = MyClass()
+ mc.children.append(MyOtherClass())
+ mc.children.append(MyOtherClass())
+ mc.children.append(MyOtherClass())
+ mc.children.append(MyOtherClass())
- session.add(mc)
- session.flush()
- session.expunge_all()
+ session.add(mc)
+ session.flush()
+ session.expunge_all()
- eq_(select(func.count("*")).select_from(myothertable).scalar(), 4)
- mc = session.query(MyClass).get(mc.id)
- session.delete(mc)
- session.flush()
+ conn = session.connection()
+
+ eq_(
+ conn.scalar(select(func.count("*")).select_from(myothertable)),
+ 4,
+ )
+ mc = session.query(MyClass).get(mc.id)
+ session.delete(mc)
+ session.flush()
- eq_(select(func.count("*")).select_from(mytable).scalar(), 0)
- eq_(select(func.count("*")).select_from(myothertable).scalar(), 0)
+ eq_(conn.scalar(select(func.count("*")).select_from(mytable)), 0)
+ eq_(
+ conn.scalar(select(func.count("*")).select_from(myothertable)),
+ 0,
+ )
@testing.emits_warning(
r".*'passive_deletes' is normally configured on one-to-many"
)
mapper(MyClass, mytable)
- session = Session()
+ session = fixture_session()
mc = MyClass()
mco = MyOtherClass()
mco.myclass = mc
},
)
- session = create_session()
- mc = MyClass()
- mc.children.append(MyOtherClass())
- mc.children.append(MyOtherClass())
- mc.children.append(MyOtherClass())
- mc.children.append(MyOtherClass())
- session.add(mc)
- session.flush()
- session.expunge_all()
+ with fixture_session(expire_on_commit=False) as session:
+ mc = MyClass()
+ mc.children.append(MyOtherClass())
+ mc.children.append(MyOtherClass())
+ mc.children.append(MyOtherClass())
+ mc.children.append(MyOtherClass())
+ session.add(mc)
+ session.commit()
- eq_(select(func.count("*")).select_from(myothertable).scalar(), 4)
- mc = session.query(MyClass).get(mc.id)
- session.delete(mc)
- assert_raises(sa.exc.DBAPIError, session.flush)
+ with fixture_session(expire_on_commit=False) as session:
+ conn = session.connection()
+ eq_(
+ conn.scalar(select(func.count("*")).select_from(myothertable)),
+ 4,
+ )
+ mc = session.query(MyClass).get(mc.id)
+ session.delete(mc)
+ assert_raises(sa.exc.DBAPIError, session.flush)
def test_extra_passive_2(self):
myothertable, MyClass, MyOtherClass, mytable = (
},
)
- session = create_session()
- mc = MyClass()
- mc.children.append(MyOtherClass())
- session.add(mc)
- session.flush()
- session.expunge_all()
+ with fixture_session(expire_on_commit=False) as session:
+ mc = MyClass()
+ mc.children.append(MyOtherClass())
+ session.add(mc)
+ session.commit()
- eq_(select(func.count("*")).select_from(myothertable).scalar(), 1)
+ with fixture_session(autoflush=False) as session:
+ conn = session.connection()
+ eq_(
+ conn.scalar(select(func.count("*")).select_from(myothertable)),
+ 1,
+ )
- mc = session.query(MyClass).get(mc.id)
- session.delete(mc)
- mc.children[0].data = "some new data"
- assert_raises(sa.exc.DBAPIError, session.flush)
+ mc = session.query(MyClass).get(mc.id)
+ session.delete(mc)
+ mc.children[0].data = "some new data"
+ assert_raises(sa.exc.DBAPIError, session.flush)
def test_extra_passive_obj_removed_o2m(self):
myothertable, MyClass, MyOtherClass, mytable = (
},
)
- session = create_session()
+ session = fixture_session()
mc = MyClass()
moc1 = MyOtherClass()
moc2 = MyOtherClass()
)
},
)
- session = Session()
+ session = fixture_session()
mc = MyClass()
session.add(mc)
session.commit()
pass
mapper(Book, book)
- sess = create_session()
+ with fixture_session() as sess:
- b1 = Book(book_id="abc", title="def")
- sess.add(b1)
- sess.flush()
+ b1 = Book(book_id="abc", title="def")
+ sess.add(b1)
+ sess.flush()
- b1.title = "ghi"
- sess.flush()
- sess.close()
- eq_(sess.query(Book).first(), Book(book_id="abc", title="ghi"))
+ b1.title = "ghi"
+ sess.flush()
+ sess.commit()
+
+ with fixture_session() as sess:
+ eq_(sess.query(Book).first(), Book(book_id="abc", title="ghi"))
class DefaultTest(fixtures.MappedTest):
h4 = Hoho()
h5 = Hoho(foober="im the new foober")
- session = create_session(autocommit=False)
+ session = fixture_session(autocommit=False, expire_on_commit=False)
session.add_all((h1, h2, h3, h4, h5))
session.commit()
mapper(Secondary, self.tables.secondary_table)
h1 = Hoho()
- session = create_session()
+ session = fixture_session()
session.add(h1)
if testing.db.dialect.implicit_returning:
mapper(Hoho, default_t)
h1 = Hoho(hoho="15", counter=15)
- session = create_session()
+ session = fixture_session()
session.add(h1)
session.flush()
mapper(Hoho, default_t)
h1 = Hoho()
- session = create_session()
+ session = fixture_session()
session.add(h1)
session.flush()
s1 = Secondary(data="s1")
h1.secondaries.append(s1)
- session = create_session()
+ session = fixture_session()
session.add(h1)
session.flush()
session.expunge_all()
)
mapper(SubData, subdata, inherits=Data)
- sess = create_session()
+ sess = fixture_session()
sd1 = SubData(a="hello", b="there", c="hi")
sess.add(sd1)
sess.flush()
def _test(self, expect_expiry, expect_deferred_load=False):
Data = self.classes.Data
- sess = create_session()
+ with fixture_session() as sess:
- d1 = Data(a="hello", b="there")
- sess.add(d1)
- sess.flush()
+ d1 = Data(a="hello", b="there")
+ sess.add(d1)
+ sess.flush()
- eq_(d1.aplusb, "hello there")
-
- d1.b = "bye"
- sess.flush()
- if expect_expiry:
- eq_(d1.aplusb, "hello bye")
- else:
eq_(d1.aplusb, "hello there")
- d1.b = "foobar"
- d1.aplusb = "im setting this explicitly"
- sess.flush()
- eq_(d1.aplusb, "im setting this explicitly")
+ d1.b = "bye"
+ sess.flush()
+ if expect_expiry:
+ eq_(d1.aplusb, "hello bye")
+ else:
+ eq_(d1.aplusb, "hello there")
+
+ d1.b = "foobar"
+ d1.aplusb = "im setting this explicitly"
+ sess.flush()
+ eq_(d1.aplusb, "im setting this explicitly")
+
+ sess.commit()
# test issue #3984.
# NOTE: if we only expire_all() here rather than start with brand new
# "undeferred". this is questionable but not as severe as the never-
# loaded attribute being loaded during an unexpire.
- sess.close()
- d1 = sess.query(Data).first()
+ with fixture_session() as sess:
+ d1 = sess.query(Data).first()
- d1.b = "so long"
- sess.flush()
- sess.expire_all()
- eq_(d1.b, "so long")
- if expect_deferred_load:
- eq_("aplusb" in d1.__dict__, False)
- else:
- eq_("aplusb" in d1.__dict__, True)
- eq_(d1.aplusb, "hello so long")
+ d1.b = "so long"
+ sess.flush()
+ sess.expire_all()
+ eq_(d1.b, "so long")
+ if expect_deferred_load:
+ eq_("aplusb" in d1.__dict__, False)
+ else:
+ eq_("aplusb" in d1.__dict__, True)
+ eq_(d1.aplusb, "hello so long")
class OneToManyTest(_fixtures.FixtureTest):
a2 = Address(email_address="lala@test.org")
u.addresses.append(a2)
- session = create_session()
+ session = fixture_session()
session.add(u)
session.flush()
- user_rows = users.select(users.c.id.in_([u.id])).execute().fetchall()
+ conn = session.connection()
+ user_rows = conn.execute(
+ users.select(users.c.id.in_([u.id]))
+ ).fetchall()
eq_(list(user_rows[0]), [u.id, "one2manytester"])
- address_rows = (
+ address_rows = conn.execute(
addresses.select(
addresses.c.id.in_([a.id, a2.id]),
order_by=[addresses.c.email_address],
)
- .execute()
- .fetchall()
- )
+ ).fetchall()
eq_(list(address_rows[0]), [a2.id, u.id, "lala@test.org"])
eq_(list(address_rows[1]), [a.id, u.id, "one2many@test.org"])
session.flush()
- address_rows = (
- addresses.select(addresses.c.id == addressid).execute().fetchall()
- )
+ address_rows = conn.execute(
+ addresses.select(addresses.c.id == addressid)
+ ).fetchall()
eq_(list(address_rows[0]), [addressid, userid, "somethingnew@foo.com"])
self.assert_(u.id == userid and a2.id == addressid)
a3 = Address(email_address="emailaddress3")
- session = create_session()
+ session = fixture_session()
session.add_all((u1, u2, a3))
session.flush()
a = Address(email_address="address1")
u1.addresses.append(a)
- session = create_session()
+ session = fixture_session()
session.add_all((u1, u2))
session.flush()
a = Address(email_address="address1")
u1.addresses.append(a)
- session = create_session()
+ session = fixture_session()
session.add_all((u1, u2))
session.flush()
a = Address(email_address="myonlyaddress@foo.com")
u.address = a
- session = create_session()
+ session = fixture_session()
session.add(u)
session.flush()
u = User(name="one2onetester")
u.address = Address(email_address="myonlyaddress@foo.com")
- session = create_session()
+ session = fixture_session()
session.add(u)
session.flush()
u = User(name="test")
Address(email_address="testaddress", user=u)
- session = create_session()
+ session = fixture_session()
session.add(u)
session.flush()
session.delete(u)
u.boston_addresses.append(a)
u.newyork_addresses.append(b)
- session = create_session()
+ session = fixture_session()
session.add(u)
session.flush()
u = User(name="savetester")
u2 = User(name="savetester2")
- session = create_session()
- session.add_all((u, u2))
- session.flush()
+ with fixture_session() as session:
+ session.add_all((u, u2))
+ session.flush()
- # assert the first one retrieves the same from the identity map
- nu = session.query(m).get(u.id)
- assert u is nu
+ # assert the first one retrieves the same from the identity map
+ nu = session.query(m).get(u.id)
+ assert u is nu
- # clear out the identity map, so next get forces a SELECT
- session.expunge_all()
+ # clear out the identity map, so next get forces a SELECT
+ session.expunge_all()
- # check it again, identity should be different but ids the same
- nu = session.query(m).get(u.id)
- assert u is not nu and u.id == nu.id and nu.name == "savetester"
+ # check it again, identity should be different but ids the same
+ nu = session.query(m).get(u.id)
+ assert u is not nu and u.id == nu.id and nu.name == "savetester"
+
+ session.commit()
# change first users name and save
- session = create_session()
- session.add(u)
- u.name = "modifiedname"
- assert u in session.dirty
- session.flush()
+ with fixture_session() as session:
+ session.add(u)
+ u.name = "modifiedname"
+ assert u in session.dirty
+ session.flush()
- # select both
- userlist = (
- session.query(User)
- .filter(users.c.id.in_([u.id, u2.id]))
- .order_by(users.c.name)
- .all()
- )
+ # select both
+ userlist = (
+ session.query(User)
+ .filter(users.c.id.in_([u.id, u2.id]))
+ .order_by(users.c.name)
+ .all()
+ )
- eq_(u.id, userlist[0].id)
- eq_(userlist[0].name, "modifiedname")
- eq_(u2.id, userlist[1].id)
- eq_(userlist[1].name, "savetester2")
+ eq_(u.id, userlist[0].id)
+ eq_(userlist[0].name, "modifiedname")
+ eq_(u2.id, userlist[1].id)
+ eq_(userlist[1].name, "savetester2")
def test_synonym(self):
users = self.tables.users
u = SUser(syn_name="some name")
eq_(u.syn_name, "User:some name:User")
- session = create_session()
+ session = fixture_session()
session.add(u)
session.flush()
session.expunge_all()
u.addresses.append(Address(email_address="u1@e3"))
u.addresses.append(Address(email_address="u1@e4"))
- session = create_session()
+ session = fixture_session()
session.add(u)
session.flush()
session.expunge_all()
au = AddressUser(name="u", email_address="u@e")
- session = create_session()
+ session = fixture_session()
session.add(au)
session.flush()
session.expunge_all()
# don't set deferred attribute, commit session
o = Order(id=42)
- session = create_session(autocommit=False)
+ session = fixture_session(autocommit=False)
session.add(o)
session.commit()
mapper(User, users)
u = User(name="")
- session = create_session()
+ session = fixture_session()
session.add(u)
session.flush()
session.expunge_all()
)
u = User(name="multitester", email="multi@test.org")
- session = create_session()
+ session = fixture_session()
session.add(u)
session.flush()
session.expunge_all()
u = session.query(User).get(id_)
assert u.name == "multitester"
- user_rows = (
- users.select(users.c.id.in_([u.foo_id])).execute().fetchall()
- )
+ conn = session.connection()
+ user_rows = conn.execute(
+ users.select(users.c.id.in_([u.foo_id]))
+ ).fetchall()
eq_(list(user_rows[0]), [u.foo_id, "multitester"])
- address_rows = (
- addresses.select(addresses.c.id.in_([u.id])).execute().fetchall()
- )
+ address_rows = conn.execute(
+ addresses.select(addresses.c.id.in_([u.id]))
+ ).fetchall()
eq_(list(address_rows[0]), [u.id, u.foo_id, "multi@test.org"])
u.email = "lala@hey.com"
u.name = "imnew"
session.flush()
- user_rows = (
- users.select(users.c.id.in_([u.foo_id])).execute().fetchall()
- )
+ user_rows = conn.execute(
+ users.select(users.c.id.in_([u.foo_id]))
+ ).fetchall()
eq_(list(user_rows[0]), [u.foo_id, "imnew"])
- address_rows = (
- addresses.select(addresses.c.id.in_([u.id])).execute().fetchall()
- )
+ address_rows = conn.execute(
+ addresses.select(addresses.c.id.in_([u.id]))
+ ).fetchall()
eq_(list(address_rows[0]), [u.id, u.foo_id, "lala@hey.com"])
session.expunge_all()
u = User(name="u1")
u.addresses.append(Address(email_address="u1@e1"))
u.addresses.append(Address(email_address="u1@e2"))
- session = create_session()
+ session = fixture_session()
session.add(u)
session.flush()
session.expunge_all()
u = session.query(User).get(u.id)
session.delete(u)
session.flush()
- eq_(select(func.count("*")).select_from(users).scalar(), 0)
- eq_(select(func.count("*")).select_from(addresses).scalar(), 0)
+ eq_(
+ session.connection().scalar(
+ select(func.count("*")).select_from(users)
+ ),
+ 0,
+ )
+ eq_(
+ session.connection().scalar(
+ select(func.count("*")).select_from(addresses)
+ ),
+ 0,
+ )
def test_batch_mode(self):
"""The 'batch=False' flag on mapper()"""
u1 = User(name="user1")
u2 = User(name="user2")
- session = create_session()
+ session = fixture_session()
session.add_all((u1, u2))
session.flush()
),
)
- session = create_session()
+ session = fixture_session()
data = [
{"name": "thesub", "email_address": "bar@foo.com"},
),
)
- result = (
- sa.select(users, addresses)
- .where(
+ conn = session.connection()
+ result = conn.execute(
+ sa.select(users, addresses).where(
sa.and_(
users.c.id == addresses.c.user_id, addresses.c.id == a.id
),
)
- .execute()
)
eq_(
list(result.first()),
u1 = User(name="user1")
a1.user = u1
- session = create_session()
+ session = fixture_session()
session.add(a1)
session.flush()
session.expunge_all()
u1 = User(name="user1")
a1.user = u1
- session = create_session()
+ session = fixture_session()
session.add_all((a1, a2))
session.flush()
session.expunge_all()
u2 = User(name="user2")
a1.user = u1
- session = create_session()
+ session = fixture_session()
session.add_all((a1, u1, u2))
session.flush()
session.expunge_all()
a1 = Address(email_address="e1")
a1.user = u1
- session = create_session()
+ session = fixture_session()
session.add(u1)
session.flush()
session.expunge_all()
},
]
- session = create_session()
+ session = fixture_session()
objects = []
_keywords = dict([(k.name, k) for k in session.query(Keyword)])
i.keywords.append(k1)
i.keywords.append(k2)
- session = create_session()
+ session = fixture_session()
session.add(i)
session.flush()
- eq_(select(func.count("*")).select_from(item_keywords).scalar(), 2)
+ conn = session.connection()
+ eq_(conn.scalar(select(func.count("*")).select_from(item_keywords)), 2)
i.keywords = []
session.flush()
- eq_(select(func.count("*")).select_from(item_keywords).scalar(), 0)
+ eq_(conn.scalar(select(func.count("*")).select_from(item_keywords)), 0)
def test_scalar(self):
"""sa.dependency won't delete an m2m relationship referencing None."""
)
i = Item(description="x")
- session = create_session()
+ session = fixture_session()
session.add(i)
session.flush()
session.delete(i)
item = Item(description="item 1")
item.keywords.extend([k1, k2, k3])
- session = create_session()
+ session = fixture_session()
session.add(item)
session.flush()
),
)
- session = create_session()
+ session = fixture_session()
def fixture():
_kw = dict([(k.name, k) for k in session.query(Keyword)])
),
)
- session = create_session()
+ session = fixture_session()
def fixture():
return [
i.keywords.append(k1)
i.keywords.append(k2)
- session = create_session()
+ session = fixture_session()
session.add(i)
session.flush()
- eq_(select(func.count("*")).select_from(assoc).scalar(), 2)
+ eq_(
+ session.connection().scalar(
+ select(func.count("*")).select_from(assoc)
+ ),
+ 2,
+ )
i.keywords = []
session.flush()
- eq_(select(func.count("*")).select_from(assoc).scalar(), 0)
+ eq_(
+ session.connection().scalar(
+ select(func.count("*")).select_from(assoc)
+ ),
+ 0,
+ )
class BooleanColTest(fixtures.MappedTest):
mapper(T, t1_t)
- sess = create_session()
+ sess = fixture_session()
t1 = T(value=True, name="t1")
t2 = T(value=False, name="t2")
t3 = T(value=True, name="t3")
)
mapper(T6, t6)
- sess = create_session()
+ sess = fixture_session()
o5 = T5(data="some t5", id=1)
o5.t6s.append(T6(data="some t6", id=1))
)
mapper(T7, t7)
- sess = create_session()
+ sess = fixture_session()
o5 = T5(data="some t5", id=1)
o5.t7s.append(T7(data="some t7", id=1))
mapper(T6, t6, properties={"t5": relationship(T5)})
mapper(T5, t5)
- sess = create_session()
+ sess = fixture_session()
o5 = T6(data="some t6", id=1)
o5.t5 = T5(data="some t5", id=1)
mapper(P, parent)
mapper(C, child, inherits=P)
- sess = create_session()
+ sess = fixture_session()
c1 = C(pid=1, cid=1, pdata="c1", cdata="c1")
sess.add(c1)
sess.flush()
)
-class TransactionTest(fixtures.MappedTest):
- __requires__ = ("deferrable_or_no_constraints",)
-
- @classmethod
- def define_tables(cls, metadata):
- Table("t1", metadata, Column("id", Integer, primary_key=True))
-
- Table(
- "t2",
- metadata,
- Column("id", Integer, primary_key=True),
- Column(
- "t1_id",
- Integer,
- ForeignKey("t1.id", deferrable=True, initially="deferred"),
- ),
- )
-
- @classmethod
- def setup_classes(cls):
- class T1(cls.Comparable):
- pass
-
- class T2(cls.Comparable):
- pass
-
- @classmethod
- def setup_mappers(cls):
- T2, T1, t2, t1 = (
- cls.classes.T2,
- cls.classes.T1,
- cls.tables.t2,
- cls.tables.t1,
- )
-
- mapper(T1, t1)
- mapper(T2, t2)
-
- def test_close_transaction_on_commit_fail(self):
- T2, t1 = self.classes.T2, self.tables.t1
-
- session = create_session(autocommit=True)
-
- # with a deferred constraint, this fails at COMMIT time instead
- # of at INSERT time.
- session.add(T2(t1_id=123))
-
- try:
- session.flush()
- assert False
- except Exception:
- # Flush needs to rollback also when commit fails
- assert session._legacy_transaction() is None
-
- # todo: on 8.3 at least, the failed commit seems to close the cursor?
- # needs investigation. leaving in the DDL above now to help verify
- # that the new deferrable support on FK isn't involved in this issue.
- if testing.against("postgresql"):
- t1.bind.engine.dispose()
-
-
class PartialNullPKTest(fixtures.MappedTest):
# sqlite totally fine with NULLs in pk columns.
# no other DB is like this.
def test_key_switch(self):
T1 = self.classes.T1
- s = Session()
+ s = fixture_session()
s.add(T1(col1="1", col2=None))
t1 = s.query(T1).first()
def test_plain_update(self):
T1 = self.classes.T1
- s = Session()
+ s = fixture_session()
s.add(T1(col1="1", col2=None))
t1 = s.query(T1).first()
def test_delete(self):
T1 = self.classes.T1
- s = Session()
+ s = fixture_session()
s.add(T1(col1="1", col2=None))
t1 = s.query(T1).first()
def test_total_null(self):
T1 = self.classes.T1
- s = Session()
+ s = fixture_session()
s.add(T1(col1=None, col2=None))
assert_raises_message(
orm_exc.FlushError,
def test_dont_complain_if_no_update(self):
T1 = self.classes.T1
- s = Session()
+ s = fixture_session()
t = T1(col1="1", col2=None)
s.add(t)
s.commit()
mapper(cls.classes.T3, cls.tables.t3)
def test_exception_persistent_flush_py3k(self):
- s = Session()
+ s = fixture_session()
a, b = self.classes.T2(id=self.three), self.classes.T2(id=self.four)
s.add_all([a, b])
s.close()
def test_persistent_flush_sortable(self):
- s = Session()
+ s = fixture_session()
a, b = self.classes.T1(id=self.one), self.classes.T1(id=self.two)
s.add_all([a, b])
s.commit()
def test_pep435_custom_sort_key(self):
- s = Session()
+ s = fixture_session()
a = self.classes.T3(id=self.three, value=1)
b = self.classes.T3(id=self.four, value=2)
from sqlalchemy import util
from sqlalchemy.orm import attributes
from sqlalchemy.orm import backref
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import exc as orm_exc
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing.assertsql import AllOf
from sqlalchemy.testing.assertsql import CompiledSQL
from sqlalchemy.testing.assertsql import Conditional
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.mock import Mock
from sqlalchemy.testing.mock import patch
from sqlalchemy.testing.schema import Column
mapper(User, users, properties={"addresses": relationship(Address)})
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
a1, a2 = Address(email_address="a1"), Address(email_address="a2")
u1 = User(name="u1", addresses=[a1, a2])
mapper(User, users, properties={"addresses": relationship(Address)})
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
a1, a2 = Address(email_address="a1"), Address(email_address="a2")
u1 = User(name="u1", addresses=[a1, a2])
sess.add(u1)
mapper(User, users, properties={"addresses": relationship(Address)})
mapper(Address, addresses)
- sess = create_session()
+ sess = fixture_session()
a1, a2 = Address(email_address="a1"), Address(email_address="a2")
u1 = User(name="u1", addresses=[a1, a2])
sess.add(u1)
mapper(User, users)
mapper(Address, addresses, properties={"user": relationship(User)})
- sess = create_session()
+ sess = fixture_session()
u1 = User(name="u1")
a1, a2 = (
mapper(User, users)
mapper(Address, addresses, properties={"user": relationship(User)})
- sess = create_session()
+ sess = fixture_session()
u1 = User(name="u1")
a1, a2 = (
mapper(User, users)
mapper(Address, addresses, properties={"user": relationship(User)})
- sess = create_session()
+ sess = fixture_session()
u1 = User(name="u1")
a1, a2 = (
Address(email_address="c2", parent=parent),
)
- session = Session()
+ session = fixture_session()
session.add_all([c1, c2])
session.add(parent)
Address(email_address="c2", parent=parent),
)
- session = Session()
+ session = fixture_session()
session.add_all([c1, c2])
session.add(parent)
Address(email_address="c2", parent=parent),
)
- session = Session()
+ session = fixture_session()
session.add_all([c1, c2])
session.add(parent)
mapper(User, users)
mapper(Address, addresses, properties={"user": relationship(User)})
- sess = create_session()
+ sess = fixture_session()
u1 = User(name="u1")
a1, a2 = (
mapper(User, users)
mapper(Address, addresses, properties={"user": relationship(User)})
- sess = create_session()
+ sess = fixture_session()
u1 = User(name="u1")
a1, a2 = (
mapper(User, users)
mapper(Address, addresses, properties={"parent": relationship(User)})
- sess = create_session()
+ sess = fixture_session()
u1 = User(id=1, name="u1")
a1 = Address(id=1, user_id=1, email_address="a2")
mapper(Node, nodes, properties={"children": relationship(Node)})
- sess = create_session()
+ sess = fixture_session()
n1 = Node(id=1)
n2 = Node(id=2, parent_id=1)
)
mapper(Keyword, keywords)
- sess = create_session()
+ sess = fixture_session()
k1 = Keyword(name="k1")
i1 = Item(description="i1", keywords=[k1])
sess.add(i1)
addresses,
properties={"user": relationship(User, passive_updates=True)},
)
- sess = create_session()
+ sess = fixture_session()
u1 = User(name="ed")
sess.add(u1)
self._assert_uow_size(sess, 2)
mapper(User, users, properties={"addresses": relationship(Address)})
mapper(Address, addresses)
- sess = create_session()
- u1 = User(name="ed")
- sess.add(u1)
- self._assert_uow_size(sess, 2)
+ with fixture_session(autoflush=False) as sess:
+ u1 = User(name="ed")
+ sess.add(u1)
+ self._assert_uow_size(sess, 2)
- sess.flush()
+ sess.flush()
- u1.name = "jack"
+ u1.name = "jack"
- self._assert_uow_size(sess, 2)
- sess.flush()
+ self._assert_uow_size(sess, 2)
+ sess.flush()
- a1 = Address(email_address="foo")
- sess.add(a1)
- sess.flush()
+ a1 = Address(email_address="foo")
+ sess.add(a1)
+ sess.flush()
- u1.addresses.append(a1)
+ u1.addresses.append(a1)
- self._assert_uow_size(sess, 6)
+ self._assert_uow_size(sess, 6)
- sess.flush()
+ sess.commit()
- sess = create_session()
- u1 = sess.query(User).first()
- u1.name = "ed"
- self._assert_uow_size(sess, 2)
+ with fixture_session(autoflush=False) as sess:
+ u1 = sess.query(User).first()
+ u1.name = "ed"
+ self._assert_uow_size(sess, 2)
- u1.addresses
- self._assert_uow_size(sess, 6)
+ u1.addresses
+ self._assert_uow_size(sess, 6)
class SingleCycleTest(UOWTest):
Node, nodes = self.classes.Node, self.tables.nodes
mapper(Node, nodes, properties={"children": relationship(Node)})
- sess = create_session()
+ sess = fixture_session()
n2, n3 = Node(data="n2"), Node(data="n3")
n1 = Node(data="n1", children=[n2, n3])
Node, nodes = self.classes.Node, self.tables.nodes
mapper(Node, nodes, properties={"children": relationship(Node)})
- sess = create_session()
+ sess = fixture_session()
n2, n3 = Node(data="n2", children=[]), Node(data="n3", children=[])
n1 = Node(data="n1", children=[n2, n3])
Node, nodes = self.classes.Node, self.tables.nodes
mapper(Node, nodes, properties={"children": relationship(Node)})
- sess = create_session()
+ sess = fixture_session()
n2, n3 = Node(data="n2", children=[]), Node(data="n3", children=[])
n1 = Node(data="n1", children=[n2, n3])
nodes,
properties={"parent": relationship(Node, remote_side=nodes.c.id)},
)
- sess = create_session()
+ sess = fixture_session()
n1 = Node(data="n1")
n2, n3 = Node(data="n2", parent=n1), Node(data="n3", parent=n1)
nodes,
properties={"parent": relationship(Node, remote_side=nodes.c.id)},
)
- sess = create_session()
+ sess = fixture_session()
n1 = Node(data="n1")
n2, n3 = Node(data="n2", parent=n1), Node(data="n3", parent=n1)
nodes,
properties={"parent": relationship(Node, remote_side=nodes.c.id)},
)
- sess = create_session()
- n1 = Node(data="n1")
- n2 = Node(data="n2", parent=n1)
- sess.add_all([n1, n2])
- sess.flush()
- sess.close()
+ with fixture_session() as sess:
+ n1 = Node(data="n1")
+ n2 = Node(data="n2", parent=n1)
+ sess.add_all([n1, n2])
+ sess.commit()
- n2 = sess.query(Node).filter_by(data="n2").one()
- n2.parent = None
- self.assert_sql_execution(
- testing.db,
- sess.flush,
- CompiledSQL(
- "UPDATE nodes SET parent_id=:parent_id WHERE "
- "nodes.id = :nodes_id",
- lambda ctx: {"parent_id": None, "nodes_id": n2.id},
- ),
- )
+ with fixture_session() as sess:
+ n2 = sess.query(Node).filter_by(data="n2").one()
+ n2.parent = None
+ self.assert_sql_execution(
+ testing.db,
+ sess.flush,
+ CompiledSQL(
+ "UPDATE nodes SET parent_id=:parent_id WHERE "
+ "nodes.id = :nodes_id",
+ lambda ctx: {"parent_id": None, "nodes_id": n2.id},
+ ),
+ )
def test_cycle_rowswitch(self):
Node, nodes = self.classes.Node, self.tables.nodes
mapper(Node, nodes, properties={"children": relationship(Node)})
- sess = create_session()
+ sess = fixture_session()
n2, n3 = Node(data="n2", children=[]), Node(data="n3", children=[])
n1 = Node(data="n1", children=[n2])
)
},
)
- sess = create_session()
+ sess = fixture_session()
n2, n3 = Node(data="n2", children=[]), Node(data="n3", children=[])
n1 = Node(data="n1", children=[n2])
)
},
)
- sess = create_session()
+ sess = fixture_session()
n1 = Node(data="n1")
n1.children.append(Node(data="n11"))
n12 = Node(data="n12")
Node, nodes = self.classes.Node, self.tables.nodes
mapper(Node, nodes, properties={"children": relationship(Node)})
- sess = create_session()
- n1 = Node(data="ed")
- sess.add(n1)
- self._assert_uow_size(sess, 2)
+ with fixture_session() as sess:
+ n1 = Node(data="ed")
+ sess.add(n1)
+ self._assert_uow_size(sess, 2)
- sess.flush()
+ sess.flush()
- n1.data = "jack"
+ n1.data = "jack"
- self._assert_uow_size(sess, 2)
- sess.flush()
+ self._assert_uow_size(sess, 2)
+ sess.flush()
- n2 = Node(data="foo")
- sess.add(n2)
- sess.flush()
+ n2 = Node(data="foo")
+ sess.add(n2)
+ sess.flush()
- n1.children.append(n2)
+ n1.children.append(n2)
- self._assert_uow_size(sess, 3)
+ self._assert_uow_size(sess, 3)
- sess.flush()
+ sess.commit()
- sess = create_session()
+ sess = fixture_session(autoflush=False)
n1 = sess.query(Node).first()
n1.data = "ed"
self._assert_uow_size(sess, 2)
parent = Node()
c1, c2 = Node(parent=parent), Node(parent=parent)
- session = Session()
+ session = fixture_session()
session.add_all([c1, c2])
session.add(parent)
)
mapper(FooBar, foobars)
- sess = create_session()
+ sess = fixture_session()
n1 = Node(data="n1")
n2 = Node(data="n2")
n1.children.append(n2)
},
)
- sess = create_session()
- n1 = Node(data="n1")
- n2 = Node(data="n2")
- n3 = Node(data="n3")
- n4 = Node(data="n4")
- n5 = Node(data="n5")
+ with fixture_session(autoflush=False) as sess:
+ n1 = Node(data="n1")
+ n2 = Node(data="n2")
+ n3 = Node(data="n3")
+ n4 = Node(data="n4")
+ n5 = Node(data="n5")
- n4.favorite = n3
- n1.favorite = n5
- n5.favorite = n2
+ n4.favorite = n3
+ n1.favorite = n5
+ n5.favorite = n2
- n1.children = [n2, n3, n4]
- n2.children = [n3, n5]
- n3.children = [n5, n4]
+ n1.children = [n2, n3, n4]
+ n2.children = [n3, n5]
+ n3.children = [n5, n4]
- sess.add_all([n1, n2, n3, n4, n5])
+ sess.add_all([n1, n2, n3, n4, n5])
- # can't really assert the SQL on this easily
- # since there's too many ways to insert the rows.
- # so check the end result
- sess.flush()
- eq_(
- sess.query(
- node_to_nodes.c.left_node_id, node_to_nodes.c.right_node_id
- )
- .order_by(
- node_to_nodes.c.left_node_id, node_to_nodes.c.right_node_id
+ # can't really assert the SQL on this easily
+ # since there's too many ways to insert the rows.
+ # so check the end result
+ sess.flush()
+ eq_(
+ sess.query(
+ node_to_nodes.c.left_node_id, node_to_nodes.c.right_node_id
+ )
+ .order_by(
+ node_to_nodes.c.left_node_id, node_to_nodes.c.right_node_id
+ )
+ .all(),
+ sorted(
+ [
+ (n1.id, n2.id),
+ (n1.id, n3.id),
+ (n1.id, n4.id),
+ (n2.id, n3.id),
+ (n2.id, n5.id),
+ (n3.id, n5.id),
+ (n3.id, n4.id),
+ ]
+ ),
)
- .all(),
- sorted(
- [
- (n1.id, n2.id),
- (n1.id, n3.id),
- (n1.id, n4.id),
- (n2.id, n3.id),
- (n2.id, n5.id),
- (n3.id, n5.id),
- (n3.id, n4.id),
- ]
- ),
- )
- sess.delete(n1)
+ sess.delete(n1)
- self.assert_sql_execution(
- testing.db,
- sess.flush,
- # this is n1.parents firing off, as it should, since
- # passive_deletes is False for n1.parents
- CompiledSQL(
- "SELECT nodes.id AS nodes_id, nodes.data AS nodes_data, "
- "nodes.favorite_node_id AS nodes_favorite_node_id FROM "
- "nodes, node_to_nodes WHERE :param_1 = "
- "node_to_nodes.right_node_id AND nodes.id = "
- "node_to_nodes.left_node_id",
- lambda ctx: {"param_1": n1.id},
- ),
- CompiledSQL(
- "DELETE FROM node_to_nodes WHERE "
- "node_to_nodes.left_node_id = :left_node_id AND "
- "node_to_nodes.right_node_id = :right_node_id",
- lambda ctx: [
- {"right_node_id": n2.id, "left_node_id": n1.id},
- {"right_node_id": n3.id, "left_node_id": n1.id},
- {"right_node_id": n4.id, "left_node_id": n1.id},
- ],
- ),
- CompiledSQL(
- "DELETE FROM nodes WHERE nodes.id = :id",
- lambda ctx: {"id": n1.id},
- ),
- )
+ self.assert_sql_execution(
+ testing.db,
+ sess.flush,
+ # this is n1.parents firing off, as it should, since
+ # passive_deletes is False for n1.parents
+ CompiledSQL(
+ "SELECT nodes.id AS nodes_id, nodes.data AS nodes_data, "
+ "nodes.favorite_node_id AS nodes_favorite_node_id FROM "
+ "nodes, node_to_nodes WHERE :param_1 = "
+ "node_to_nodes.right_node_id AND nodes.id = "
+ "node_to_nodes.left_node_id",
+ lambda ctx: {"param_1": n1.id},
+ ),
+ CompiledSQL(
+ "DELETE FROM node_to_nodes WHERE "
+ "node_to_nodes.left_node_id = :left_node_id AND "
+ "node_to_nodes.right_node_id = :right_node_id",
+ lambda ctx: [
+ {"right_node_id": n2.id, "left_node_id": n1.id},
+ {"right_node_id": n3.id, "left_node_id": n1.id},
+ {"right_node_id": n4.id, "left_node_id": n1.id},
+ ],
+ ),
+ CompiledSQL(
+ "DELETE FROM nodes WHERE nodes.id = :id",
+ lambda ctx: {"id": n1.id},
+ ),
+ )
- for n in [n2, n3, n4, n5]:
- sess.delete(n)
+ for n in [n2, n3, n4, n5]:
+ sess.delete(n)
- # load these collections
- # outside of the flush() below
- n4.children
- n5.children
+ # load these collections
+ # outside of the flush() below
+ n4.children
+ n5.children
- self.assert_sql_execution(
- testing.db,
- sess.flush,
- CompiledSQL(
- "DELETE FROM node_to_nodes WHERE node_to_nodes.left_node_id "
- "= :left_node_id AND node_to_nodes.right_node_id = "
- ":right_node_id",
- lambda ctx: [
- {"right_node_id": n5.id, "left_node_id": n3.id},
- {"right_node_id": n4.id, "left_node_id": n3.id},
- {"right_node_id": n3.id, "left_node_id": n2.id},
- {"right_node_id": n5.id, "left_node_id": n2.id},
- ],
- ),
- CompiledSQL(
- "DELETE FROM nodes WHERE nodes.id = :id",
- lambda ctx: [{"id": n4.id}, {"id": n5.id}],
- ),
- CompiledSQL(
- "DELETE FROM nodes WHERE nodes.id = :id",
- lambda ctx: [{"id": n2.id}, {"id": n3.id}],
- ),
- )
+ self.assert_sql_execution(
+ testing.db,
+ sess.flush,
+ CompiledSQL(
+ "DELETE FROM node_to_nodes "
+ "WHERE node_to_nodes.left_node_id "
+ "= :left_node_id AND node_to_nodes.right_node_id = "
+ ":right_node_id",
+ lambda ctx: [
+ {"right_node_id": n5.id, "left_node_id": n3.id},
+ {"right_node_id": n4.id, "left_node_id": n3.id},
+ {"right_node_id": n3.id, "left_node_id": n2.id},
+ {"right_node_id": n5.id, "left_node_id": n2.id},
+ ],
+ ),
+ CompiledSQL(
+ "DELETE FROM nodes WHERE nodes.id = :id",
+ lambda ctx: [{"id": n4.id}, {"id": n5.id}],
+ ),
+ CompiledSQL(
+ "DELETE FROM nodes WHERE nodes.id = :id",
+ lambda ctx: [{"id": n2.id}, {"id": n3.id}],
+ ),
+ )
class RowswitchAccountingTest(fixtures.MappedTest):
def test_switch_on_update(self):
Parent, Child = self._fixture()
- sess = create_session(autocommit=False)
+ sess = fixture_session(autocommit=False)
p1 = Parent(id=1, child=Child())
sess.add(p1)
def test_switch_on_delete(self):
Parent, Child = self._fixture()
- sess = Session()
+ sess = fixture_session()
p1 = Parent(id=1, data=2, child=None)
sess.add(p1)
sess.flush()
# change that previously showed up as nothing.
A, B, C = self._fixture()
- sess = Session()
+ sess = fixture_session()
sess.add(A(id=1, bs=[B(id=1, c=C(id=1))]))
sess.commit()
def test_set_none_w_get_replaces_m2o(self):
A, B, C = self._fixture()
- sess = Session()
+ sess = fixture_session()
sess.add(A(id=1, bs=[B(id=1, c=C(id=1))]))
sess.commit()
# shows, we can't rely on this - the get of None will blow
# away the history.
A, B, C = self._fixture()
- sess = Session()
+ sess = fixture_session()
sess.add(A(id=1, bs=[B(id=1, data="somedata")]))
sess.commit()
def test_set_none_w_get_replaces_scalar(self):
A, B, C = self._fixture()
- sess = Session()
+ sess = fixture_session()
sess.add(A(id=1, bs=[B(id=1, data="somedata")]))
sess.commit()
@testing.requires.sane_rowcount
def test_update_single_missing(self):
Parent, Child = self._fixture()
- sess = Session()
+ sess = fixture_session()
p1 = Parent(id=1, data=2)
sess.add(p1)
sess.flush()
"sqlalchemy.engine.cursor.CursorResult.rowcount", rowcount
):
Parent, Child = self._fixture()
- sess = Session()
+ sess = fixture_session()
p1 = Parent(id=1, data=2)
sess.add(p1)
sess.flush()
"sqlalchemy.engine.cursor.CursorResult.rowcount", rowcount
):
Parent, Child = self._fixture()
- sess = Session()
+ sess = fixture_session()
p1 = Parent(id=1, data=2)
p2 = Parent(id=2, data=3)
sess.add_all([p1, p2])
"sqlalchemy.engine.cursor.CursorResult.rowcount", rowcount
):
Parent, Child = self._fixture()
- sess = Session()
+ sess = fixture_session()
p1 = Parent(id=1, data=1)
sess.add(p1)
sess.flush()
@testing.requires.sane_rowcount
def test_delete_twice(self):
Parent, Child = self._fixture()
- sess = Session()
+ sess = fixture_session()
p1 = Parent(id=1, data=2, child=None)
sess.add(p1)
sess.commit()
@testing.requires.sane_multi_rowcount
def test_delete_multi_missing_warning(self):
Parent, Child = self._fixture()
- sess = Session()
+ sess = fixture_session()
p1 = Parent(id=1, data=2, child=None)
p2 = Parent(id=2, data=3, child=None)
sess.add_all([p1, p2])
# raise occurs for single row UPDATE that misses even if
# supports_sane_multi_rowcount is False
Parent, Child = self._fixture()
- sess = Session()
+ sess = fixture_session()
p1 = Parent(id=1, data=2, child=None)
sess.add(p1)
sess.flush()
# supports_sane_multi_rowcount is False, even if rowcount is still
# correct
Parent, Child = self._fixture()
- sess = Session()
+ sess = fixture_session()
p1 = Parent(id=1, data=2, child=None)
p2 = Parent(id=2, data=3, child=None)
sess.add_all([p1, p2])
def test_delete_single_broken_multi_rowcount_still_warns(self):
Parent, Child = self._fixture()
- sess = Session()
+ sess = fixture_session()
p1 = Parent(id=1, data=2, child=None)
sess.add(p1)
sess.flush()
def test_delete_multi_broken_multi_rowcount_doesnt_warn(self):
Parent, Child = self._fixture()
- sess = Session()
+ sess = fixture_session()
p1 = Parent(id=1, data=2, child=None)
p2 = Parent(id=2, data=3, child=None)
sess.add_all([p1, p2])
def test_delete_multi_missing_allow(self):
Parent, Child = self._fixture(confirm_deleted_rows=False)
- sess = Session()
+ sess = fixture_session()
p1 = Parent(id=1, data=2, child=None)
p2 = Parent(id=2, data=3, child=None)
sess.add_all([p1, p2])
pass
mapper(T, t)
- sess = Session()
+ sess = fixture_session()
sess.add_all(
[
T(data="t1"),
},
)
mapper(Address, addresses)
- return create_session(autocommit=False)
+ return fixture_session(expire_on_commit=False)
def test_before_update_m2o(self):
"""Expect normal many to one attribute load behavior
event.listen(Thing.prefetch_val, "set", mock.prefetch_val)
event.listen(Thing.returning_val, "set", mock.prefetch_val)
t1 = Thing()
- s = Session()
+ s = fixture_session()
s.add(t1)
s.flush()
def test_insert_defaults_present(self):
Thing = self.classes.Thing
- s = Session()
+ s = fixture_session()
t1, t2 = (Thing(id=1, foo=5), Thing(id=2, foo=10))
def test_insert_defaults_present_as_expr(self):
Thing = self.classes.Thing
- s = Session()
+ s = fixture_session()
t1, t2 = (
Thing(id=1, foo=text("2 + 5")),
def test_insert_defaults_nonpresent(self):
Thing = self.classes.Thing
- s = Session()
+ s = fixture_session()
t1, t2 = (Thing(id=1), Thing(id=2))
def test_update_defaults_nonpresent(self):
Thing2 = self.classes.Thing2
- s = Session()
+ s = fixture_session()
t1, t2, t3, t4 = (
Thing2(id=1, foo=1, bar=2),
def test_update_defaults_present_as_expr(self):
Thing2 = self.classes.Thing2
- s = Session()
+ s = fixture_session()
t1, t2, t3, t4 = (
Thing2(id=1, foo=1, bar=2),
def test_insert_defaults_bulk_insert(self):
Thing = self.classes.Thing
- s = Session()
+ s = fixture_session()
mappings = [{"id": 1}, {"id": 2}]
def test_update_defaults_bulk_update(self):
Thing2 = self.classes.Thing2
- s = Session()
+ s = fixture_session()
t1, t2, t3, t4 = (
Thing2(id=1, foo=1, bar=2),
def test_update_defaults_present(self):
Thing2 = self.classes.Thing2
- s = Session()
+ s = fixture_session()
t1, t2 = (Thing2(id=1, foo=1, bar=2), Thing2(id=2, foo=2, bar=3))
def test_insert_dont_fetch_nondefaults(self):
Thing2 = self.classes.Thing2
- s = Session()
+ s = fixture_session()
t1 = Thing2(id=1, bar=2)
def test_update_dont_fetch_nondefaults(self):
Thing2 = self.classes.Thing2
- s = Session()
+ s = fixture_session()
t1 = Thing2(id=1, bar=2)
def test_update_against_none(self):
Thing = self.classes.Thing
- s = Session()
+ s = fixture_session()
s.add(Thing(value=self.MyWidget("foo")))
s.commit()
def test_update_against_something_else(self):
Thing = self.classes.Thing
- s = Session()
+ s = fixture_session()
s.add(Thing(value=self.MyWidget("foo")))
s.commit()
def test_no_update_no_change(self):
Thing = self.classes.Thing
- s = Session()
+ s = fixture_session()
s.add(Thing(value=self.MyWidget("foo"), unrelated="unrelated"))
s.commit()
def _assert_col(self, name, value):
Thing, AltNameThing = self.classes.Thing, self.classes.AltNameThing
- s = Session()
+ s = fixture_session()
col = getattr(Thing, name)
obj = s.query(col).filter(col == value).one()
def _test_insert(self, attr, expected):
Thing, AltNameThing = self.classes.Thing, self.classes.AltNameThing
- s = Session()
+ s = fixture_session()
t1 = Thing(**{attr: None})
s.add(t1)
def _test_bulk_insert(self, attr, expected):
Thing, AltNameThing = self.classes.Thing, self.classes.AltNameThing
- s = Session()
+ s = fixture_session()
s.bulk_insert_mappings(Thing, [{attr: None}])
s.bulk_insert_mappings(AltNameThing, [{"_foo_" + attr: None}])
s.commit()
def _test_insert_novalue(self, attr, expected):
Thing, AltNameThing = self.classes.Thing, self.classes.AltNameThing
- s = Session()
+ s = fixture_session()
t1 = Thing()
s.add(t1)
def _test_bulk_insert_novalue(self, attr, expected):
Thing, AltNameThing = self.classes.Thing, self.classes.AltNameThing
- s = Session()
+ s = fixture_session()
s.bulk_insert_mappings(Thing, [{}])
s.bulk_insert_mappings(AltNameThing, [{}])
s.commit()
def test_json_none_as_null(self):
JSONThing = self.classes.JSONThing
- s = Session()
+ s = fixture_session()
f1 = JSONThing(data=None, data_null=None)
s.add(f1)
s.commit()
from sqlalchemy.testing import in_
from sqlalchemy.testing import not_in
from sqlalchemy.testing.assertsql import CompiledSQL
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
def test_illegal_eval(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
assert_raises_message(
exc.ArgumentError,
"Valid strategies for session synchronization "
User = self.classes.User
Address = self.classes.Address
- s = Session()
+ s = fixture_session()
for q, mname in (
(s.query(User).limit(2), r"limit\(\)"),
def __clause_element__(self):
return User.name.__clause_element__()
- s = Session()
+ s = fixture_session()
jill = s.query(User).get(3)
s.query(User).update(
{Thing(): "moonbeam"}, synchronize_session="evaluate"
def __clause_element__(self):
return 5
- s = Session()
+ s = fixture_session()
assert_raises_message(
exc.ArgumentError,
def test_evaluate_unmapped_col(self):
User = self.classes.User
- s = Session()
+ s = fixture_session()
jill = s.query(User).get(3)
s.query(User).update(
{column("name"): "moonbeam"}, synchronize_session="evaluate"
mapper(Foo, self.tables.users, properties={"uname": synonym("name")})
- s = Session()
+ s = fixture_session()
jill = s.query(Foo).get(3)
s.query(Foo).update(
{"uname": "moonbeam"}, synchronize_session="evaluate"
mapper(Foo, self.tables.users, properties={"uname": synonym("name")})
- s = Session()
+ s = fixture_session()
jill = s.query(Foo).get(3)
s.query(Foo).update(
{Foo.uname: "moonbeam"}, synchronize_session="evaluate"
properties={"uname": synonym("name"), "ufoo": synonym("uname")},
)
- s = Session()
+ s = fixture_session()
jill = s.query(Foo).get(3)
s.query(Foo).update(
{Foo.ufoo: "moonbeam"}, synchronize_session="evaluate"
):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
def test_fetch_dont_refresh_expired_objects(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
def test_delete(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
sess.query(User).filter(
User = self.classes.User
users = self.tables.users
- sess = Session()
+ sess = fixture_session()
sess.query(users).delete(synchronize_session=False)
eq_(sess.query(User).count(), 0)
def test_delete_with_bindparams(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
sess.query(User).filter(text("name = :name")).params(
def test_delete_rollback(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
sess.query(User).filter(
or_(User.name == "john", User.name == "jill")
def test_delete_rollback_with_fetch(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
sess.query(User).filter(
or_(User.name == "john", User.name == "jill")
def test_delete_without_session_sync(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
sess.query(User).filter(
def test_delete_with_fetch_strategy(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
sess.query(User).filter(
def test_delete_invalid_evaluation(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
def test_update(self):
User, users = self.classes.User, self.tables.users
- sess = Session()
+ sess = fixture_session()
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
sess.query(User).filter(User.age > 29).update(
def test_update_against_table_col(self):
User, users = self.classes.User, self.tables.users
- sess = Session()
+ sess = fixture_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(
def test_update_against_metadata(self):
User, users = self.classes.User, self.tables.users
- sess = Session()
+ sess = fixture_session()
sess.query(users).update(
{users.c.age_int: 29}, synchronize_session=False
def test_update_with_bindparams(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
def test_update_fetch_returning(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
def test_delete_fetch_returning(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
assert_raises(
exc.ArgumentError,
lambda: sess.query(User.name == "filter").update(
def test_update_without_load(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
sess.query(User).filter(User.id == 3).update(
{"age": 44}, synchronize_session="fetch"
def test_update_changes_resets_dirty(self):
User = self.classes.User
- sess = Session(autoflush=False)
+ sess = fixture_session(autoflush=False)
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
def test_update_changes_with_autoflush(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
def test_update_with_expire_strategy(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
sess.query(User).filter(User.age > 29).update(
def test_update_returns_rowcount(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
rowcount = (
sess.query(User)
def test_delete_returns_rowcount(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
rowcount = (
sess.query(User)
def test_update_all(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
sess.query(User).update({"age": 42}, synchronize_session="evaluate")
def test_delete_all(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
sess.query(User).delete(synchronize_session="evaluate")
def test_autoflush_before_evaluate_update(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john = sess.query(User).filter_by(name="john").one()
john.name = "j2"
def test_autoflush_before_fetch_update(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john = sess.query(User).filter_by(name="john").one()
john.name = "j2"
def test_autoflush_before_evaluate_delete(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john = sess.query(User).filter_by(name="john").one()
john.name = "j2"
def test_autoflush_before_fetch_delete(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john = sess.query(User).filter_by(name="john").one()
john.name = "j2"
def test_evaluate_before_update(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john = sess.query(User).filter_by(name="john").one()
sess.expire(john, ["age"])
def test_fetch_before_update(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john = sess.query(User).filter_by(name="john").one()
sess.expire(john, ["age"])
def test_evaluate_before_delete(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john = sess.query(User).filter_by(name="john").one()
sess.expire(john, ["age"])
def test_fetch_before_delete(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john = sess.query(User).filter_by(name="john").one()
sess.expire(john, ["age"])
def test_update_unordered_dict(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
# Do an update using unordered dict and check that the parameters used
# are ordered in table order
def test_update_preserve_parameter_order_query(self):
User = self.classes.User
- session = Session()
+ session = fixture_session()
# Do update using a tuple and check that order is preserved
def test_update_with_eager_relationships(self):
Document = self.classes.Document
- sess = Session()
+ sess = fixture_session()
foo, bar, baz = sess.query(Document).order_by(Document.id).all()
sess.query(Document).filter(Document.user_id == 1).update(
def test_update_with_explicit_joinedload(self):
User = self.classes.User
- sess = Session()
+ sess = fixture_session()
john, jack, jill, jane = sess.query(User).order_by(User.id).all()
sess.query(User).options(joinedload(User.documents)).filter(
def test_delete_with_eager_relationships(self):
Document = self.classes.Document
- sess = Session()
+ sess = fixture_session()
sess.query(Document).filter(Document.user_id == 1).delete(
synchronize_session=False
@testing.requires.update_from
def test_update_from_joined_subq_test(self):
Document = self.classes.Document
- s = Session()
+ s = fixture_session()
subq = (
s.query(func.max(Document.title).label("title"))
@testing.requires.delete_from
def test_delete_from_joined_subq_test(self):
Document = self.classes.Document
- s = Session()
+ s = fixture_session()
subq = (
s.query(func.max(Document.title).label("title"))
User = self.classes.User
Document = self.classes.Document
- s = Session()
+ s = fixture_session()
q = s.query(User).filter(User.id == Document.user_id)
assert_raises_message(
@testing.requires.update_where_target_in_subquery
def test_update_using_in(self):
Document = self.classes.Document
- s = Session()
+ s = fixture_session()
subq = (
s.query(func.max(Document.title).label("title"))
@testing.requires.standalone_binds
def test_update_using_case(self):
Document = self.classes.Document
- s = Session()
+ s = fixture_session()
subq = (
s.query(func.max(Document.title).label("title"))
Document = self.classes.Document
User = self.classes.User
- s = Session()
+ s = fixture_session()
s.query(Document).filter(User.id == Document.user_id).filter(
User.id == 2
Data = self.classes.Data
d1 = Data()
- sess = Session()
+ sess = fixture_session()
sess.add(d1)
sess.commit()
eq_(d1.cnt, 0)
def test_update_args(self):
Data = self.classes.Data
- session = Session()
+ session = fixture_session()
update_args = {"mysql_limit": 1}
m1 = testing.mock.Mock()
def test_update(self, fetchstyle, future):
Staff, Sales, Support = self.classes("Staff", "Sales", "Support")
- sess = Session()
+ sess = fixture_session()
en1, en2 = (
sess.execute(select(Sales).order_by(Sales.sales_stats))
def test_delete(self, fetchstyle, future):
Staff, Sales, Support = self.classes("Staff", "Sales", "Support")
- sess = Session()
+ sess = fixture_session()
en1, en2 = sess.query(Sales).order_by(Sales.sales_stats).all()
mn1, mn2 = sess.query(Support).order_by(Support.support_stats).all()
from sqlalchemy.ext.hybrid import hybrid_method
from sqlalchemy.ext.hybrid import hybrid_property
from sqlalchemy.orm import aliased
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import mapper
-from sqlalchemy.orm import Session
from sqlalchemy.orm import synonym
from sqlalchemy.orm import util as orm_util
from sqlalchemy.orm import with_polymorphic
from sqlalchemy.testing import expect_warnings
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import is_
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.util import compat
from test.orm import _fixtures
from .inheritance import _poly_fixtures
self._fixture(Point)
alias = aliased(Point)
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(alias).filter(alias.left_of(Point)),
eq_(str(Point.double_x.__clause_element__()), "point.x * :x_1")
eq_(str(alias.double_x.__clause_element__()), "point_1.x * :x_1")
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(alias).filter(alias.double_x > Point.x),
a2 = aliased(Point)
eq_(str(a2.x_alone == alias.x), "point_1.x = point_2.x")
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(alias).filter(alias.x_alone > Point.x),
eq_(str(Point.x_syn), "Point.x_syn")
eq_(str(alias.x_syn), "AliasedClass_Point.x_syn")
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(alias.x_syn).filter(alias.x_syn > Point.x_syn),
"SELECT point_1.x AS point_1_x FROM point AS point_1, point "
a2 = aliased(Point)
eq_(str(a2.x_syn == alias.x), "point_1.x = point_2.x")
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(alias).filter(alias.x_syn > Point.x),
eq_(str(Point.double_x.__clause_element__()), "point.x * :x_1")
eq_(str(alias.double_x.__clause_element__()), "point_1.x * :x_1")
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(alias).filter(alias.double_x > Point.x),
eq_(str(Point.double_x.__clause_element__()), "point.x * :x_1")
eq_(str(alias.double_x.__clause_element__()), "point_1.x * :x_1")
- sess = Session()
+ sess = fixture_session()
self.assert_compile(
sess.query(alias).filter(alias.double_x > Point.x),
users, User = self.tables.users, self.classes.User
mapper(User, users)
- s = create_session()
+ s = fixture_session()
u = User(name="u1")
s.add(u)
s.flush()
from sqlalchemy.orm import collections
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
-from sqlalchemy.orm import Session
from sqlalchemy.orm import validates
from sqlalchemy.testing import assert_raises
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import ne_
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.mock import call
from sqlalchemy.testing.mock import Mock
from test.orm import _fixtures
return name + " modified"
mapper(User, users)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="ed")
eq_(u1.name, "ed modified")
assert_raises(AssertionError, setattr, u1, "name", "fred")
mapper(User, users, properties={"addresses": relationship(Address)})
mapper(Address, addresses)
- sess = Session()
+ sess = fixture_session()
u1 = User(name="edward")
a0 = Address(email_address="noemail")
assert_raises(AssertionError, u1.addresses.append, a0)
from sqlalchemy import TypeDecorator
from sqlalchemy import util
from sqlalchemy.orm import configure_mappers
-from sqlalchemy.orm import create_session
from sqlalchemy.orm import exc as orm_exc
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
-from sqlalchemy.orm import sessionmaker
from sqlalchemy.testing import assert_raises
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import config
from sqlalchemy.testing import is_false
from sqlalchemy.testing import is_true
from sqlalchemy.testing.assertsql import CompiledSQL
+from sqlalchemy.testing.fixtures import fixture_session
from sqlalchemy.testing.mock import patch
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
version_id_generator=False,
)
- s1 = Session()
+ s1 = fixture_session()
return s1
def test_null_version_id_insert(self):
Foo, version_table = self.classes.Foo, self.tables.version_table
mapper(Foo, version_table, version_id_col=version_table.c.version_id)
- s1 = Session()
+ s1 = fixture_session()
return s1
@engines.close_open_connections
):
s1.commit()
- s2 = create_session(autocommit=False)
+ s2 = fixture_session(autocommit=False)
f1_s = s2.query(Foo).get(f1.id)
f1_s.value = "f1rev3"
with conditional_sane_rowcount_warnings(
s1.add(f1s1)
s1.commit()
- s2 = create_session(autocommit=False)
+ s2 = fixture_session(autocommit=False)
f1s2 = s2.query(Foo).get(f1s1.id)
f1s2.value = "f1 new value"
with conditional_sane_rowcount_warnings(
version_table = self.tables.version_table
mapper(Foo, version_table)
- s1 = Session()
+ s1 = fixture_session()
f1s1 = Foo(value="f1 value", version_id=1)
s1.add(f1s1)
s1.commit()
s1.add(f1s1)
s1.commit()
- s2 = create_session(autocommit=False)
+ s2 = fixture_session(autocommit=False)
f1s2 = s2.query(Foo).get(f1s1.id)
# not sure if I like this API
s2.refresh(f1s2, with_for_update=True)
Foo, version_table = self.classes.Foo, self.tables.version_table
- s1 = create_session(autocommit=False)
+ s1 = fixture_session(autocommit=False)
mapper(Foo, version_table)
f1s1 = Foo(value="foo", version_id=0)
s1.add(f1s1)
s1.commit()
- s2 = create_session(autocommit=False)
+ s2 = fixture_session(autocommit=False)
f1s2 = s2.query(Foo).with_for_update(read=True).get(f1s1.id)
assert f1s2.id == f1s1.id
assert f1s2.value == f1s1.value
version_id_col=node.c.version_id,
)
- s = Session()
+ s = fixture_session()
n1 = Node(id=1)
n2 = Node(id=2)
def _run_test(self, auto_version_counter=True):
A, B = self.classes("A", "B")
- s = Session()
+ s = fixture_session()
if auto_version_counter:
a1 = A()
else:
Foo, version_table = self.classes.Foo, self.tables.version_table
mapper(Foo, version_table, version_id_col=version_table.c.version_id)
- s1 = Session()
+ s1 = fixture_session()
return s1
@engines.close_open_connections
def test_row_switch(self):
P = self.classes.P
- session = sessionmaker()()
+ session = fixture_session()
session.add(P(id="P1", data="P version 1"))
session.commit()
session.close()
assert P.c.property.strategy.use_get
- session = sessionmaker()()
+ session = fixture_session()
session.add(P(id="P1", data="P version 1"))
session.commit()
session.close()
def test_row_switch(self):
P = self.classes.P
- session = sessionmaker()()
+ session = fixture_session()
session.add(P(id="P1", data="P version 1"))
session.commit()
session.close()
assert P.c.property.strategy.use_get
- session = sessionmaker()()
+ session = fixture_session()
session.add(P(id="P1", data="P version 1"))
session.commit()
session.close()
def test_child_row_switch_two(self):
P = self.classes.P
- Session = sessionmaker()
-
# TODO: not sure this test is
# testing exactly what its looking for
- sess1 = Session()
+ sess1 = fixture_session()
sess1.add(P(id="P1", data="P version 1"))
sess1.commit()
sess1.close()
p1 = sess1.query(P).first()
- sess2 = Session()
+ sess2 = fixture_session()
p2 = sess2.query(P).first()
sess1.delete(p1)
mapper(Base, base, version_id_col=base.c.version_id)
mapper(Sub, sub, inherits=Base)
- s = Session()
+ s = fixture_session()
s1 = Sub(data="b", sub_data="s")
s.add(s1)
s.commit()
mapper(Base, base, version_id_col=base.c.version_id)
mapper(Sub, sub, inherits=Base)
- session = Session()
+ session = fixture_session()
b1 = Base(data="b1")
session.add(b1)
session.commit()
eq_(b1.version_id, 1)
# base is populated
- eq_(select(base.c.version_id).scalar(), 1)
+ eq_(session.connection().scalar(select(base.c.version_id)), 1)
def test_sub_both(self):
Base, sub, base, Sub = (
mapper(Base, base, version_id_col=base.c.version_id)
mapper(Sub, sub, inherits=Base)
- session = Session()
+ session = fixture_session()
s1 = Sub(data="s1", sub_data="s1")
session.add(s1)
session.commit()
# table is populated
- eq_(select(sub.c.version_id).scalar(), 1)
+ eq_(session.connection().scalar(select(sub.c.version_id)), 1)
# base is populated
- eq_(select(base.c.version_id).scalar(), 1)
+ eq_(session.connection().scalar(select(base.c.version_id)), 1)
def test_sub_only(self):
Base, sub, base, Sub = (
mapper(Base, base)
mapper(Sub, sub, inherits=Base, version_id_col=sub.c.version_id)
- session = Session()
+ session = fixture_session()
s1 = Sub(data="s1", sub_data="s1")
session.add(s1)
session.commit()
# table is populated
- eq_(select(sub.c.version_id).scalar(), 1)
+ eq_(session.connection().scalar(select(sub.c.version_id)), 1)
# base is not
- eq_(select(base.c.version_id).scalar(), None)
+ eq_(session.connection().scalar(select(base.c.version_id)), None)
def test_mismatch_version_col_warning(self):
Base, sub, base, Sub = (
eager_defaults=eager_defaults,
)
- s1 = Session(expire_on_commit=expire_on_commit)
+ s1 = fixture_session(expire_on_commit=expire_on_commit)
return s1
def test_insert_col(self):
f1.value
- s2 = Session()
+ s2 = fixture_session()
f2 = s2.query(self.classes.Foo).first()
f2.value = "f2"
s2.commit()
# a SELECT for it within the flush.
f1.value
- s2 = Session(expire_on_commit=False)
+ s2 = fixture_session(expire_on_commit=False)
f2 = s2.query(self.classes.Foo).first()
f2.value = "f2"
s2.commit()
)
def test_insert(self):
- sess = Session()
+ sess = fixture_session()
a1 = self.classes.A()
a1.vid = 1
eq_(a1.vid, 1)
def test_update(self):
- sess = Session()
+ sess = fixture_session()
a1 = self.classes.A()
a1.vid = 1
@testing.requires.sane_rowcount_w_returning
def test_update_concurrent_check(self):
- sess = Session()
+ sess = fixture_session()
a1 = self.classes.A()
a1.vid = 1
assert_raises(orm_exc.StaleDataError, sess.commit)
def test_update_version_conditional(self):
- sess = Session()
+ sess = fixture_session()
a1 = self.classes.A()
a1.vid = 1
mapper(cls.classes.B, cls.tables.b, inherits=cls.classes.A)
def test_no_increment(self):
- sess = Session()
+ sess = fixture_session()
b1 = self.classes.B()
b1.vid = 1
)
mapper(Foo, current, version_id_col=version_table.c.version_id)
- s1 = Session()
+ s1 = fixture_session()
return s1
def _explicit_version_fixture(self):
version_id_col=version_table.c.version_id,
version_id_generator=False,
)
- s1 = Session()
+ s1 = fixture_session()
return s1
def test_implicit(self):
@testing.fails_on_everything_except("postgresql")
def test_as_from(self, connection):
# TODO: shouldn't this work on oracle too ?
- x = connection.execute(func.current_date(bind=testing.db)).scalar()
- y = connection.execute(
- func.current_date(bind=testing.db).select()
- ).scalar()
- z = connection.scalar(func.current_date(bind=testing.db))
- w = connection.scalar(
- select("*").select_from(func.current_date(bind=testing.db))
- )
+ x = connection.execute(func.current_date()).scalar()
+ y = connection.execute(func.current_date().select()).scalar()
+ z = connection.scalar(func.current_date())
+ w = connection.scalar(select("*").select_from(func.current_date()))
assert x == y == z == w
def test_compiled_execute(self, connection):
users = self.tables.users
connection.execute(users.insert(), user_id=7, user_name="jack")
- s = select(users).where(users.c.user_id == bindparam("id")).compile()
+ s = (
+ select(users)
+ .where(users.c.user_id == bindparam("id"))
+ .compile(connection)
+ )
eq_(connection.execute(s, id=7).first()._mapping["user_id"], 7)
def test_compiled_insert_execute(self, connection):
users = self.tables.users
connection.execute(
- users.insert().compile(), user_id=7, user_name="jack"
+ users.insert().compile(connection), user_id=7, user_name="jack"
+ )
+ s = (
+ select(users)
+ .where(users.c.user_id == bindparam("id"))
+ .compile(connection)
)
- s = select(users).where(users.c.user_id == bindparam("id")).compile()
eq_(connection.execute(s, id=7).first()._mapping["user_id"], 7)
def test_repeated_bindparams(self, connection):
def test_drop_ordering(self):
with self.sql_execution_asserter(testing.db) as asserter:
- self.tables_test_metadata.drop_all(checkfirst=False)
+ self.tables_test_metadata.drop_all(testing.db, checkfirst=False)
asserter.assert_(
AllOf(
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
