return cfg_cls(registry, cls_, dict_, table, mapper_kw)
- def __init__(self, registry, cls_):
- self.cls = cls_
+ def __init__(self, registry, cls_, mapper_kw):
+ self.cls = util.assert_arg_type(cls_, type, "cls_")
self.classname = cls_.__name__
self.properties = util.OrderedDict()
self.declared_attr_reg = {}
- instrumentation.register_class(
- self.cls,
- finalize=False,
- registry=registry,
- declarative_scan=self,
- init_method=registry.constructor,
- )
+ if not mapper_kw.get("non_primary", False):
+ instrumentation.register_class(
+ self.cls,
+ finalize=False,
+ registry=registry,
+ declarative_scan=self,
+ init_method=registry.constructor,
+ )
+ else:
+ manager = attributes.manager_of_class(self.cls)
+ if not manager or not manager.is_mapped:
+ raise exc.InvalidRequestError(
+ "Class %s has no primary mapper configured. Configure "
+ "a primary mapper first before setting up a non primary "
+ "Mapper." % self.cls
+ )
def set_cls_attribute(self, attrname, value):
table,
mapper_kw,
):
- super(_ImperativeMapperConfig, self).__init__(registry, cls_)
+ super(_ImperativeMapperConfig, self).__init__(
+ registry, cls_, mapper_kw
+ )
self.dict_ = {}
self.local_table = self.set_cls_attribute("__table__", table)
with mapperlib._CONFIGURE_MUTEX:
- clsregistry.add_class(
- self.classname, self.cls, registry._class_registry
- )
+ if not mapper_kw.get("non_primary", False):
+ clsregistry.add_class(
+ self.classname, self.cls, registry._class_registry
+ )
self._setup_inheritance(mapper_kw)
mapper_kw,
):
- super(_ClassScanMapperConfig, self).__init__(registry, cls_)
+ super(_ClassScanMapperConfig, self).__init__(registry, cls_, mapper_kw)
self.dict_ = dict(dict_) if dict_ else {}
self.persist_selectable = None
@classmethod
def _setup_once_mappers(cls):
if cls.run_setup_mappers == "once":
- cls.mapper = cls._generate_mapper()
+ cls.mapper_registry, cls.mapper = cls._generate_registry()
cls._with_register_classes(cls.setup_mappers)
def _setup_each_mappers(self):
+ if self.run_setup_mappers != "once":
+ (
+ self.__class__.mapper_registry,
+ self.__class__.mapper,
+ ) = self._generate_registry()
+
if self.run_setup_mappers == "each":
- self.__class__.mapper = self._generate_mapper()
self._with_register_classes(self.setup_mappers)
def _setup_each_classes(self):
self._with_register_classes(self.setup_classes)
@classmethod
- def _generate_mapper(cls):
- decl = registry()
- return decl.map_imperatively
+ def _generate_registry(cls):
+ decl = registry(metadata=cls._tables_metadata)
+ return decl, decl.map_imperatively
@classmethod
def _with_register_classes(cls, fn):
self = request.instance
- # 1. run outer xdist-style setup
+ # before this fixture runs:
+
+ # 1. function level "autouse" fixtures under py3k (examples: TablesTest
+ # define tables / data, MappedTest define tables / mappers / data)
+
+ # 2. run homegrown function level "autouse" fixtures under py2k
+ if py2k:
+ reinvent_fixtures_py2k.run_fn_fixture_setup(request)
+
+ # 3. run outer xdist-style setup
if hasattr(self, "setup_test"):
asyncio._maybe_async(self.setup_test)
if hasattr(self, "setUp"):
asyncio._maybe_async(self.setUp)
- # 2. run homegrown function level "autouse" fixtures under py2k
- if py2k:
- reinvent_fixtures_py2k.run_fn_fixture_setup(request)
-
# inside the yield:
-
- # 3. function level "autouse" fixtures under py3k (examples: TablesTest
- # define tables / data, MappedTest define tables / mappers / data)
-
# 4. function level fixtures defined on test functions themselves,
# e.g. "connection", "metadata" run next
# yield finishes:
- # 7. pytest hook pytest_runtest_teardown hook runs, this is associated
+ # 7. function level fixtures defined on test functions
+ # themselves, e.g. "connection" rolls back the transaction, "metadata"
+ # emits drop all
+
+ # 8. pytest hook pytest_runtest_teardown hook runs, this is associated
# with fixtures close all sessions, provisioning.stop_test_class(),
# engines.testing_reaper -> ensure all connection pool connections
# are returned, engines created by testing_engine that aren't the
# config engine are disposed
- # 8. function level fixtures defined on test functions
- # themselves, e.g. "connection" rolls back the transaction, "metadata"
- # emits drop all
-
- # 9. function level "autouse" fixtures under py3k (examples: TablesTest /
- # MappedTest delete table data, possibly drop tables and clear mappers
- # depending on the flags defined by the test class)
-
- # 10. run homegrown function-level "autouse" fixtures under py2k
- if py2k:
- reinvent_fixtures_py2k.run_fn_fixture_teardown(request)
-
asyncio._maybe_async(plugin_base.after_test_fixtures, self)
- # 11. run outer xdist-style teardown
+ # 10. run xdist-style teardown
if hasattr(self, "tearDown"):
asyncio._maybe_async(self.tearDown)
if hasattr(self, "teardown_test"):
asyncio._maybe_async(self.teardown_test)
+ # 11. run homegrown function-level "autouse" fixtures under py2k
+ if py2k:
+ reinvent_fixtures_py2k.run_fn_fixture_teardown(request)
+
+ # 12. function level "autouse" fixtures under py3k (examples: TablesTest /
+ # MappedTest delete table data, possibly drop tables and clear mappers
+ # depending on the flags defined by the test class)
+
def getargspec(fn):
if sys.version_info.major == 3:
# be "error" however for I98b8defdf7c37b818b3824d02f7668e3f5f31c94
# we are moving one at a time
for msg in [
- #
- # ORM configuration
- #
- r"Calling the mapper\(\) function directly outside of a "
- "declarative registry",
#
# ORM Query
#
from sqlalchemy.orm import join as orm_join
from sqlalchemy.orm import joinedload
from sqlalchemy.orm import Load
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import selectinload
from sqlalchemy.orm import Session
go()
-class MemUsageWBackendTest(EnsureZeroed):
+class MemUsageWBackendTest(fixtures.MappedTest, EnsureZeroed):
__tags__ = ("memory_intensive",)
__requires__ = "cpython", "memory_process_intensive", "no_asyncio"
metadata.create_all(self.engine)
- m1 = mapper(
+ m1 = self.mapper_registry.map_imperatively(
A,
table1,
properties={
)
},
)
- m2 = mapper(B, table2)
+ m2 = self.mapper_registry.map_imperatively(B, table2)
@profile_memory()
def go():
metadata.create_all()
- m1 = mapper(
+ m1 = self.mapper_registry.map_imperatively(
A,
table1,
properties={
},
_compiled_cache_size=50,
)
- m2 = mapper(B, table2, _compiled_cache_size=50)
+ m2 = self.mapper_registry.map_imperatively(
+ B, table2, _compiled_cache_size=50
+ )
@profile_memory()
def go():
class Wide(object):
pass
- mapper(Wide, wide_table, _compiled_cache_size=10)
+ self.mapper_registry.map_imperatively(
+ Wide, wide_table, _compiled_cache_size=10
+ )
metadata.create_all(self.engine)
with Session(self.engine) as session:
class SomeClass(object):
pass
- mapper(SomeClass, some_table)
+ self.mapper_registry.map_imperatively(SomeClass, some_table)
metadata.create_all(self.engine)
@profile_memory()
def go():
- mapper(
+ self.mapper_registry.map_imperatively(
A,
table1,
properties={"bs": relationship(B, order_by=table2.c.col1)},
)
- mapper(B, table2)
+ self.mapper_registry.map_imperatively(B, table2)
sess = create_session(self.engine)
a1 = A(col2="a1")
"id", Integer, primary_key=True, test_needs_autoincrement=True
),
)
- mapper(A, a, polymorphic_identity="a", polymorphic_on=a.c.type)
- mapper(ASub, asub, inherits=A, polymorphic_identity="asub")
- mapper(B, b, properties={"as_": relationship(A)})
+ self.mapper_registry.map_imperatively(
+ A, a, polymorphic_identity="a", polymorphic_on=a.c.type
+ )
+ self.mapper_registry.map_imperatively(
+ ASub, asub, inherits=A, polymorphic_identity="asub"
+ )
+ self.mapper_registry.map_imperatively(
+ B, b, properties={"as_": relationship(A)}
+ )
metadata.create_all(self.engine)
sess = Session(self.engine)
Column("id", Integer, primary_key=True),
Column("a_id", ForeignKey("a.id")),
)
- m1 = mapper(A, a, properties={"bs": relationship(B)})
- mapper(B, b)
+ m1 = self.mapper_registry.map_imperatively(
+ A, a, properties={"bs": relationship(B)}
+ )
+ self.mapper_registry.map_imperatively(B, b)
@profile_memory()
def go():
class B(A):
pass
- mapper(
+ clear_mappers()
+ self.mapper_registry.map_imperatively(
A,
table1,
polymorphic_on=table1.c.col2,
polymorphic_identity="a",
)
- mapper(B, table2, inherits=A, polymorphic_identity="b")
+ self.mapper_registry.map_imperatively(
+ B, table2, inherits=A, polymorphic_identity="b"
+ )
sess = create_session(self.engine)
a1 = A()
class B(fixtures.ComparableEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
A,
table1,
properties={
)
},
)
- mapper(B, table2)
+ self.mapper_registry.map_imperatively(B, table2)
sess = create_session(self.engine)
a1 = A(col2="a1")
class T1(object):
pass
- t1_mapper = mapper(T1, t1)
+ t1_mapper = self.mapper_registry.map_imperatively(T1, t1)
@testing.emits_warning()
@profile_memory()
class T2(object):
pass
- t2_mapper = mapper(T2, t2)
+ t2_mapper = self.mapper_registry.map_imperatively(T2, t2)
t1_mapper.add_property("bar", relationship(t2_mapper))
s1 = Session(testing.db)
# this causes the path_registry to be invoked
class Bar(object):
pass
- mapper(
- Foo, table1, properties={"bars": relationship(mapper(Bar, table2))}
+ self.mapper_registry.map_imperatively(
+ Foo,
+ table1,
+ properties={
+ "bars": relationship(
+ self.mapper_registry.map_imperatively(Bar, table2)
+ )
+ },
)
metadata.create_all(self.engine)
session = sessionmaker(self.engine)
class Bar(object):
pass
- mapper(
- Foo, table1, properties={"bars": relationship(mapper(Bar, table2))}
+ self.mapper_registry.map_imperatively(
+ Foo,
+ table1,
+ properties={
+ "bars": relationship(
+ self.mapper_registry.map_imperatively(Bar, table2)
+ )
+ },
)
metadata.create_all(self.engine)
session = sessionmaker(self.engine)
def user_name(self):
return self.name
- mapper(Foo, users)
+ self.mapper_registry.map_imperatively(Foo, users)
# unfortunately there's a lot of cycles with an aliased()
# for now, however calling upon clause_element does not seem
+import sqlalchemy
from sqlalchemy import Column
from sqlalchemy import Enum
from sqlalchemy import ForeignKey
from sqlalchemy import Table
from sqlalchemy import testing
from sqlalchemy.orm import join as ormjoin
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
# a whole new model of setup/teardown, since pytest "fixture"
# sort of purposely works badly with setup/teardown
+ registry = sqlalchemy.orm.registry()
+
metadata = MetaData()
parent = Table(
"parent",
class Child(testing.entities.BasicEntity):
pass
- mapper(
+ registry.map_imperatively(
Parent,
parent,
properties={"children": relationship(Child, backref="parent")},
)
- mapper(Child, child)
+ registry.map_imperatively(Child, child)
+
+ yield Parent, Child
- return Parent, Child
+ registry.dispose()
@testing.fixture(scope="function")
def stmt_fixture_one(self, mapping_fixture):
from sqlalchemy.orm import join as orm_join
from sqlalchemy.orm import joinedload
from sqlalchemy.orm import Load
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import selectinload
from sqlalchemy.orm import Session
cls.tables.child,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Parent,
parent,
properties={"children": relationship(Child, backref="parent")},
)
- mapper(Child, child)
+ cls.mapper_registry.map_imperatively(Child, child)
@classmethod
def insert_data(cls, connection):
cls.tables.child,
)
- mapper(Parent, parent, properties={"child": relationship(Child)})
- mapper(Child, child)
+ cls.mapper_registry.map_imperatively(
+ Parent, parent, properties={"child": relationship(Child)}
+ )
+ cls.mapper_registry.map_imperatively(Child, child)
@classmethod
def insert_data(cls, connection):
def setup_mappers(cls):
A, B, C, D = cls.classes.A, cls.classes.B, cls.classes.C, cls.classes.D
a, b, c, d = cls.tables.a, cls.tables.b, cls.tables.c, cls.tables.d
- mapper(
+ cls.mapper_registry.map_imperatively(
A,
a,
properties={
"ds": relationship(D, backref="a"),
},
)
- mapper(B, b)
- mapper(C, c)
- mapper(D, d)
+ cls.mapper_registry.map_imperatively(B, b)
+ cls.mapper_registry.map_imperatively(C, c)
+ cls.mapper_registry.map_imperatively(D, d)
@classmethod
def insert_data(cls, connection):
def setup_mappers(cls):
A = cls.classes.A
a = cls.tables.a
- mapper(A, a)
+ cls.mapper_registry.map_imperatively(A, a)
@classmethod
def insert_data(cls, connection):
cls.tables.child,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Parent,
parent,
properties={"children": relationship(Child, backref="parent")},
)
- mapper(Child, child)
+ cls.mapper_registry.map_imperatively(Child, child)
def test_attribute_set(self):
Parent, Child = self.classes.Parent, self.classes.Child
cls.tables.child,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Parent,
parent,
properties={"children": relationship(Child, backref="parent")},
)
- mapper(Child, child)
+ cls.mapper_registry.map_imperatively(Child, child)
def test_expire_lots(self):
Parent, Child = self.classes.Parent, self.classes.Child
Parent = cls.classes.Parent
parent = cls.tables.parent
- mapper(Parent, parent)
+ cls.mapper_registry.map_imperatively(Parent, parent)
def _fixture(self):
Parent = self.classes.Parent
A, B, C = cls.classes("A", "B", "C")
a, b, c = cls.tables("a", "b", "c")
- mapper(A, a, properties={"bs": relationship(B)})
- mapper(B, b, properties={"cs": relationship(C)})
- mapper(C, c)
+ cls.mapper_registry.map_imperatively(
+ A, a, properties={"bs": relationship(B)}
+ )
+ cls.mapper_registry.map_imperatively(
+ B, b, properties={"cs": relationship(C)}
+ )
+ cls.mapper_registry.map_imperatively(C, c)
@classmethod
def insert_data(cls, connection):
A, B, C, D, E, F, G = cls.classes("A", "B", "C", "D", "E", "F", "G")
a, b, c, d, e, f, g = cls.tables("a", "b", "c", "d", "e", "f", "g")
- mapper(A, a, properties={"bs": relationship(B), "es": relationship(E)})
- mapper(B, b, properties={"cs": relationship(C)})
- mapper(C, c, properties={"ds": relationship(D)})
- mapper(D, d)
- mapper(E, e, properties={"fs": relationship(F), "gs": relationship(G)})
- mapper(F, f)
- mapper(G, g)
+ cls.mapper_registry.map_imperatively(
+ A, a, properties={"bs": relationship(B), "es": relationship(E)}
+ )
+ cls.mapper_registry.map_imperatively(
+ B, b, properties={"cs": relationship(C)}
+ )
+ cls.mapper_registry.map_imperatively(
+ C, c, properties={"ds": relationship(D)}
+ )
+ cls.mapper_registry.map_imperatively(D, d)
+ cls.mapper_registry.map_imperatively(
+ E, e, properties={"fs": relationship(F), "gs": relationship(G)}
+ )
+ cls.mapper_registry.map_imperatively(F, f)
+ cls.mapper_registry.map_imperatively(G, g)
@classmethod
def insert_data(cls, connection):
A, B, C, D, E, F, G = cls.classes("A", "B", "C", "D", "E", "F", "G")
a, b, c, d, e, f, g = cls.tables("a", "b", "c", "d", "e", "f", "g")
- mapper(A, a, properties={"bs": relationship(B), "gs": relationship(G)})
- mapper(
+ cls.mapper_registry.map_imperatively(
+ A, a, properties={"bs": relationship(B), "gs": relationship(G)}
+ )
+ cls.mapper_registry.map_imperatively(
B,
b,
properties={
"fs": relationship(F),
},
)
- mapper(C, c)
- mapper(D, d)
- mapper(E, e)
- mapper(F, f)
- mapper(G, g)
+ cls.mapper_registry.map_imperatively(C, c)
+ cls.mapper_registry.map_imperatively(D, d)
+ cls.mapper_registry.map_imperatively(E, e)
+ cls.mapper_registry.map_imperatively(F, f)
+ cls.mapper_registry.map_imperatively(G, g)
configure_mappers()
A = cls.classes.A
a = cls.tables.a
- mapper(A, a)
+ cls.mapper_registry.map_imperatively(A, a)
@classmethod
def insert_data(cls, connection):
from sqlalchemy.dialects.postgresql.base import PGDialect
from sqlalchemy.dialects.postgresql.psycopg2 import PGDialect_psycopg2
from sqlalchemy.orm import aliased
-from sqlalchemy.orm import mapper
+from sqlalchemy.orm import clear_mappers
from sqlalchemy.orm import Session
from sqlalchemy.sql import column
from sqlalchemy.sql import literal_column
)
-class DistinctOnTest(fixtures.TestBase, AssertsCompiledSQL):
+class DistinctOnTest(fixtures.MappedTest, AssertsCompiledSQL):
"""Test 'DISTINCT' with SQL expression language and orm.Query with
an emphasis on PG's 'DISTINCT ON' syntax.
class Foo(object):
pass
- mapper(Foo, self.table)
+ clear_mappers()
+ self.mapper_registry.map_imperatively(Foo, self.table)
sess = Session()
subq = sess.query(Foo).subquery()
class Foo(object):
pass
- mapper(Foo, self.table)
+ self.mapper_registry.map_imperatively(Foo, self.table)
a1 = aliased(Foo)
sess = Session()
self.assert_compile(
)
self._assert_data([{r"key \"foo\"": r'value \"bar"\ xyz'}], connection)
- def test_orm_round_trip(self, connection):
- from sqlalchemy import orm
-
+ def test_orm_round_trip(self, registry):
class Data(object):
def __init__(self, name, data):
self.name = name
self.data = data
- orm.mapper(Data, self.tables.data_table)
+ registry.map_imperatively(Data, self.tables.data_table)
- with orm.Session(connection) as s:
+ with fixtures.fixture_session() as s:
d = Data(
name="r1",
data={"key1": "value1", "key2": "value2", "key3": "value3"},
return iter(self.values)
-class AutoFlushTest(fixtures.TablesTest):
+class AutoFlushTest(fixtures.MappedTest):
@classmethod
def define_tables(cls, metadata):
Table(
Column("name", String(50)),
)
- def teardown_test(self):
- clear_mappers()
-
def _fixture(self, collection_class, is_dict=False):
class Parent(object):
collection = association_proxy("_collection", "child")
def __init__(self, child):
self.child = child
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
self.tables.parent,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Association,
self.tables.association,
properties={"child": relationship(Child, backref="association")},
)
- mapper(Child, self.tables.child)
+ self.mapper_registry.map_imperatively(Child, self.tables.child)
return Parent, Child, Association
)
-class _CollectionOperations(fixtures.TestBase):
- def setup_test(self):
- collection_class = self.collection_class
-
- metadata = MetaData()
-
- parents_table = Table(
+class _CollectionOperations(fixtures.MappedTest):
+ @classmethod
+ def define_tables(cls, metadata):
+ Table(
"Parent",
metadata,
Column(
),
Column("name", String(128)),
)
- children_table = Table(
+ Table(
"Children",
metadata,
Column(
Column("name", String(128)),
)
- class Parent(object):
+ @classmethod
+ def setup_mappers(cls):
+ collection_class = cls.collection_class
+
+ class Parent(cls.Basic):
children = association_proxy("_children", "name")
def __init__(self, name):
self.name = name
- class Child(object):
+ class Child(cls.Basic):
if collection_class and issubclass(collection_class, dict):
def __init__(self, foo, name):
def __init__(self, name):
self.name = name
- mapper(
+ parents_table, children_table = cls.tables("Parent", "Children")
+ cls.mapper_registry.map_imperatively(
Parent,
parents_table,
properties={
)
},
)
- mapper(Child, children_table)
-
- metadata.create_all(testing.db)
-
- self.metadata = metadata
- self.session = fixture_session()
- self.Parent, self.Child = Parent, Child
-
- def teardown_test(self):
- self.metadata.drop_all(testing.db)
+ cls.mapper_registry.map_imperatively(Child, children_table)
def roundtrip(self, obj):
if obj not in self.session:
return self.session.query(type_).get(id_)
def _test_sequence_ops(self):
- Parent, Child = self.Parent, self.Child
+ Parent, Child = self.classes("Parent", "Child")
+ self.session = fixture_session()
p1 = Parent("P1")
collection_class = DictCollection
def test_mapping_ops(self):
- Parent, Child = self.Parent, self.Child
+ Parent, Child = self.classes("Parent", "Child")
+
+ self.session = fixture_session()
p1 = Parent("P1")
assert_raises(TypeError, set, [p1.children])
def test_bulk_replace(self):
- Parent = self.Parent
+ Parent = self.classes.Parent
p1 = Parent("foo")
p1.children = {"a": "v a", "b": "v b", "c": "v c"}
collection_class = set
def test_set_operations(self):
- Parent, Child = self.Parent, self.Child
+ Parent, Child = self.classes.Parent, self.classes.Child
+
+ self.session = fixture_session()
p1 = Parent("P1")
assert_raises(TypeError, set, [p1.children])
def test_set_comparisons(self):
- Parent = self.Parent
+ Parent = self.classes.Parent
p1 = Parent("P1")
p1.children = ["a", "b", "c"]
@testing.requires.python_fixed_issue_8743
def test_set_comparison_empty_to_empty(self):
# test issue #3265 which was fixed in Python version 2.7.8
- Parent = self.Parent
+ Parent = self.classes.Parent
p1 = Parent("P1")
p1.children = []
is_(set_0 != set_a, False)
def test_set_mutation(self):
- Parent = self.Parent
+ Parent = self.classes.Parent
+
+ self.session = fixture_session()
# mutations
for op in (
raise
def test_bulk_replace(self):
- Parent = self.Parent
+ Parent = self.classes.Parent
p1 = Parent("foo")
p1.children = {"a", "b", "c"}
collection_class = ObjectCollection
def test_basic(self):
- Parent = self.Parent
+ Parent = self.classes.Parent
+
+ self.session = fixture_session()
p = Parent("p1")
self.assert_(len(list(p.children)) == 0)
class ProxyFactoryTest(ListTest):
- def setup_test(self):
- metadata = MetaData()
-
- parents_table = Table(
+ @classmethod
+ def define_tables(cls, metadata):
+ Table(
"Parent",
metadata,
Column(
),
Column("name", String(128)),
)
- children_table = Table(
+ Table(
"Children",
metadata,
Column(
Column("name", String(128)),
)
+ @classmethod
+ def setup_mappers(cls):
+ parents_table, children_table = cls.tables("Parent", "Children")
+
class CustomProxy(_AssociationList):
def __init__(self, lazy_collection, creator, value_attr, parent):
getter, setter = parent._default_getset(lazy_collection)
self, lazy_collection, creator, getter, setter, parent
)
- class Parent(object):
+ class Parent(cls.Basic):
children = association_proxy(
"_children",
"name",
def __init__(self, name):
self.name = name
- class Child(object):
+ class Child(cls.Basic):
def __init__(self, name):
self.name = name
- mapper(
+ cls.mapper_registry.map_imperatively(
Parent,
parents_table,
properties={
)
},
)
- mapper(Child, children_table)
-
- metadata.create_all(testing.db)
-
- self.metadata = metadata
- self.session = fixture_session()
- self.Parent, self.Child = Parent, Child
+ cls.mapper_registry.map_imperatively(Child, children_table)
def test_sequence_ops(self):
self._test_sequence_ops()
-class ScalarTest(fixtures.TestBase):
+class ScalarTest(fixtures.MappedTest):
@testing.provide_metadata
def test_scalar_proxy(self):
metadata = self.metadata
for attr in kw:
setattr(self, attr, kw[attr])
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
parents_table,
properties={
)
},
)
- mapper(Child, children_table)
+ self.mapper_registry.map_imperatively(Child, children_table)
metadata.create_all(testing.db)
session = fixture_session()
class B(object):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
A, a, properties=dict(a2b_single=relationship(A2B, uselist=False))
)
- mapper(A2B, a2b, properties=dict(b=relationship(B)))
- mapper(B, b)
+ self.mapper_registry.map_imperatively(
+ A2B, a2b, properties=dict(b=relationship(B))
+ )
+ self.mapper_registry.map_imperatively(B, b)
a1 = A()
assert a1.a2b_name is None
def __init__(self, foo):
self.foo = foo
- mapper(Parent, p, properties={"child": relationship(Child)})
- mapper(Child, c)
+ self.mapper_registry.map_imperatively(
+ Parent, p, properties={"child": relationship(Child)}
+ )
+ self.mapper_registry.map_imperatively(Child, c)
p1 = Parent()
eq_(set_.mock_calls, [call(child, "y")])
-class LazyLoadTest(fixtures.TestBase):
- def setup_test(self):
- metadata = MetaData()
+class LazyLoadTest(fixtures.MappedTest):
+ @classmethod
+ def define_tables(cls, metadata):
- parents_table = Table(
+ Table(
"Parent",
metadata,
Column(
),
Column("name", String(128)),
)
- children_table = Table(
+ Table(
"Children",
metadata,
Column(
Column("name", String(128)),
)
- class Parent(object):
+ @classmethod
+ def setup_mappers(cls):
+ class Parent(cls.Basic):
children = association_proxy("_children", "name")
def __init__(self, name):
self.name = name
- class Child(object):
+ class Child(cls.Basic):
def __init__(self, name):
self.name = name
- mapper(Child, children_table)
- metadata.create_all(testing.db)
-
- self.metadata = metadata
- self.session = fixture_session()
- self.Parent, self.Child = Parent, Child
- self.table = parents_table
-
- def teardown_test(self):
- self.metadata.drop_all(testing.db)
+ cls.mapper_registry.map_imperatively(Child, cls.tables.Children)
def roundtrip(self, obj):
self.session.add(obj)
return self.session.query(type_).get(id_)
def test_lazy_list(self):
- Parent, Child = self.Parent, self.Child
+ Parent, Child = self.classes("Parent", "Child")
- mapper(
+ self.session = fixture_session()
+
+ self.mapper_registry.map_imperatively(
Parent,
- self.table,
+ self.tables.Parent,
properties={
"_children": relationship(
Child, lazy="select", collection_class=list
self.assert_("_children" in p.__dict__)
def test_eager_list(self):
- Parent, Child = self.Parent, self.Child
+ Parent, Child = self.classes("Parent", "Child")
- mapper(
+ self.session = fixture_session()
+
+ self.mapper_registry.map_imperatively(
Parent,
- self.table,
+ self.tables.Parent,
properties={
"_children": relationship(
Child, lazy="joined", collection_class=list
self.assert_(len(p._children) == 3)
def test_slicing_list(self):
- Parent, Child = self.Parent, self.Child
+ Parent, Child = self.classes("Parent", "Child")
- mapper(
+ self.session = fixture_session()
+
+ self.mapper_registry.map_imperatively(
Parent,
- self.table,
+ self.tables.Parent,
properties={
"_children": relationship(
Child, lazy="select", collection_class=list
eq_(["b", "c"], p.children[-2:])
def test_lazy_scalar(self):
- Parent, Child = self.Parent, self.Child
+ Parent, Child = self.classes("Parent", "Child")
- mapper(
+ self.session = fixture_session()
+
+ self.mapper_registry.map_imperatively(
Parent,
- self.table,
+ self.tables.Parent,
properties={
"_children": relationship(Child, lazy="select", uselist=False)
},
self.assert_(p._children is not None)
def test_eager_scalar(self):
- Parent, Child = self.Parent, self.Child
+ Parent, Child = self.classes("Parent", "Child")
- mapper(
+ self.session = fixture_session()
+
+ self.mapper_registry.map_imperatively(
Parent,
- self.table,
+ self.tables.Parent,
properties={
"_children": relationship(Child, lazy="joined", uselist=False)
},
Parent.kids = association_proxy("children", "name")
def test_weak_identity_map(self):
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
self.tables.parents,
properties=dict(children=relationship(Child)),
)
- mapper(Child, self.tables.children)
+ self.mapper_registry.map_imperatively(Child, self.tables.children)
session = fixture_session()
def add_child(parent_name, child_name):
assert set(p.kids) == set(["c1", "c2"]), p.kids
def test_copy(self):
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
self.tables.parents,
properties=dict(children=relationship(Child)),
)
- mapper(Child, self.tables.children)
+ self.mapper_registry.map_imperatively(Child, self.tables.children)
p = Parent("p1")
p.kids.extend(["c1", "c2"])
p_copy = copy.copy(p)
assert set(p_copy.kids) == set(["c1", "c2"]), p_copy.kids
def test_pickle_list(self):
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
self.tables.parents,
properties=dict(children=relationship(Child)),
)
- mapper(Child, self.tables.children)
+ self.mapper_registry.map_imperatively(Child, self.tables.children)
p = Parent("p1")
p.kids.extend(["c1", "c2"])
r1 = pickle.loads(pickle.dumps(p))
# assert r2 == ['c1', 'c2']
def test_pickle_set(self):
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
self.tables.parents,
properties=dict(
children=relationship(Child, collection_class=set)
),
)
- mapper(Child, self.tables.children)
+ self.mapper_registry.map_imperatively(Child, self.tables.children)
p = Parent("p1")
p.kids.update(["c1", "c2"])
r1 = pickle.loads(pickle.dumps(p))
# assert r2 == set(['c1', 'c2'])
def test_pickle_dict(self):
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
self.tables.parents,
properties=dict(
)
),
)
- mapper(KVChild, self.tables.children)
+ self.mapper_registry.map_imperatively(KVChild, self.tables.children)
p = Parent("p1")
p.kids.update({"c1": "v1", "c2": "v2"})
assert p.kids == {"c1": "c1", "c2": "c2"}
cls.classes.Singular,
)
- mapper(User, users, properties={"singular": relationship(Singular)})
- mapper(
+ cls.mapper_registry.map_imperatively(
+ User, users, properties={"singular": relationship(Singular)}
+ )
+ cls.mapper_registry.map_imperatively(
Keyword,
keywords,
properties={
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
UserKeyword,
userkeywords,
properties={
),
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Singular, singular, properties={"keywords": relationship(Keyword)}
)
)
-class DictOfTupleUpdateTest(fixtures.TestBase):
- def setup_test(self):
- class B(object):
- def __init__(self, key, elem):
- self.key = key
- self.elem = elem
-
- class A(object):
- elements = association_proxy("orig", "elem", creator=B)
+class DictOfTupleUpdateTest(fixtures.MappedTest):
+ run_create_tables = None
- m = MetaData()
- a = Table("a", m, Column("id", Integer, primary_key=True))
- b = Table(
+ @classmethod
+ def define_tables(cls, metadata):
+ Table("a", metadata, Column("id", Integer, primary_key=True))
+ Table(
"b",
- m,
+ metadata,
Column("id", Integer, primary_key=True),
Column("aid", Integer, ForeignKey("a.id")),
Column("elem", String),
)
- mapper(
+
+ @classmethod
+ def setup_mappers(cls):
+ a, b = cls.tables("a", "b")
+
+ class B(cls.Basic):
+ def __init__(self, key, elem):
+ self.key = key
+ self.elem = elem
+
+ class A(cls.Basic):
+ elements = association_proxy("orig", "elem", creator=B)
+
+ cls.mapper_registry.map_imperatively(
A,
a,
properties={
)
},
)
- mapper(B, b)
- self.A = A
- self.B = B
+ cls.mapper_registry.map_imperatively(B, b)
def test_update_one_elem_dict(self):
- a1 = self.A()
+
+ a1 = self.classes.A()
a1.elements.update({("B", 3): "elem2"})
eq_(a1.elements, {("B", 3): "elem2"})
def test_update_multi_elem_dict(self):
- a1 = self.A()
+ a1 = self.classes.A()
a1.elements.update({("B", 3): "elem2", ("C", 4): "elem3"})
eq_(a1.elements, {("B", 3): "elem2", ("C", 4): "elem3"})
def test_update_one_elem_list(self):
- a1 = self.A()
+ a1 = self.classes.A()
a1.elements.update([(("B", 3), "elem2")])
eq_(a1.elements, {("B", 3): "elem2"})
def test_update_multi_elem_list(self):
- a1 = self.A()
+ a1 = self.classes.A()
a1.elements.update([(("B", 3), "elem2"), (("C", 4), "elem3")])
eq_(a1.elements, {("B", 3): "elem2", ("C", 4): "elem3"})
def test_update_one_elem_varg(self):
- a1 = self.A()
+ a1 = self.classes.A()
assert_raises_message(
ValueError,
"dictionary update sequence requires " "2-element tuples",
)
def test_update_multi_elem_varg(self):
- a1 = self.A()
+ a1 = self.classes.A()
assert_raises_message(
TypeError,
"update expected at most 1 arguments, got 2",
class CompositeAccessTest(fixtures.DeclarativeMappedTest):
+ run_create_tables = None
+
@classmethod
def setup_classes(cls):
class Point(cls.Basic):
ScalarRemoveTest, fixtures.DeclarativeMappedTest
):
+ run_create_tables = None
useobject = True
cascade_scalar_deletes = True
uselist = True
ScalarRemoveTest, fixtures.DeclarativeMappedTest
):
+ run_create_tables = None
useobject = True
cascade_scalar_deletes = True
uselist = False
ScalarRemoveTest, fixtures.DeclarativeMappedTest
):
+ run_create_tables = None
useobject = False
cascade_scalar_deletes = True
uselist = True
ScalarRemoveTest, fixtures.DeclarativeMappedTest
):
+ run_create_tables = None
useobject = False
cascade_scalar_deletes = True
uselist = False
ScalarRemoveTest, fixtures.DeclarativeMappedTest
):
+ run_create_tables = None
useobject = True
cascade_scalar_deletes = False
uselist = True
ScalarRemoveTest, fixtures.DeclarativeMappedTest
):
+ run_create_tables = None
useobject = True
cascade_scalar_deletes = False
uselist = False
ScalarRemoveTest, fixtures.DeclarativeMappedTest
):
+ run_create_tables = None
useobject = False
cascade_scalar_deletes = False
uselist = True
ScalarRemoveTest, fixtures.DeclarativeMappedTest
):
+ run_create_tables = None
useobject = False
cascade_scalar_deletes = False
uselist = False
class ProxyHybridTest(fixtures.DeclarativeMappedTest, AssertsCompiledSQL):
__dialect__ = "default"
+ run_create_tables = None
+
@classmethod
def setup_classes(cls):
from sqlalchemy.ext.hybrid import hybrid_property
class ProxyPlainPropertyTest(fixtures.DeclarativeMappedTest):
+ run_create_tables = None
+
@classmethod
def setup_classes(cls):
from sqlalchemy import testing
from sqlalchemy.ext import baked
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 subqueryload
def setup_mappers(cls):
User = cls.classes.User
- mapper(User, cls.tables.users)
+ cls.mapper_registry.map_imperatively(User, cls.tables.users)
def _assert_cache_key(self, key, elements):
eq_(key, tuple(elem.__code__ for elem in elements))
def setup_mappers(cls):
User = cls.classes.User
- mapper(User, cls.tables.users)
+ cls.mapper_registry.map_imperatively(User, cls.tables.users)
def test_first_no_result(self):
User = self.classes.User
class AddressUser(object):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
AddressUser,
self.tables.users.outerjoin(self.tables.addresses),
properties={
Address = cls.classes.Address
Order = cls.classes.Order
- mapper(
+ cls.mapper_registry.map_imperatively(
User,
cls.tables.users,
properties={
"orders": relationship(Order, order_by=cls.tables.orders.c.id),
},
)
- mapper(Address, cls.tables.addresses)
- mapper(Order, cls.tables.orders)
+ cls.mapper_registry.map_imperatively(Address, cls.tables.addresses)
+ cls.mapper_registry.map_imperatively(Order, cls.tables.orders)
@contextlib.contextmanager
def _fixture(self):
Address = cls.classes.Address
Order = cls.classes.Order
- mapper(
+ cls.mapper_registry.map_imperatively(
User,
cls.tables.users,
properties={
"orders": relationship(Order, order_by=cls.tables.orders.c.id),
},
)
- mapper(Address, cls.tables.addresses)
- mapper(Order, cls.tables.orders)
+ cls.mapper_registry.map_imperatively(Address, cls.tables.addresses)
+ cls.mapper_registry.map_imperatively(Order, cls.tables.orders)
def test_cachekeys_on_constructor(self):
User = self.classes.User
User = self.classes.User
Address = self.classes.Address
- mapper(
+ self.mapper_registry.map_imperatively(
User,
self.tables.users,
properties={
)
},
)
- mapper(Address, self.tables.addresses)
+ self.mapper_registry.map_imperatively(Address, self.tables.addresses)
return User, Address
def _query_fixture(self):
from sqlalchemy import testing
from sqlalchemy.ext.automap import automap_base
from sqlalchemy.ext.horizontal_shard import ShardedSession
-from sqlalchemy.orm import mapper
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import mock
def setup_mappers(cls):
foo = cls.tables.foo
- mapper(Foo, foo)
+ cls.mapper_registry.map_imperatively(Foo, foo)
with testing.expect_deprecated(
"The mapper.non_primary parameter is deprecated"
):
- mapper(
+ cls.mapper_registry.map_imperatively(
Foo, foo, non_primary=True, properties={"foo_bar": foo.c.data}
)
def setup_mappers(cls):
foo = cls.tables.foo
- mapper(Foo, foo)
+ cls.mapper_registry.map_imperatively(Foo, foo)
with testing.expect_deprecated(
"The mapper.non_primary parameter is deprecated"
):
- mapper(
+ cls.mapper_registry.map_imperatively(
Foo, foo, non_primary=True, properties={"foo_bar": foo.c.data}
)
from sqlalchemy import ForeignKey
from sqlalchemy import inspect
from sqlalchemy import Integer
-from sqlalchemy import MetaData
from sqlalchemy import select
from sqlalchemy import sql
from sqlalchemy import String
from sqlalchemy.ext.horizontal_shard import ShardedSession
from sqlalchemy.orm import clear_mappers
from sqlalchemy.orm import deferred
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import selectinload
from sqlalchemy.orm import Session
__skip_if__ = (lambda: util.win32,)
__requires__ = ("sqlite",)
+ run_create_tables = None
+
schema = None
- def setup_test(self):
+ @classmethod
+ def define_tables(cls, metadata):
global db1, db2, db3, db4, weather_locations, weather_reports
- db1, db2, db3, db4 = self._dbs = self._init_dbs()
-
- meta = self.tables_test_metadata = MetaData()
- ids = Table("ids", meta, Column("nextid", Integer, nullable=False))
+ cls.tables.ids = ids = Table(
+ "ids", metadata, Column("nextid", Integer, nullable=False)
+ )
def id_generator(ctx):
# in reality, might want to use a separate transaction for this.
)
return nextid
- weather_locations = Table(
+ cls.tables.weather_locations = weather_locations = Table(
"weather_locations",
- meta,
+ metadata,
Column("id", Integer, primary_key=True, default=id_generator),
Column("continent", String(30), nullable=False),
Column("city", String(50), nullable=False),
- schema=self.schema,
+ schema=cls.schema,
)
- weather_reports = Table(
+ cls.tables.weather_reports = Table(
"weather_reports",
- meta,
+ metadata,
Column("id", Integer, primary_key=True),
Column("location_id", Integer, ForeignKey(weather_locations.c.id)),
Column("temperature", Float),
Column("report_time", DateTime, default=datetime.datetime.now),
- schema=self.schema,
+ schema=cls.schema,
)
+ def setup_test(self):
+ global db1, db2, db3, db4
+ db1, db2, db3, db4 = self._dbs = self._init_dbs()
+
for db in (db1, db2, db3, db4):
- meta.create_all(db)
+ self.tables_test_metadata.create_all(db)
+ ids = self.tables.ids
with db1.begin() as conn:
conn.execute(ids.insert(), dict(nextid=1))
self.setup_session()
- self.setup_mappers()
@classmethod
def setup_session(cls):
if id_:
self.id = id_
- mapper(
+ weather_locations = cls.tables.weather_locations
+
+ cls.mapper_registry.map_imperatively(
WeatherLocation,
weather_locations,
properties={
},
)
- mapper(Report, weather_reports)
+ weather_reports = cls.tables.weather_reports
+
+ cls.mapper_registry.map_imperatively(Report, weather_reports)
def _fixture_data(self):
tokyo = WeatherLocation("Asia", "Tokyo")
assert inspect(t).deleted is (t.temperature >= 80)
-class DistinctEngineShardTest(ShardTest, fixtures.TestBase):
+class DistinctEngineShardTest(ShardTest, fixtures.MappedTest):
def _init_dbs(self):
db1 = testing_engine(
"sqlite:///shard1_%s.db" % provision.FOLLOWER_IDENT,
return self.dbs
def teardown_test(self):
- clear_mappers()
testing_reaper.checkin_all()
for i in range(1, 5):
)
-class AttachedFileShardTest(ShardTest, fixtures.TestBase):
+class AttachedFileShardTest(ShardTest, fixtures.MappedTest):
"""Use modern schema conventions along with SQLite ATTACH."""
schema = "changeme"
return db1, db2, db3, db4
def teardown_test(self):
- clear_mappers()
-
testing_reaper.checkin_all()
for i in range(1, 5):
os.remove("shard%d_%s.db" % (i, provision.FOLLOWER_IDENT))
-class TableNameConventionShardTest(ShardTest, fixtures.TestBase):
+class TableNameConventionShardTest(ShardTest, fixtures.MappedTest):
"""This fixture uses a single SQLite database along with a table naming
convention to achieve sharding. Event hooks are used to rewrite SQL
statements.
return db1, db2, db3, db4
-class MultipleDialectShardTest(ShardTest, fixtures.TestBase):
+class MultipleDialectShardTest(ShardTest, fixtures.MappedTest):
__only_on__ = "postgresql"
schema = "changeme"
from sqlalchemy.orm import column_property
from sqlalchemy.orm import composite
from sqlalchemy.orm import declarative_base
-from sqlalchemy.orm import mapper
from sqlalchemy.orm.instrumentation import ClassManager
from sqlalchemy.orm.mapper import Mapper
from sqlalchemy.testing import assert_raises
def setup_mappers(cls):
foo = cls.tables.foo
- mapper(Foo, foo)
+ cls.mapper_registry.map_imperatively(Foo, foo)
def test_coerce_none(self):
sess = fixture_session()
def setup_mappers(cls):
foo = cls.tables.foo
- mapper(Foo, foo)
+ cls.mapper_registry.map_imperatively(Foo, foo)
def test_coerce_none(self):
sess = fixture_session()
def setup_mappers(cls):
foo = cls.tables.foo
- mapper(Foo, foo)
+ cls.mapper_registry.map_imperatively(Foo, foo)
def test_coerce_none(self):
sess = fixture_session()
def setup_mappers(cls):
foo = cls.tables.foo
- mapper(Foo, foo)
+ cls.mapper_registry.map_imperatively(Foo, foo)
def test_evt_on_flush_refresh(self):
# test for #3427
foo = cls.tables.foo
subfoo = cls.tables.subfoo
- mapper(Foo, foo)
- mapper(SubFoo, subfoo, inherits=Foo)
+ cls.mapper_registry.map_imperatively(Foo, foo)
+ cls.mapper_registry.map_imperatively(SubFoo, subfoo, inherits=Foo)
MutableDict.associate_with_attribute(Foo.data)
def test_in_place_mutation(self):
cls.Point = cls._type_fixture()
- mapper(
+ cls.mapper_registry.map_imperatively(
Foo,
foo,
properties={"data": composite(cls.Point, foo.c.x, foo.c.y)},
cls.Point = cls._type_fixture()
- mapper(
+ cls.mapper_registry.map_imperatively(
FooWithEq,
foo,
properties={"data": composite(cls.Point, foo.c.x, foo.c.y)},
Point = cls._type_fixture()
- mapper(
+ cls.mapper_registry.map_imperatively(
Foo, foo, properties={"data": composite(Point, foo.c.x, foo.c.y)}
)
# in this case, this is not actually a MutableComposite.
# so we don't expect it to track changes
- mapper(
+ cls.mapper_registry.map_imperatively(
Foo,
foo,
properties={
Point = cls._type_fixture()
- mapper(
+ cls.mapper_registry.map_imperatively(
Foo, foo, properties={"data": composite(Point, foo.c.x, foo.c.y)}
)
Point = cls._type_fixture()
- mapper(
+ cls.mapper_registry.map_imperatively(
Foo, foo, properties={"data": composite(Point, foo.c.x, foo.c.y)}
)
- mapper(SubFoo, subfoo, inherits=Foo)
+ cls.mapper_registry.map_imperatively(SubFoo, subfoo, inherits=Foo)
def test_in_place_mutation_subclass(self):
sess = fixture_session()
from sqlalchemy import String
from sqlalchemy import testing
from sqlalchemy.ext.orderinglist import ordering_list
-from sqlalchemy.orm import mapper
+from sqlalchemy.orm import clear_mappers
from sqlalchemy.orm import relationship
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
return s
-class OrderingListTest(fixtures.TestBase):
+class OrderingListTest(fixtures.MappedTest):
def setup_test(self):
global metadata, slides_table, bullets_table, Slide, Bullet
slides_table, bullets_table = None, None
def __repr__(self):
return '<Bullet "%s" pos %s>' % (self.text, self.position)
- mapper(
+ clear_mappers()
+ self.mapper_registry.map_imperatively(
Slide,
slides_table,
properties={
)
},
)
- mapper(Bullet, bullets_table)
+ self.mapper_registry.map_imperatively(Bullet, bullets_table)
metadata.create_all(testing.db)
from sqlalchemy.orm import column_property
from sqlalchemy.orm import configure_mappers
from sqlalchemy.orm import joinedload
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import scoped_session
from sqlalchemy.orm import sessionmaker
def setup_mappers(cls):
global Session
Session = scoped_session(sessionmaker(testing.db))
- mapper(
+ cls.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ cls.mapper_registry.map_imperatively(Address, addresses)
configure_mappers()
@classmethod
from sqlalchemy import util
from sqlalchemy.orm import backref
from sqlalchemy.orm import configure_mappers
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import fixtures
from sqlalchemy.testing.schema import Column
# use OrderedDict on this one to support some tests that
# assert the order of attributes (e.g. orm/test_inspect)
- mapper(
+ cls.mapper_registry.map_imperatively(
User,
users,
properties=util.OrderedDict(
]
),
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Address,
addresses,
properties={
)
},
)
- mapper(Dingaling, dingalings)
- mapper(
+ cls.mapper_registry.map_imperatively(Dingaling, dingalings)
+ cls.mapper_registry.map_imperatively(
Order,
orders,
properties={
"address": relationship(Address), # m2o
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Item,
items,
properties={
) # m2m
},
)
- mapper(Keyword, keywords)
- mapper(
+ cls.mapper_registry.map_imperatively(Keyword, keywords)
+ cls.mapper_registry.map_imperatively(
Node,
nodes,
properties={
},
)
- mapper(CompositePk, composite_pk_table)
+ cls.mapper_registry.map_imperatively(CompositePk, composite_pk_table)
configure_mappers()
from sqlalchemy import String
from sqlalchemy import testing
from sqlalchemy.orm import class_mapper
-from sqlalchemy.orm import clear_mappers
from sqlalchemy.orm import close_all_sessions
from sqlalchemy.orm import configure_mappers
-from sqlalchemy.orm import declarative_base
from sqlalchemy.orm import declared_attr
from sqlalchemy.orm import deferred
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
+from sqlalchemy.orm.decl_api import registry
from sqlalchemy.testing import assert_raises
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import eq_
class DeclarativeTestBase(fixtures.TestBase, testing.AssertsExecutionResults):
def setup_test(self):
global Base
- Base = declarative_base()
+ self.mapper_registry = registry()
+ Base = self.mapper_registry.generate_base()
def teardown_test(self):
close_all_sessions()
- clear_mappers()
+ self.mapper_registry.dispose()
Base.metadata.drop_all(testing.db)
Column("kind", String(50)),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Person,
person_table,
polymorphic_on="kind",
Column("kind", String(50)),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Person,
person_table,
polymorphic_on="kind",
Column("kind", String(50)),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Person,
person_table,
polymorphic_on="kind",
from sqlalchemy import String
from sqlalchemy import testing
from sqlalchemy.orm import class_mapper
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import polymorphic_union
from sqlalchemy.orm import relationship
from sqlalchemy.orm.interfaces import MANYTOONE
class C(B):
pass
- mapper(
+ cls.mapper_registry.map_imperatively(
A,
ta,
polymorphic_on=abcjoin.c.type,
with_polymorphic=("*", abcjoin),
polymorphic_identity="a",
)
- mapper(
+ cls.mapper_registry.map_imperatively(
B,
tb,
polymorphic_on=bcjoin.c.type,
inherits=A,
inherit_condition=atob,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
C,
tc,
polymorphic_identity="c",
from sqlalchemy import Integer
from sqlalchemy import String
from sqlalchemy import testing
-from sqlalchemy.orm import mapper
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
from sqlalchemy.testing.fixtures import fixture_session
else:
abc = bc = None
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
with_polymorphic=("*", abc),
polymorphic_on=a.c.type,
polymorphic_identity="a",
)
- mapper(
+ self.mapper_registry.map_imperatively(
B,
b,
with_polymorphic=("*", bc),
inherits=A,
polymorphic_identity="b",
)
- mapper(C, c, inherits=B, polymorphic_identity="c")
+ self.mapper_registry.map_imperatively(
+ C, c, inherits=B, polymorphic_identity="c"
+ )
a1 = A(adata="a1")
b1 = B(bdata="b1", adata="b1")
from sqlalchemy.orm import contains_eager
from sqlalchemy.orm import join
from sqlalchemy.orm import joinedload
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import polymorphic_union
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
def test_parent_refs_descendant(self):
Person, Manager = self.classes("Person", "Manager")
- mapper(
+ self.mapper_registry.map_imperatively(
Person,
people,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Manager,
managers,
inherits=Person,
def test_descendant_refs_parent(self):
Person, Manager = self.classes("Person", "Manager")
- mapper(Person, people)
- mapper(
+ self.mapper_registry.map_imperatively(Person, people)
+ self.mapper_registry.map_imperatively(
Manager,
managers,
inherits=Person,
def __init__(self, data):
self.data = data
- mapper(Data, data)
+ self.mapper_registry.map_imperatively(Data, data)
- mapper(
+ self.mapper_registry.map_imperatively(
Person,
people,
with_polymorphic=("*", poly_union),
)
if usedata:
- mapper(
+ self.mapper_registry.map_imperatively(
Manager,
managers,
inherits=Person,
},
)
else:
- mapper(
+ self.mapper_registry.map_imperatively(
Manager,
managers,
inherits=Person,
assert False
if usedata:
- mapper(Data, data)
+ self.mapper_registry.map_imperatively(Data, data)
if usedata:
- mapper(
+ self.mapper_registry.map_imperatively(
Person,
people,
with_polymorphic=("*", poly_union),
},
)
else:
- mapper(
+ self.mapper_registry.map_imperatively(
Person,
people,
with_polymorphic=("*", poly_union),
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Manager,
managers,
inherits=Person,
"employee_join",
)
- person_mapper = mapper(
+ person_mapper = self.mapper_registry.map_imperatively(
Person,
people,
with_polymorphic=("*", employee_join),
polymorphic_on=employee_join.c.type,
polymorphic_identity="person",
)
- mapper(
+ self.mapper_registry.map_imperatively(
Engineer,
engineers,
with_polymorphic=([Engineer], people.join(engineers)),
inherits=person_mapper,
polymorphic_identity="engineer",
)
- mapper(
+ self.mapper_registry.map_imperatively(
Manager,
managers,
with_polymorphic=([Manager], people.join(managers)),
inherits=person_mapper,
polymorphic_identity="manager",
)
- mapper(Car, cars, properties={"employee": relationship(person_mapper)})
+ self.mapper_registry.map_imperatively(
+ Car, cars, properties={"employee": relationship(person_mapper)}
+ )
session = fixture_session()
def __repr__(self):
return "Car number %d" % self.car_id
- person_mapper = mapper(
+ person_mapper = self.mapper_registry.map_imperatively(
Person,
people,
polymorphic_on=people.c.type,
polymorphic_identity="person",
)
- mapper(
+ self.mapper_registry.map_imperatively(
Engineer,
engineers,
inherits=person_mapper,
polymorphic_identity="engineer",
)
- manager_mapper = mapper(
+ manager_mapper = self.mapper_registry.map_imperatively(
Manager,
managers,
inherits=person_mapper,
polymorphic_identity="manager",
)
- mapper(
+ self.mapper_registry.map_imperatively(
Car,
cars,
properties={
def test_basic(self):
Person, Manager = self.classes("Person", "Manager")
- mapper(Person, people)
+ self.mapper_registry.map_imperatively(Person, people)
- mapper(
+ self.mapper_registry.map_imperatively(
Manager,
managers,
inherits=Person,
"car_join",
)
- car_mapper = mapper(
+ car_mapper = self.mapper_registry.map_imperatively(
Car,
cars,
with_polymorphic=("*", car_join),
polymorphic_on=car_join.c.type,
polymorphic_identity="car",
)
- mapper(
+ self.mapper_registry.map_imperatively(
Offraod_Car,
offroad_cars,
inherits=car_mapper,
polymorphic_identity="offroad",
)
- person_mapper = mapper(
+ person_mapper = self.mapper_registry.map_imperatively(
Person,
people,
with_polymorphic=("*", employee_join),
polymorphic_identity="person",
properties={"car": relationship(car_mapper)},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Engineer,
engineers,
inherits=person_mapper,
polymorphic_identity="engineer",
)
- mapper(
+ self.mapper_registry.map_imperatively(
Manager,
managers,
inherits=person_mapper,
class User(Taggable):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Taggable,
taggable,
polymorphic_on=taggable.c.type,
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
inherits=Taggable,
"employee_join",
)
- status_mapper = mapper(Status, status)
- person_mapper = mapper(
+ status_mapper = cls.mapper_registry.map_imperatively(Status, status)
+ person_mapper = cls.mapper_registry.map_imperatively(
Person,
people,
with_polymorphic=("*", employee_join),
polymorphic_identity="person",
properties={"status": relationship(status_mapper)},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Engineer,
engineers,
with_polymorphic=([Engineer], people.join(engineers)),
inherits=person_mapper,
polymorphic_identity="engineer",
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Manager,
managers,
with_polymorphic=([Manager], people.join(managers)),
inherits=person_mapper,
polymorphic_identity="manager",
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Car,
cars,
properties={
"pu_employee",
)
- mapper_Employee = mapper(
+ mapper_Employee = self.mapper_registry.map_imperatively(
Employee,
table_Employee,
polymorphic_identity="Employee",
None,
"pu_engineer",
)
- mapper_Engineer = mapper(
+ mapper_Engineer = self.mapper_registry.map_imperatively(
Engineer,
table_Engineer,
inherit_condition=table_Engineer.c.id == table_Employee.c.id,
with_polymorphic=("*", pu_Engineer),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Manager,
table_Manager,
inherit_condition=table_Manager.c.id == table_Engineer.c.id,
"item_join",
)
- mapper(
+ self.mapper_registry.map_imperatively(
BaseItem,
base_item_table,
with_polymorphic=("*", item_join),
),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Item, item_table, inherits=BaseItem, polymorphic_identity="Item"
)
- mapper(Collection, collection_table)
+ self.mapper_registry.map_imperatively(Collection, collection_table)
class_mapper(BaseItem)
d["t2"] = t1.join(t2)
pjoin = polymorphic_union(d, None, "pjoin")
- mapper(
+ self.mapper_registry.map_imperatively(
T1,
t1,
polymorphic_on=t1.c.type,
with_polymorphic=("*", pjoin),
primary_key=[pjoin.c.id],
)
- mapper(T2, t2, inherits=T1, polymorphic_identity="t2")
+ self.mapper_registry.map_imperatively(
+ T2, t2, inherits=T1, polymorphic_identity="t2"
+ )
ot1 = T1()
ot2 = T2()
sess = fixture_session()
d["t2"] = t1.join(t2)
pjoin = polymorphic_union(d, None, "pjoin")
- mapper(
+ self.mapper_registry.map_imperatively(
T1,
t1,
polymorphic_on=t1.c.type,
polymorphic_identity="t1",
with_polymorphic=("*", pjoin),
)
- mapper(T2, t2, inherits=T1, polymorphic_identity="t2")
+ self.mapper_registry.map_imperatively(
+ T2, t2, inherits=T1, polymorphic_identity="t2"
+ )
assert len(class_mapper(T1).primary_key) == 1
ot1 = T1()
def __init__(self, label):
self.label = label
- mapper(
+ self.mapper_registry.map_imperatively(
Person,
people,
polymorphic_on=people.c._type,
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Employee,
employees,
inherits=Person,
polymorphic_identity="employee",
)
- mapper(Tag, tags)
+ self.mapper_registry.map_imperatively(Tag, tags)
session = fixture_session()
.alias("poly")
)
- mapper(B, tableb)
- mapper(
+ self.mapper_registry.map_imperatively(B, tableb)
+ self.mapper_registry.map_imperatively(
A,
tablea,
with_polymorphic=("*", poly_select),
polymorphic_on=poly_select.c.discriminator,
properties={"b": relationship(B, uselist=False)},
)
- mapper(C, tablec, inherits=A, polymorphic_identity="c")
- mapper(D, tabled, inherits=C, polymorphic_identity="d")
+ self.mapper_registry.map_imperatively(
+ C, tablec, inherits=A, polymorphic_identity="c"
+ )
+ self.mapper_registry.map_imperatively(
+ D, tabled, inherits=C, polymorphic_identity="d"
+ )
c = C(cdata="c1", adata="a1", b=B(data="c"))
d = D(cdata="c2", adata="a2", ddata="d2", b=B(data="d"))
people, users = self.tables.people, self.tables.users
Person, User = self.classes.Person, self.classes.User
- mapper(
+ self.mapper_registry.map_imperatively(
Person,
people,
polymorphic_on=people.c.type,
polymorphic_identity="person",
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
inherits=Person,
people, users = self.tables.people, self.tables.users
Person, User = self.classes.Person, self.classes.User
- mapper(
+ self.mapper_registry.map_imperatively(
Person,
people,
polymorphic_on=people.c.type,
polymorphic_identity="person",
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
inherits=Person,
self.classes.Dude,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Person,
people,
polymorphic_on=people.c.type,
polymorphic_identity="person",
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
inherits=Person,
polymorphic_identity="user",
inherit_condition=(users.c.id == people.c.id),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Dude,
dudes,
inherits=User,
from sqlalchemy.orm import deferred
from sqlalchemy.orm import exc as orm_exc
from sqlalchemy.orm import joinedload
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import object_mapper
from sqlalchemy.orm import polymorphic_union
from sqlalchemy.orm import relationship
def __repr__(self):
return "Foo id %d, data %s" % (self.id, self.data)
- mapper(Foo, foo)
+ self.mapper_registry.map_imperatively(Foo, foo)
class Bar(Foo):
def __repr__(self):
return "Bar id %d, data %s" % (self.id, self.data)
- mapper(Bar, bar, inherits=Foo)
+ self.mapper_registry.map_imperatively(Bar, bar, inherits=Foo)
class Blub(Bar):
def __repr__(self):
return "Blub id %d, data %s" % (self.id, self.data)
- mapper(
+ self.mapper_registry.map_imperatively(
Blub,
blub,
inherits=Bar,
"Can't determine polymorphic_on "
"value 'im not a column' - no "
"attribute is mapped to this name.",
- mapper,
+ self.mapper_registry.map_imperatively,
Parent,
t2,
polymorphic_on="im not a column",
sa_exc.ArgumentError,
r"Column expression or string key expected for argument "
r"'polymorphic_on'; got .*function",
- mapper,
+ self.mapper,
Parent,
t2,
polymorphic_on=lambda: "hi",
def go():
t1t2_join_2 = select(t1.c.q).select_from(t1.join(t2)).alias()
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
t2,
polymorphic_on=t1t2_join.c.x,
Parent = self.classes.Parent
t1t2_join = select(t1.c.x).select_from(t1.join(t2)).alias()
# if its in the with_polymorphic, then its OK
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
t2,
polymorphic_on=t1t2_join.c.x,
# if with_polymorphic, but its not present, not OK
def go():
t1t2_join_2 = select(t1.c.q).select_from(t1.join(t2)).alias()
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
t2,
polymorphic_on=t1t2_join.c.x,
t2, t1 = self.tables.t2, self.tables.t1
Parent, Child = self.classes.Parent, self.classes.Child
expr = case((t1.c.x == "p", "parent"), (t1.c.x == "c", "child"))
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
t1,
properties={"discriminator": column_property(expr)},
polymorphic_identity="parent",
polymorphic_on=expr,
)
- mapper(Child, t2, inherits=Parent, polymorphic_identity="child")
+ self.mapper_registry.map_imperatively(
+ Child, t2, inherits=Parent, polymorphic_identity="child"
+ )
self._roundtrip(parent_ident="p", child_ident="c")
t2, t1 = self.tables.t2, self.tables.t1
Parent, Child = self.classes.Parent, self.classes.Child
expr = case((t1.c.x == "p", "parent"), (t1.c.x == "c", "child"))
- mapper(Parent, t1, polymorphic_identity="parent", polymorphic_on=expr)
- mapper(Child, t2, inherits=Parent, polymorphic_identity="child")
+ self.mapper_registry.map_imperatively(
+ Parent, t1, polymorphic_identity="parent", polymorphic_on=expr
+ )
+ self.mapper_registry.map_imperatively(
+ Child, t2, inherits=Parent, polymorphic_identity="child"
+ )
self._roundtrip(parent_ident="p", child_ident="c")
expr = case((t1.c.x == "p", "parent"), (t1.c.x == "c", "child")).label(
None
)
- mapper(Parent, t1, polymorphic_identity="parent", polymorphic_on=expr)
- mapper(Child, t2, inherits=Parent, polymorphic_identity="child")
+ self.mapper_registry.map_imperatively(
+ Parent, t1, polymorphic_identity="parent", polymorphic_on=expr
+ )
+ self.mapper_registry.map_imperatively(
+ Child, t2, inherits=Parent, polymorphic_identity="child"
+ )
self._roundtrip(parent_ident="p", child_ident="c")
t1 = self.tables.t1
Parent, Child = self.classes.Parent, self.classes.Child
expr = case((t1.c.x == "p", "parent"), (t1.c.x == "c", "child"))
- mapper(Parent, t1, polymorphic_identity="parent", polymorphic_on=expr)
- mapper(Child, inherits=Parent, polymorphic_identity="child")
+ self.mapper_registry.map_imperatively(
+ Parent, t1, polymorphic_identity="parent", polymorphic_on=expr
+ )
+ self.mapper_registry.map_imperatively(
+ Child, inherits=Parent, polymorphic_identity="child"
+ )
self._roundtrip(parent_ident="p", child_ident="c")
expr = case((t1.c.x == "p", "parent"), (t1.c.x == "c", "child")).label(
None
)
- mapper(Parent, t1, polymorphic_identity="parent", polymorphic_on=expr)
- mapper(Child, inherits=Parent, polymorphic_identity="child")
+ self.mapper_registry.map_imperatively(
+ Parent, t1, polymorphic_identity="parent", polymorphic_on=expr
+ )
+ self.mapper_registry.map_imperatively(
+ Child, inherits=Parent, polymorphic_identity="child"
+ )
self._roundtrip(parent_ident="p", child_ident="c")
Parent, Child = self.classes.Parent, self.classes.Child
expr = case((t1.c.x == "p", "parent"), (t1.c.x == "c", "child"))
cprop = column_property(expr)
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
t1,
properties={"discriminator": cprop},
polymorphic_identity="parent",
polymorphic_on=cprop,
)
- mapper(Child, t2, inherits=Parent, polymorphic_identity="child")
+ self.mapper_registry.map_imperatively(
+ Child, t2, inherits=Parent, polymorphic_identity="child"
+ )
self._roundtrip(parent_ident="p", child_ident="c")
Parent, Child = self.classes.Parent, self.classes.Child
expr = case((t1.c.x == "p", "parent"), (t1.c.x == "c", "child"))
cprop = column_property(expr)
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
t1,
properties={"discriminator": cprop},
polymorphic_identity="parent",
polymorphic_on="discriminator",
)
- mapper(Child, t2, inherits=Parent, polymorphic_identity="child")
+ self.mapper_registry.map_imperatively(
+ Child, t2, inherits=Parent, polymorphic_identity="child"
+ )
self._roundtrip(parent_ident="p", child_ident="c")
sa_exc.ArgumentError,
"Only direct column-mapped property or "
"SQL expression can be passed for polymorphic_on",
- mapper,
+ self.mapper_registry.map_imperatively,
Parent,
t1,
properties={"discriminator": cprop, "discrim_syn": synonym(cprop)},
class Bar(Foo):
pass
- mapper(Foo, t1, polymorphic_on=t1.c.type, polymorphic_identity=True)
- mapper(Bar, inherits=Foo, polymorphic_identity=False)
+ self.mapper_registry.map_imperatively(
+ Foo, t1, polymorphic_on=t1.c.type, polymorphic_identity=True
+ )
+ self.mapper_registry.map_imperatively(
+ Bar, inherits=Foo, polymorphic_identity=False
+ )
sess = fixture_session()
b1 = Bar()
sess.add(b1)
class Bat(Ding):
pass
- mapper(Ding, t1, polymorphic_on=t1.c.type, polymorphic_identity=False)
- mapper(Bat, inherits=Ding, polymorphic_identity=True)
+ self.mapper_registry.map_imperatively(
+ Ding, t1, polymorphic_on=t1.c.type, polymorphic_identity=False
+ )
+ self.mapper_registry.map_imperatively(
+ Bat, inherits=Ding, polymorphic_identity=True
+ )
sess = fixture_session()
d1 = Ding()
sess.add(d1)
class T2(T1):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
T1,
t1,
polymorphic_on=t1.c.type,
polymorphic_identity="t1",
properties={"info": synonym("_info", map_column=True)},
)
- mapper(T2, t2, inherits=T1, polymorphic_identity="t2")
+ self.mapper_registry.map_imperatively(
+ T2, t2, inherits=T1, polymorphic_identity="t2"
+ )
sess = fixture_session()
at1 = T1(info="at1")
at2 = T2(info="at2", data="t2 data")
@classmethod
def setup_classes(cls):
- table_b, table_c, table_a = (
- cls.tables.table_b,
- cls.tables.table_c,
- cls.tables.table_a,
- )
-
class A(cls.Basic):
pass
class D(B):
pass
- mapper(
+ @classmethod
+ def setup_mappers(cls):
+ A, B, C, D = cls.classes("A", "B", "C", "D")
+ table_b, table_c, table_a = (
+ cls.tables.table_b,
+ cls.tables.table_c,
+ cls.tables.table_a,
+ )
+ cls.mapper_registry.map_imperatively(
A,
table_a,
polymorphic_on=table_a.c.class_name,
polymorphic_identity="a",
)
- mapper(
+ cls.mapper_registry.map_imperatively(
B,
table_b,
inherits=A,
class_name=[table_a.c.class_name, table_b.c.class_name]
),
)
- mapper(C, table_c, inherits=B, polymorphic_identity="c")
- mapper(D, inherits=B, polymorphic_identity="d")
+ cls.mapper_registry.map_imperatively(
+ C, table_c, inherits=B, polymorphic_identity="c"
+ )
+ cls.mapper_registry.map_imperatively(
+ D, inherits=B, polymorphic_identity="d"
+ )
def test_poly_configured_immediate(self):
A, C, B = (self.classes.A, self.classes.C, self.classes.B)
class T4(fixtures.BasicEntity):
pass
- mapper(T1, t1, properties={"t2s": relationship(T2, cascade="all")})
- mapper(T2, t2, polymorphic_on=t2.c.type, polymorphic_identity="t2")
- mapper(
+ self.mapper_registry.map_imperatively(
+ T1, t1, properties={"t2s": relationship(T2, cascade="all")}
+ )
+ self.mapper_registry.map_imperatively(
+ T2, t2, polymorphic_on=t2.c.type, polymorphic_identity="t2"
+ )
+ self.mapper_registry.map_imperatively(
T3,
t3,
inherits=T2,
polymorphic_identity="t3",
properties={"t4s": relationship(T4, cascade="all")},
)
- mapper(T4, t4)
+ self.mapper_registry.map_imperatively(T4, t4)
sess = fixture_session()
t1_1 = T1(data="t1")
class Related(Base):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Base, base, polymorphic_on=base.c.type, polymorphic_identity="b"
)
- mapper(Sub, sub, inherits=Base, polymorphic_identity="s")
- mapper(
+ self.mapper_registry.map_imperatively(
+ Sub, sub, inherits=Base, polymorphic_identity="s"
+ )
+ self.mapper_registry.map_imperatively(
Related,
related,
properties={
)
if polymorphic:
- mapper(
+ self.mapper_registry.map_imperatively(
Foo, foo, polymorphic_on=foo.c.type, polymorphic_identity="foo"
)
- mapper(Bar, bar, inherits=Foo, polymorphic_identity="bar")
- mapper(Blub, blub, inherits=Bar, polymorphic_identity="blub")
+ self.mapper_registry.map_imperatively(
+ Bar, bar, inherits=Foo, polymorphic_identity="bar"
+ )
+ self.mapper_registry.map_imperatively(
+ Blub, blub, inherits=Bar, polymorphic_identity="blub"
+ )
else:
- mapper(Foo, foo)
- mapper(Bar, bar, inherits=Foo)
- mapper(Blub, blub, inherits=Bar)
+ self.mapper_registry.map_imperatively(Foo, foo)
+ self.mapper_registry.map_imperatively(Bar, bar, inherits=Foo)
+ self.mapper_registry.map_imperatively(Blub, blub, inherits=Bar)
sess = fixture_session()
f = Foo()
class Bar(Foo):
pass
- foos = mapper(Foo, foo)
- bars = mapper(Bar, bar, inherits=foos)
+ foos = cls.mapper_registry.map_imperatively(Foo, foo)
+ bars = cls.mapper_registry.map_imperatively(Bar, bar, inherits=foos)
bars.add_property("lazy", relationship(foos, bar_foo, lazy="select"))
bars.add_property(
"eager", relationship(foos, bar_foo, lazy="joined", viewonly=True)
class B(A):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a_table,
polymorphic_on=a_table.c.type,
properties={"children": relationship(A, order_by=a_table.c.name)},
)
- mapper(
+ self.mapper_registry.map_imperatively(
B,
b_table,
inherits=A,
class Admin(User):
pass
- mapper(Role, roles)
- user_mapper = mapper(
+ self.mapper_registry.map_imperatively(Role, roles)
+ user_mapper = self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Admin, admins, inherits=user_mapper)
+ self.mapper_registry.map_imperatively(
+ Admin, admins, inherits=user_mapper
+ )
sess = fixture_session()
adminrole = Role()
sess.add(adminrole)
class Admin(User):
pass
- mapper(Role, roles)
- user_mapper = mapper(
+ self.mapper_registry.map_imperatively(Role, roles)
+ user_mapper = self.mapper_registry.map_imperatively(
User,
users,
properties={
},
)
- mapper(Admin, admins, inherits=user_mapper)
+ self.mapper_registry.map_imperatively(
+ Admin, admins, inherits=user_mapper
+ )
# create roles
adminrole = Role("admin")
A, B, C = self.classes("A", "B", "C")
a, b, c = self.tables("a", "b", "c")
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
passive_deletes=a_p,
polymorphic_on=a.c.type,
polymorphic_identity="a",
)
- mapper(B, b, inherits=A, passive_deletes=b_p, polymorphic_identity="b")
- mapper(C, c, inherits=B, passive_deletes=c_p, polymorphic_identity="c")
+ self.mapper_registry.map_imperatively(
+ B, b, inherits=A, passive_deletes=b_p, polymorphic_identity="b"
+ )
+ self.mapper_registry.map_imperatively(
+ C, c, inherits=B, passive_deletes=c_p, polymorphic_identity="c"
+ )
def test_none(self):
A, B, C = self.classes("A", "B", "C")
A, B = cls.classes("A", "B")
a, b = cls.tables("a", "b")
- mapper(A, a)
- mapper(
+ cls.mapper_registry.map_imperatively(A, a)
+ cls.mapper_registry.map_imperatively(
B,
b,
inherits=A,
@classmethod
def setup_mappers(cls):
A, B, C = cls.classes.A, cls.classes.B, cls.classes.C
- mapper(A, cls.tables.a)
- mapper(
+ cls.mapper_registry.map_imperatively(A, cls.tables.a)
+ cls.mapper_registry.map_imperatively(
B,
cls.tables.b,
inherits=A,
inherit_condition=cls.tables.a.c.id == cls.tables.b.c.id,
inherit_foreign_keys=cls.tables.b.c.id,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
C,
cls.tables.c,
inherits=A,
class Stuff(Base):
pass
- mapper(Stuff, stuff)
- mapper(
+ self.mapper_registry.map_imperatively(Stuff, stuff)
+ self.mapper_registry.map_imperatively(
Base,
base,
polymorphic_on=base.c.discriminator,
polymorphic_identity=1,
properties={"stuff": relationship(Stuff)},
)
- mapper(Sub, subtable, inherits=Base, polymorphic_identity=2)
+ self.mapper_registry.map_imperatively(
+ Sub, subtable, inherits=Base, polymorphic_identity=2
+ )
sess = fixture_session(autoflush=False)
class Sub(Base):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Base,
base,
polymorphic_on=base.c.discriminator,
version_id_col=base.c.version_id,
polymorphic_identity=1,
)
- mapper(Sub, subtable, inherits=Base, polymorphic_identity=2)
+ self.mapper_registry.map_imperatively(
+ Sub, subtable, inherits=Base, polymorphic_identity=2
+ )
sess = fixture_session(autoflush=False, expire_on_commit=False)
) # bob
def test_implicit(self):
- person_mapper = mapper(Person, person_table)
- mapper(Employee, employee_table, inherits=person_mapper)
+ person_mapper = self.mapper_registry.map_imperatively(
+ Person, person_table
+ )
+ self.mapper_registry.map_imperatively(
+ Employee, employee_table, inherits=person_mapper
+ )
assert list(class_mapper(Employee).primary_key) == [person_table.c.id]
def test_explicit_props(self):
- person_mapper = mapper(Person, person_table)
- mapper(
+ person_mapper = self.mapper_registry.map_imperatively(
+ Person, person_table
+ )
+ self.mapper_registry.map_imperatively(
Employee,
employee_table,
inherits=person_mapper,
self._do_test(False)
def test_explicit_composite_pk(self):
- person_mapper = mapper(Person, person_table)
- mapper(
+ person_mapper = self.mapper_registry.map_imperatively(
+ Person, person_table
+ )
+ self.mapper_registry.map_imperatively(
Employee,
employee_table,
inherits=person_mapper,
)
def test_explicit_pk(self):
- person_mapper = mapper(Person, person_table)
- mapper(
+ person_mapper = self.mapper_registry.map_imperatively(
+ Person, person_table
+ )
+ self.mapper_registry.map_imperatively(
Employee,
employee_table,
inherits=person_mapper,
class C(B):
pass
- mapper(A, _a_table)
- mapper(B, _b_table, inherits=A, inherit_condition=j1)
- mapper(C, _c_table, inherits=B, inherit_condition=j2)
+ self.mapper_registry.map_imperatively(A, _a_table)
+ self.mapper_registry.map_imperatively(
+ B, _b_table, inherits=A, inherit_condition=j1
+ )
+ self.mapper_registry.map_imperatively(
+ C, _c_table, inherits=B, inherit_condition=j2
+ )
session = fixture_session()
class Sub(Base):
pass
- mapper(Base, base)
- mapper(Sub, subtable, inherits=Base)
+ self.mapper_registry.map_imperatively(Base, base)
+ self.mapper_registry.map_imperatively(Sub, subtable, inherits=Base)
# Sub gets a "base_id" property using the "base_id"
# column of both tables.
class Sub(Base):
pass
- mapper(Base, base, properties={"id": base.c.base_id})
- mapper(
+ self.mapper_registry.map_imperatively(
+ Base, base, properties={"id": base.c.base_id}
+ )
+ self.mapper_registry.map_imperatively(
Sub,
subtable,
inherits=Base,
class Sub(Base):
pass
- mapper(Base, base, properties={"id": base.c.base_id})
- mapper(Sub, subtable, inherits=Base)
+ self.mapper_registry.map_imperatively(
+ Base, base, properties={"id": base.c.base_id}
+ )
+ self.mapper_registry.map_imperatively(Sub, subtable, inherits=Base)
eq_(class_mapper(Sub).get_property("id").columns, [base.c.base_id])
class Sub(Base):
pass
- mapper(Base, base, properties={"id": base.c.base_id})
+ self.mapper_registry.map_imperatively(
+ Base, base, properties={"id": base.c.base_id}
+ )
def go():
- mapper(
+ self.mapper_registry.map_imperatively(
Sub,
subtable,
inherits=Base,
class Sub(Base):
pass
- mapper(Base, base)
+ self.mapper_registry.map_imperatively(Base, base)
def go():
- mapper(Sub, subtable_two, inherits=Base)
+ self.mapper_registry.map_imperatively(
+ Sub, subtable_two, inherits=Base
+ )
assert_raises_message(
sa_exc.SAWarning,
def data(self):
return "im the data"
- mapper(Base, base)
- mapper(Sub, subtable, inherits=Base)
+ self.mapper_registry.map_imperatively(Base, base)
+ self.mapper_registry.map_imperatively(Sub, subtable, inherits=Base)
s1 = Sub()
sess = fixture_session()
class Sub(Base):
data = MyDesc()
- mapper(Base, base)
- mapper(Sub, subtable, inherits=Base)
+ self.mapper_registry.map_imperatively(Base, base)
+ self.mapper_registry.map_imperatively(Sub, subtable, inherits=Base)
s1 = Sub()
sess = fixture_session()
class Sub(Base):
pass
- mapper(Base, base)
- mapper(Sub, subtable, inherits=Base)
+ self.mapper_registry.map_imperatively(Base, base)
+ self.mapper_registry.map_imperatively(Sub, subtable, inherits=Base)
sess = fixture_session()
b1 = Base()
class Sub(Base):
pass
- mapper(Base, base)
- mapper(Sub, subtable, inherits=Base)
+ self.mapper_registry.map_imperatively(Base, base)
+ self.mapper_registry.map_imperatively(Sub, subtable, inherits=Base)
sess = fixture_session()
b1 = Base()
class SubJoinBase(JoinBase):
pass
- mapper(Base, base)
- mapper(
+ self.mapper_registry.map_imperatively(Base, base)
+ self.mapper_registry.map_imperatively(
JoinBase,
base.outerjoin(sub),
properties=util.OrderedDict(
]
),
)
- mapper(SubJoinBase, inherits=JoinBase)
+ self.mapper_registry.map_imperatively(SubJoinBase, inherits=JoinBase)
sess = fixture_session()
sess.add(Base(data="data"))
class Sub(Base):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Base, base, polymorphic_on=base.c.type, polymorphic_identity="base"
)
- mapper(
+ self.mapper_registry.map_imperatively(
Sub,
sub,
inherits=Base,
class Sub(Base):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Base, base, polymorphic_on=base.c.type, polymorphic_identity="base"
)
# redefine Sub's "id" to favor the "id" col in the subtable.
# "id" is also part of the primary join condition
- mapper(
+ self.mapper_registry.map_imperatively(
Sub,
sub,
inherits=Base,
class Sub(Base):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Base, base, polymorphic_on=base.c.type, polymorphic_identity="base"
)
- mapper(
+ self.mapper_registry.map_imperatively(
Sub,
sub,
inherits=Base,
class Sub(Base):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Base, base, polymorphic_on=base.c.type, polymorphic_identity="base"
)
- mapper(
+ self.mapper_registry.map_imperatively(
Sub,
sub,
inherits=Base,
def __eq__(self, other):
return (self.a == other.a) and (self.b == other.b)
- mapper(
+ self.mapper_registry.map_imperatively(
Base, base, polymorphic_on=base.c.type, polymorphic_identity="base"
)
- mapper(
+ self.mapper_registry.map_imperatively(
WithComp,
with_comp,
inherits=Base,
class Sub(Base):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Base, base, polymorphic_on=base.c.type, polymorphic_identity="base"
)
- mapper(Sub, sub, inherits=Base, polymorphic_identity="sub")
+ self.mapper_registry.map_imperatively(
+ Sub, sub, inherits=Base, polymorphic_identity="sub"
+ )
sess = fixture_session()
s1 = Sub(data="s1")
sess.add(s1)
class Sub(Base):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Base, base, polymorphic_on=base.c.type, polymorphic_identity="base"
)
- m = mapper(Sub, sub, inherits=Base, polymorphic_identity="sub")
+ m = self.mapper_registry.map_imperatively(
+ Sub, sub, inherits=Base, polymorphic_identity="sub"
+ )
s1 = Sub()
assert (
class SubSub(Sub):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Base, base, polymorphic_on=base.c.type, polymorphic_identity="base"
)
- mapper(Sub, sub, inherits=Base, polymorphic_identity="sub")
- mapper(SubSub, subsub, inherits=Sub, polymorphic_identity="subsub")
+ self.mapper_registry.map_imperatively(
+ Sub, sub, inherits=Base, polymorphic_identity="sub"
+ )
+ self.mapper_registry.map_imperatively(
+ SubSub, subsub, inherits=Sub, polymorphic_identity="subsub"
+ )
sess = fixture_session()
s1 = SubSub(data="s1", counter=1, subcounter=2)
sess.add(s1)
)
-class NoPKOnSubTableWarningTest(fixtures.TestBase):
+class NoPKOnSubTableWarningTest(fixtures.MappedTest):
def _fixture(self):
metadata = MetaData()
parent = Table(
)
return parent, child
- def teardown_test(self):
- clear_mappers()
-
def test_warning_on_sub(self):
parent, child = self._fixture()
class C(P):
pass
- mapper(P, parent)
+ self.mapper_registry.map_imperatively(P, parent)
assert_raises_message(
sa_exc.SAWarning,
"Could not assemble any primary keys for locally mapped "
"table 'child' - no rows will be persisted in this Table.",
- mapper,
+ self.mapper_registry.map_imperatively,
C,
child,
inherits=P,
class C(P):
pass
- mapper(P, parent)
- mc = mapper(C, child, inherits=P, primary_key=[parent.c.id])
+ self.mapper_registry.map_imperatively(P, parent)
+ mc = self.mapper_registry.map_imperatively(
+ C, child, inherits=P, primary_key=[parent.c.id]
+ )
eq_(mc.primary_key, (parent.c.id,))
-class InhCondTest(fixtures.TestBase):
+class InhCondTest(fixtures.MappedTest):
def test_inh_cond_nonexistent_table_unrelated(self):
metadata = MetaData()
base_table = Table(
class Derived(Base):
pass
- mapper(Base, base_table)
+ self.mapper_registry.map_imperatively(Base, base_table)
# succeeds, despite "owner" table not configured yet
- m2 = mapper(Derived, derived_table, inherits=Base)
+ m2 = self.mapper_registry.map_imperatively(
+ Derived, derived_table, inherits=Base
+ )
assert m2.inherit_condition.compare(
base_table.c.id == derived_table.c.id
)
class Derived(Base):
pass
- mapper(Base, base_table)
+ self.mapper_registry.map_imperatively(Base, base_table)
# succeeds, despite "order.foo" doesn't exist
- m2 = mapper(Derived, derived_table, inherits=Base)
+ m2 = self.mapper_registry.map_imperatively(
+ Derived, derived_table, inherits=Base
+ )
assert m2.inherit_condition.compare(
base_table.c.id == derived_table.c.id
)
class Derived(Base):
pass
- mapper(Base, base_table)
+ self.mapper_registry.map_imperatively(Base, base_table)
assert_raises_message(
sa_exc.NoForeignKeysError,
"Can't determine the inherit condition between inherited table "
"table has a foreign key relationship to the inherited table, "
"or provide an 'on clause' using the 'inherit_condition' "
"mapper argument.",
- mapper,
+ self.mapper,
Derived,
derived_table,
inherits=Base,
class Derived(Base):
pass
- mapper(Base, base_table)
+ self.mapper(Base, base_table)
assert_raises_message(
sa_exc.AmbiguousForeignKeysError,
"Can't determine the inherit condition between inherited table "
"'base' and inheriting table 'derived'; tables have more than "
"one foreign key relationship established. Please specify the "
"'on clause' using the 'inherit_condition' mapper argument.",
- mapper,
+ self.mapper,
Derived,
derived_table,
inherits=Base,
class Derived(Base):
pass
- mapper(Base, base_table)
+ clear_mappers()
+ self.mapper_registry.map_imperatively(Base, base_table)
# the ForeignKey def is correct but there are two
# different metadatas. Would like the traditional
"Foreign key associated with column 'derived.id' "
"could not find table 'base' with which to generate "
"a foreign key to target column 'id'",
- mapper,
+ self.mapper,
Derived,
derived_table,
inherits=Base,
class Derived(Base):
pass
- mapper(Base, base_table)
+ clear_mappers()
+ self.mapper_registry.map_imperatively(Base, base_table)
assert_raises_message(
sa_exc.NoReferencedColumnError,
"Could not initialize target column for ForeignKey "
"'base.q' on table "
"'derived': table 'base' has no column named 'q'",
- mapper,
+ self.mapper,
Derived,
derived_table,
inherits=Base,
class A(Child):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
parents,
properties={"children": relationship(Child, backref="parent")},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Child,
children,
polymorphic_on=children.c.type,
polymorphic_identity=1,
)
- mapper(A, inherits=Child, polymorphic_identity=2)
+ self.mapper_registry.map_imperatively(
+ A, inherits=Child, polymorphic_identity=2
+ )
s = fixture_session()
p = Parent("p1")
cls.tables.base,
)
- mapper(A, base, polymorphic_on=base.c.type)
- mapper(B, inherits=A)
- mapper(C, inherits=B, polymorphic_identity="c")
- mapper(D, inherits=B, polymorphic_identity="d")
- mapper(E, inherits=A, polymorphic_identity="e")
+ cls.mapper_registry.map_imperatively(
+ A, base, polymorphic_on=base.c.type
+ )
+ cls.mapper_registry.map_imperatively(B, inherits=A)
+ cls.mapper_registry.map_imperatively(
+ C, inherits=B, polymorphic_identity="c"
+ )
+ cls.mapper_registry.map_imperatively(
+ D, inherits=B, polymorphic_identity="d"
+ )
+ cls.mapper_registry.map_imperatively(
+ E, inherits=A, polymorphic_identity="e"
+ )
def test_load_from_middle(self):
C, B = self.classes.C, self.classes.B
class Parent(fixtures.BasicEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Base,
single,
polymorphic_on=single.c.type,
polymorphic_identity="base",
)
- mapper(SubClass, inherits=Base, polymorphic_identity="sub")
- mapper(
+ self.mapper_registry.map_imperatively(
+ SubClass, inherits=Base, polymorphic_identity="sub"
+ )
+ self.mapper_registry.map_imperatively(
Parent,
parent,
properties={
class Foo(Content):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Content,
self.tables.content,
polymorphic_on=self.tables.content.c.type,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Foo, self.tables.foo, inherits=Content, polymorphic_identity="foo"
)
sess = fixture_session()
from sqlalchemy.orm import clear_mappers
from sqlalchemy.orm import configure_mappers
from sqlalchemy.orm import joinedload
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import polymorphic_union
from sqlalchemy.orm import relationship
from sqlalchemy.testing import assert_raises
"type",
"pjoin",
)
- employee_mapper = mapper(Employee, pjoin, polymorphic_on=pjoin.c.type)
- mapper(
+ employee_mapper = self.mapper_registry.map_imperatively(
+ Employee, pjoin, polymorphic_on=pjoin.c.type
+ )
+ self.mapper_registry.map_imperatively(
Manager,
managers_table,
inherits=employee_mapper,
concrete=True,
polymorphic_identity="manager",
)
- mapper(
+ self.mapper_registry.map_imperatively(
Engineer,
engineers_table,
inherits=employee_mapper,
"type",
"pjoin2",
)
- employee_mapper = mapper(Employee, pjoin, polymorphic_on=pjoin.c.type)
- mapper(
+ employee_mapper = self.mapper_registry.map_imperatively(
+ Employee, pjoin, polymorphic_on=pjoin.c.type
+ )
+ self.mapper_registry.map_imperatively(
Manager,
managers_table,
inherits=employee_mapper,
concrete=True,
polymorphic_identity="manager",
)
- engineer_mapper = mapper(
+ engineer_mapper = self.mapper_registry.map_imperatively(
Engineer,
engineers_table,
with_polymorphic=("*", pjoin2),
concrete=True,
polymorphic_identity="engineer",
)
- mapper(
+ self.mapper_registry.map_imperatively(
Hacker,
hackers_table,
inherits=engineer_mapper,
test_calls.engineer_info_class()
return cls.manager_data
- employee_mapper = mapper(Employee, pjoin, polymorphic_on=pjoin.c.type)
- mapper(
+ employee_mapper = self.mapper_registry.map_imperatively(
+ Employee, pjoin, polymorphic_on=pjoin.c.type
+ )
+ self.mapper_registry.map_imperatively(
ManagerWHybrid,
managers_table,
inherits=employee_mapper,
concrete=True,
polymorphic_identity="manager",
)
- mapper(
+ self.mapper_registry.map_imperatively(
Engineer,
engineers_table,
inherits=employee_mapper,
"type",
"pjoin2",
)
- employee_mapper = mapper(
+ employee_mapper = self.mapper_registry.map_imperatively(
Employee,
employees_table,
with_polymorphic=("*", pjoin),
polymorphic_on=pjoin.c.type,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Manager,
managers_table,
inherits=employee_mapper,
concrete=True,
polymorphic_identity="manager",
)
- engineer_mapper = mapper(
+ engineer_mapper = self.mapper_registry.map_imperatively(
Engineer,
engineers_table,
with_polymorphic=("*", pjoin2),
concrete=True,
polymorphic_identity="engineer",
)
- mapper(
+ self.mapper_registry.map_imperatively(
Hacker,
hackers_table,
inherits=engineer_mapper,
"type",
"pjoin2",
)
- employee_mapper = mapper(
+ employee_mapper = self.mapper_registry.map_imperatively(
Employee, employees_table, polymorphic_identity="employee"
)
- mapper(
+ self.mapper_registry.map_imperatively(
Manager,
managers_table,
inherits=employee_mapper,
concrete=True,
polymorphic_identity="manager",
)
- engineer_mapper = mapper(
+ engineer_mapper = self.mapper_registry.map_imperatively(
Engineer,
engineers_table,
inherits=employee_mapper,
concrete=True,
polymorphic_identity="engineer",
)
- mapper(
+ self.mapper_registry.map_imperatively(
Hacker,
hackers_table,
inherits=engineer_mapper,
"type",
"pjoin",
)
- mapper(
+ self.mapper_registry.map_imperatively(
Company,
companies,
properties={"employees": relationship(Employee)},
)
- employee_mapper = mapper(Employee, pjoin, polymorphic_on=pjoin.c.type)
- mapper(
+ employee_mapper = self.mapper_registry.map_imperatively(
+ Employee, pjoin, polymorphic_on=pjoin.c.type
+ )
+ self.mapper_registry.map_imperatively(
Manager,
managers_table,
inherits=employee_mapper,
concrete=True,
polymorphic_identity="manager",
)
- mapper(
+ self.mapper_registry.map_imperatively(
Engineer,
engineers_table,
inherits=employee_mapper,
self.tables.dest_table,
)
- mapper(A, a_table, properties={"some_dest": relationship(Dest)})
- mapper(B, b_table, inherits=A, concrete=True)
- mapper(Dest, dest_table)
+ self.mapper_registry.map_imperatively(
+ A, a_table, properties={"some_dest": relationship(Dest)}
+ )
+ self.mapper_registry.map_imperatively(
+ B, b_table, inherits=A, concrete=True
+ )
+ self.mapper_registry.map_imperatively(Dest, dest_table)
b = B()
dest = Dest()
assert_raises(AttributeError, setattr, b, "some_dest", dest)
clear_mappers()
- mapper(A, a_table, properties={"a_id": a_table.c.id})
- mapper(B, b_table, inherits=A, concrete=True)
- mapper(Dest, dest_table)
+ self.mapper_registry.map_imperatively(
+ A, a_table, properties={"a_id": a_table.c.id}
+ )
+ self.mapper_registry.map_imperatively(
+ B, b_table, inherits=A, concrete=True
+ )
+ self.mapper_registry.map_imperatively(Dest, dest_table)
b = B()
assert_raises(AttributeError, setattr, b, "a_id", 3)
clear_mappers()
- mapper(A, a_table, properties={"a_id": a_table.c.id})
- mapper(B, b_table, inherits=A, concrete=True)
- mapper(Dest, dest_table)
+ self.mapper_registry.map_imperatively(
+ A, a_table, properties={"a_id": a_table.c.id}
+ )
+ self.mapper_registry.map_imperatively(
+ B, b_table, inherits=A, concrete=True
+ )
+ self.mapper_registry.map_imperatively(Dest, dest_table)
def test_inheriting(self):
A, B, b_table, a_table, Dest, dest_table = (
self.tables.dest_table,
)
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a_table,
properties={
"some_dest": relationship(Dest, back_populates="many_a")
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
B,
b_table,
inherits=A,
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Dest,
dest_table,
properties={
)
# test issue #3630, no error or warning is generated
- mapper(A, a_table)
- mapper(B, b_table, inherits=A, concrete=True)
- mapper(
+ self.mapper_registry.map_imperatively(A, a_table)
+ self.mapper_registry.map_imperatively(
+ B, b_table, inherits=A, concrete=True
+ )
+ self.mapper_registry.map_imperatively(
Dest,
dest_table,
properties={
# this is the opposite mapping as that of #3630, never generated
# an error / warning
- mapper(
+ self.mapper_registry.map_imperatively(
A, a_table, properties={"dest": relationship(Dest, backref="a")}
)
- mapper(
+ self.mapper_registry.map_imperatively(
B,
b_table,
inherits=A,
concrete=True,
properties={"dest": relationship(Dest, backref="a1")},
)
- mapper(Dest, dest_table)
+ self.mapper_registry.map_imperatively(Dest, dest_table)
configure_mappers()
def test_polymorphic_backref(self):
ajoin = polymorphic_union(
{"a": a_table, "b": b_table, "c": c_table}, "type", "ajoin"
)
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a_table,
with_polymorphic=("*", ajoin),
"some_dest": relationship(Dest, back_populates="many_a")
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
B,
b_table,
inherits=A,
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
C,
c_table,
inherits=A,
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Dest,
dest_table,
properties={
ajoin = polymorphic_union(
{"a": a_table, "b": b_table, "c": c_table}, "type", "ajoin"
)
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a_table,
with_polymorphic=("*", ajoin),
"some_dest": relationship(Dest, back_populates="many_a")
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
B,
b_table,
inherits=A,
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
C,
c_table,
inherits=A,
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Dest,
dest_table,
properties={
self.classes.Sub,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Base,
base,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Sub,
sub,
inherits=Base,
)
},
)
- mapper(Related, related)
+ self.mapper_registry.map_imperatively(Related, related)
sess = fixture_session()
b1, s1, r1, r2, r3 = Base(), Sub(), Related(), Related(), Related()
b1.related.append(r1)
class Office(Location):
pass
- location_mapper = mapper(
+ location_mapper = self.mapper_registry.map_imperatively(
Location,
pjoin,
polymorphic_on=pjoin.c.type,
polymorphic_identity="location",
)
- mapper(
+ self.mapper_registry.map_imperatively(
Office,
offices_table,
inherits=location_mapper,
concrete=True,
polymorphic_identity="office",
)
- mapper(
+ self.mapper_registry.map_imperatively(
Refugee,
refugees_table,
inherits=location_mapper,
from sqlalchemy import testing
from sqlalchemy import Text
from sqlalchemy.orm import backref
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import polymorphic_union
from sqlalchemy.orm import relationship
from sqlalchemy.testing import eq_
"MagazinePage",
"ClassifiedPage",
)
- mapper(Publication, self.tables.publication)
+ self.mapper_registry.map_imperatively(
+ Publication, self.tables.publication
+ )
- mapper(
+ self.mapper_registry.map_imperatively(
Issue,
self.tables.issue,
properties={
},
)
- mapper(LocationName, self.tables.location_name)
+ self.mapper_registry.map_imperatively(
+ LocationName, self.tables.location_name
+ )
- mapper(
+ self.mapper_registry.map_imperatively(
Location,
self.tables.location,
properties={
},
)
- mapper(PageSize, self.tables.page_size)
+ self.mapper_registry.map_imperatively(PageSize, self.tables.page_size)
- mapper(
+ self.mapper_registry.map_imperatively(
Magazine,
self.tables.magazine,
properties={
None,
"page_join",
)
- page_mapper = mapper(
+ page_mapper = self.mapper_registry.map_imperatively(
Page,
self.tables.page,
with_polymorphic=("*", page_join),
page_join = self.tables.page.outerjoin(
self.tables.magazine_page
).outerjoin(self.tables.classified_page)
- page_mapper = mapper(
+ page_mapper = self.mapper_registry.map_imperatively(
Page,
self.tables.page,
with_polymorphic=("*", page_join),
polymorphic_identity="p",
)
else:
- page_mapper = mapper(
+ page_mapper = self.mapper_registry.map_imperatively(
Page,
self.tables.page,
polymorphic_on=self.tables.page.c.type,
None,
"page_join",
)
- magazine_page_mapper = mapper(
+ magazine_page_mapper = self.mapper_registry.map_imperatively(
MagazinePage,
self.tables.magazine_page,
with_polymorphic=("*", magazine_join),
magazine_join = self.tables.page.join(
self.tables.magazine_page
).outerjoin(self.tables.classified_page)
- magazine_page_mapper = mapper(
+ magazine_page_mapper = self.mapper_registry.map_imperatively(
MagazinePage,
self.tables.magazine_page,
with_polymorphic=("*", magazine_join),
},
)
else:
- magazine_page_mapper = mapper(
+ magazine_page_mapper = self.mapper_registry.map_imperatively(
MagazinePage,
self.tables.magazine_page,
inherits=page_mapper,
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
ClassifiedPage,
self.tables.classified_page,
inherits=magazine_page_mapper,
from sqlalchemy import String
from sqlalchemy import Table
from sqlalchemy.orm import class_mapper
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
class Group(Principal):
pass
- mapper(Principal, principals)
- mapper(User, users, inherits=Principal)
+ self.mapper_registry.map_imperatively(Principal, principals)
+ self.mapper_registry.map_imperatively(User, users, inherits=Principal)
- mapper(
+ self.mapper_registry.map_imperatively(
Group,
groups,
inherits=Principal,
class Bar(Foo):
pass
- mapper(Foo, foo)
- mapper(Bar, bar, inherits=Foo)
+ self.mapper_registry.map_imperatively(Foo, foo)
+ self.mapper_registry.map_imperatively(Bar, bar, inherits=Foo)
print(foo.join(bar).primary_key)
print(class_mapper(Bar).primary_key)
b = Bar("somedata")
def __init__(self, data=None):
self.data = data
- mapper(Foo, foo)
+ self.mapper_registry.map_imperatively(Foo, foo)
class Bar(Foo):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Bar,
bar,
inherits=Foo,
def __repr__(self):
return "Foo id %d, data %s" % (self.id, self.data)
- mapper(Foo, foo)
+ self.mapper_registry.map_imperatively(Foo, foo)
class Bar(Foo):
def __repr__(self):
return "Bar id %d, data %s" % (self.id, self.data)
- mapper(
+ self.mapper_registry.map_imperatively(
Bar,
bar,
inherits=Foo,
def __repr__(self):
return "Foo id %d, data %s" % (self.id, self.data)
- mapper(Foo, foo)
+ self.mapper_registry.map_imperatively(Foo, foo)
class Bar(Foo):
def __repr__(self):
return "Bar id %d, data %s" % (self.id, self.data)
- mapper(Bar, bar, inherits=Foo)
+ self.mapper_registry.map_imperatively(Bar, bar, inherits=Foo)
class Blub(Bar):
def __repr__(self):
repr([f for f in self.foos]),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Blub,
blub,
inherits=Bar,
from sqlalchemy.orm import backref
from sqlalchemy.orm import clear_mappers
from sqlalchemy.orm import configure_mappers
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import fixtures
from sqlalchemy.testing.fixtures import fixture_session
@classmethod
def define_tables(cls, metadata):
- global Table1, Table1B, Table2, Table3, Data
- table1 = Table(
+ Table(
"table1",
metadata,
Column(
Column("name", String(30)),
)
- table2 = Table(
+ Table(
"table2",
metadata,
Column("id", Integer, ForeignKey("table1.id"), primary_key=True),
)
- table3 = Table(
+ Table(
"table3",
metadata,
Column("id", Integer, ForeignKey("table1.id"), primary_key=True),
)
- data = Table(
+ Table(
"data",
metadata,
Column(
Column("data", String(30)),
)
+ @classmethod
+ def setup_mappers(cls):
+ global Table1, Table1B, Table2, Table3, Data
+ table1, table2, table3, data = cls.tables(
+ "table1", "table2", "table3", "data"
+ )
# join = polymorphic_union(
# {
# 'table3' : table1.join(table3),
try:
# this is how the mapping used to work. ensure that this raises an
# error now
- table1_mapper = mapper(
+ table1_mapper = cls.mapper_registry.map_imperatively(
Table1,
table1,
select_table=join,
uselist=False,
primaryjoin=join.c.id == join.c.related_id,
),
- "data": relationship(mapper(Data, data)),
+ "data": relationship(
+ cls.mapper_registry.map_imperatively(Data, data)
+ ),
},
)
configure_mappers()
# gets an exception instead of it silently not eager loading.
# NOTE: using "nxt" instead of "next" to avoid 2to3 turning it into
# __next__() for some reason.
- table1_mapper = mapper(
+ table1_mapper = cls.mapper_registry.map_imperatively(
Table1,
table1,
# select_table=join,
primaryjoin=table1.c.id == table1.c.related_id,
),
"data": relationship(
- mapper(Data, data), lazy="joined", order_by=data.c.id
+ cls.mapper_registry.map_imperatively(Data, data),
+ lazy="joined",
+ order_by=data.c.id,
),
},
)
- mapper(Table1B, inherits=table1_mapper, polymorphic_identity="table1b")
+ cls.mapper_registry.map_imperatively(
+ Table1B, inherits=table1_mapper, polymorphic_identity="table1b"
+ )
- mapper(
+ cls.mapper_registry.map_imperatively(
Table2,
table2,
inherits=table1_mapper,
polymorphic_identity="table2",
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Table3,
table3,
inherits=table1_mapper,
from sqlalchemy import String
from sqlalchemy import Table
from sqlalchemy import testing
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import polymorphic_union
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
"pjoin",
)
- person_mapper = mapper(
+ person_mapper = self.mapper_registry.map_imperatively(
Person,
people,
with_polymorphic=("*", person_join),
polymorphic_identity="person",
)
- mapper(
+ self.mapper_registry.map_imperatively(
Engineer,
engineers,
inherits=person_mapper,
polymorphic_identity="engineer",
)
- mapper(
+ self.mapper_registry.map_imperatively(
Manager,
managers,
inherits=person_mapper,
polymorphic_identity="manager",
)
- mapper(
+ self.mapper_registry.map_imperatively(
Company,
companies,
properties={
manager_with_polymorphic = None
if redefine_colprop:
- person_mapper = mapper(
+ person_mapper = cls.mapper_registry.map_imperatively(
Person,
people,
with_polymorphic=person_with_polymorphic,
properties={"person_name": people.c.name},
)
else:
- person_mapper = mapper(
+ person_mapper = cls.mapper_registry.map_imperatively(
Person,
people,
with_polymorphic=person_with_polymorphic,
polymorphic_identity="person",
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Engineer,
engineers,
inherits=person_mapper,
polymorphic_identity="engineer",
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Manager,
managers,
inherits=person_mapper,
polymorphic_identity="manager",
)
- mapper(Boss, boss, inherits=Manager, polymorphic_identity="boss")
+ cls.mapper_registry.map_imperatively(
+ Boss, boss, inherits=Manager, polymorphic_identity="boss"
+ )
- mapper(
+ cls.mapper_registry.map_imperatively(
Company,
companies,
properties={
from sqlalchemy import String
from sqlalchemy.orm import backref
from sqlalchemy.orm import deferred
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import fixtures
from sqlalchemy.testing.fixtures import fixture_session
pass
def test_one(self):
- product_mapper = mapper(
+ product_mapper = self.mapper_registry.map_imperatively(
Product,
products_table,
polymorphic_on=products_table.c.product_type,
polymorphic_identity="product",
)
- mapper(Detail, inherits=product_mapper, polymorphic_identity="detail")
+ self.mapper_registry.map_imperatively(
+ Detail, inherits=product_mapper, polymorphic_identity="detail"
+ )
- mapper(
+ self.mapper_registry.map_imperatively(
Assembly, inherits=product_mapper, polymorphic_identity="assembly"
)
- mapper(
+ self.mapper_registry.map_imperatively(
SpecLine,
specification_table,
properties=dict(
)
def test_two(self):
- product_mapper = mapper(
+ product_mapper = self.mapper_registry.map_imperatively(
Product,
products_table,
polymorphic_on=products_table.c.product_type,
polymorphic_identity="product",
)
- mapper(Detail, inherits=product_mapper, polymorphic_identity="detail")
+ self.mapper_registry.map_imperatively(
+ Detail, inherits=product_mapper, polymorphic_identity="detail"
+ )
- mapper(
+ self.mapper_registry.map_imperatively(
SpecLine,
specification_table,
properties=dict(
)
def test_three(self):
- product_mapper = mapper(
+ product_mapper = self.mapper_registry.map_imperatively(
Product,
products_table,
polymorphic_on=products_table.c.product_type,
polymorphic_identity="product",
)
- mapper(Detail, inherits=product_mapper, polymorphic_identity="detail")
- mapper(
+ self.mapper_registry.map_imperatively(
+ Detail, inherits=product_mapper, polymorphic_identity="detail"
+ )
+ self.mapper_registry.map_imperatively(
Assembly, inherits=product_mapper, polymorphic_identity="assembly"
)
- mapper(
+ self.mapper_registry.map_imperatively(
SpecLine,
specification_table,
properties=dict(
),
)
- document_mapper = mapper(
+ document_mapper = self.mapper_registry.map_imperatively(
Document,
documents_table,
polymorphic_on=documents_table.c.document_type,
),
),
)
- mapper(
+ self.mapper_registry.map_imperatively(
RasterDocument,
inherits=document_mapper,
polymorphic_identity="raster_document",
corresponding to an inheriting mapper but not the base mapper,
is created."""
- product_mapper = mapper(
+ product_mapper = self.mapper_registry.map_imperatively(
Product,
products_table,
polymorphic_on=products_table.c.product_type,
polymorphic_identity="product",
)
- mapper(Detail, inherits=product_mapper, polymorphic_identity="detail")
- mapper(
+ self.mapper_registry.map_imperatively(
+ Detail, inherits=product_mapper, polymorphic_identity="detail"
+ )
+ self.mapper_registry.map_imperatively(
Assembly, inherits=product_mapper, polymorphic_identity="assembly"
)
- document_mapper = mapper(
+ document_mapper = self.mapper_registry.map_imperatively(
Document,
documents_table,
polymorphic_on=documents_table.c.document_type,
),
),
)
- mapper(
+ self.mapper_registry.map_imperatively(
RasterDocument,
inherits=document_mapper,
polymorphic_identity="raster_document",
def test_five(self):
"""tests the late compilation of mappers"""
- mapper(
+ self.mapper_registry.map_imperatively(
SpecLine,
specification_table,
properties=dict(
),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Product,
products_table,
polymorphic_on=products_table.c.product_type,
},
)
- mapper(Detail, inherits=Product, polymorphic_identity="detail")
+ self.mapper_registry.map_imperatively(
+ Detail, inherits=Product, polymorphic_identity="detail"
+ )
- mapper(
+ self.mapper_registry.map_imperatively(
Document,
documents_table,
polymorphic_on=documents_table.c.document_type,
),
)
- mapper(
+ self.mapper_registry.map_imperatively(
RasterDocument,
inherits=Document,
polymorphic_identity="raster_document",
)
- mapper(Assembly, inherits=Product, polymorphic_identity="assembly")
+ self.mapper_registry.map_imperatively(
+ Assembly, inherits=Product, polymorphic_identity="assembly"
+ )
session = fixture_session()
from sqlalchemy.orm import configure_mappers
from sqlalchemy.orm import contains_eager
from sqlalchemy.orm import joinedload
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import selectinload
from sqlalchemy.orm import Session
def setup_mappers(cls):
engineers, people = cls.tables.engineers, cls.tables.people
- mapper(
+ cls.mapper_registry.map_imperatively(
Person,
people,
polymorphic_on=people.c.type,
polymorphic_identity="person",
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Engineer,
engineers,
inherits=Person,
managers = cls.tables.managers
people = cls.tables.people
- mapper(
+ cls.mapper_registry.map_imperatively(
Person,
people,
polymorphic_on=people.c.type,
polymorphic_identity="person",
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Manager, managers, inherits=Person, polymorphic_identity="manager"
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Engineer,
engineers,
inherits=Person,
engineers = cls.tables.engineers
people = cls.tables.people
- mapper(
+ cls.mapper_registry.map_imperatively(
Person,
people,
polymorphic_on=people.c.type,
polymorphic_identity="person",
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Engineer,
engineers,
inherits=Person,
class Organization(cls.Comparable):
pass
- mapper(
+ cls.mapper_registry.map_imperatively(
Organization,
organizations,
properties={
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Person,
people,
polymorphic_on=people.c.type,
polymorphic_identity="person",
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Engineer,
engineers,
inherits=Person,
Child2 = cls.classes.Child2
secondary = cls.tables.secondary
- mapper(Parent, parent, polymorphic_on=parent.c.cls)
+ cls.mapper_registry.map_imperatively(
+ Parent, parent, polymorphic_on=parent.c.cls
+ )
- mapper(
+ cls.mapper_registry.map_imperatively(
Child1,
child1,
inherits=Parent,
},
)
- mapper(Child2, child2, inherits=Parent, polymorphic_identity="child2")
+ cls.mapper_registry.map_imperatively(
+ Child2, child2, inherits=Parent, polymorphic_identity="child2"
+ )
def test_query_crit(self):
Child1, Child2 = self.classes.Child1, self.classes.Child2
related = cls.tables.related
Related = cls.classes.Related
- mapper(
+ cls.mapper_registry.map_imperatively(
Parent,
parent,
properties={"children": relationship(Sub, order_by=sub.c.data)},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Base,
base,
polymorphic_on=base.c.type,
properties={"related": relationship(Related)},
)
- mapper(Sub, sub, inherits=Base, polymorphic_identity="s")
+ cls.mapper_registry.map_imperatively(
+ Sub, sub, inherits=Base, polymorphic_identity="s"
+ )
- mapper(Related, related)
+ cls.mapper_registry.map_imperatively(Related, related)
@classmethod
def insert_data(cls, connection):
subparent = cls.tables.subparent
Subparent = cls.classes.Subparent
- mapper(
+ cls.mapper_registry.map_imperatively(
Parent,
parent,
polymorphic_on=parent.c.type,
polymorphic_identity="b",
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Subparent,
subparent,
inherits=Parent,
properties={"children": relationship(Sub, order_by=base.c.id)},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Base, base, polymorphic_on=base.c.type, polymorphic_identity="b"
)
- mapper(Sub, sub, inherits=Base, polymorphic_identity="s")
+ cls.mapper_registry.map_imperatively(
+ Sub, sub, inherits=Base, polymorphic_identity="s"
+ )
@classmethod
def insert_data(cls, connection):
C = cls.classes.C
D = cls.classes.D
- mapper(A, cls.tables.a, polymorphic_on=cls.tables.a.c.type)
- mapper(
+ cls.mapper_registry.map_imperatively(
+ A, cls.tables.a, polymorphic_on=cls.tables.a.c.type
+ )
+ cls.mapper_registry.map_imperatively(
B,
cls.tables.b,
inherits=A,
polymorphic_identity="b",
properties={"related": relationship(D, secondary=cls.tables.btod)},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
C,
cls.tables.c,
inherits=A,
polymorphic_identity="c",
properties={"related": relationship(D, secondary=cls.tables.ctod)},
)
- mapper(D, cls.tables.d)
+ cls.mapper_registry.map_imperatively(D, cls.tables.d)
@classmethod
def insert_data(cls, connection):
B = cls.classes.B
D = cls.classes.D
- mapper(Z, cls.tables.z)
- mapper(
+ cls.mapper_registry.map_imperatively(Z, cls.tables.z)
+ cls.mapper_registry.map_imperatively(
A,
cls.tables.a,
polymorphic_on=cls.tables.a.c.type,
with_polymorphic="*",
properties={"zs": relationship(Z, lazy="subquery")},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
B,
cls.tables.b,
inherits=A,
)
},
)
- mapper(D, cls.tables.d, inherits=A, polymorphic_identity="d")
+ cls.mapper_registry.map_imperatively(
+ D, cls.tables.d, inherits=A, polymorphic_identity="d"
+ )
@classmethod
def insert_data(cls, connection):
def setup_mappers(cls):
Parent, Base1, Base2, Sub1, Sub2, EP1, EP2 = cls._classes()
- mapper(
+ cls.mapper_registry.map_imperatively(
Parent, cls.tables.parent, properties={"sub1": relationship(Sub1)}
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Base1, cls.tables.base1, properties={"sub2": relationship(Sub2)}
)
- mapper(Sub1, cls.tables.sub1, inherits=Base1)
- mapper(
+ cls.mapper_registry.map_imperatively(
+ Sub1, cls.tables.sub1, inherits=Base1
+ )
+ cls.mapper_registry.map_imperatively(
Base2,
cls.tables.base2,
properties={"ep1": relationship(EP1), "ep2": relationship(EP2)},
)
- mapper(Sub2, cls.tables.sub2, inherits=Base2)
- mapper(EP1, cls.tables.ep1)
- mapper(EP2, cls.tables.ep2)
+ cls.mapper_registry.map_imperatively(
+ Sub2, cls.tables.sub2, inherits=Base2
+ )
+ cls.mapper_registry.map_imperatively(EP1, cls.tables.ep1)
+ cls.mapper_registry.map_imperatively(EP2, cls.tables.ep2)
def test_one(self):
Parent, Base1, Base2, Sub1, Sub2, EP1, EP2 = self._classes()
def setup_mappers(cls):
A, B, C, D = cls.classes.A, cls.classes.B, cls.classes.C, cls.classes.D
a, b, c, d = cls.tables.a, cls.tables.b, cls.tables.c, cls.tables.d
- mapper(A, a)
- mapper(B, b, inherits=A)
- mapper(C, c, inherits=A)
- mapper(D, d, inherits=A)
+ cls.mapper_registry.map_imperatively(A, a)
+ cls.mapper_registry.map_imperatively(B, b, inherits=A)
+ cls.mapper_registry.map_imperatively(C, c, inherits=A)
+ cls.mapper_registry.map_imperatively(D, d, inherits=A)
def _two_join_fixture(self):
B, C, D = (self.classes.B, self.classes.C, self.classes.D)
class B(cls.Comparable):
pass
- mapper(
+ cls.mapper_registry.map_imperatively(
A,
cls.tables.a,
polymorphic_on=cls.tables.a.c.t,
properties={"bs": relationship(B, cascade="all, delete-orphan")},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
ASub,
cls.tables.a_sub,
inherits=A,
properties={"bs": relationship(B, cascade="all, delete-orphan")},
)
- mapper(B, cls.tables.b)
+ cls.mapper_registry.map_imperatively(B, cls.tables.b)
def test_persist(self):
A, ASub, B = self.classes("A", "ASub", "B")
from sqlalchemy import Integer
from sqlalchemy import select
from sqlalchemy import String
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import Session
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
class Baz(Foo):
pass
- mapper(Foo, foo, polymorphic_on=foo.c.b)
+ self.mapper_registry.map_imperatively(Foo, foo, polymorphic_on=foo.c.b)
- mapper(
+ self.mapper_registry.map_imperatively(
Baz,
baz,
with_polymorphic=(
polymorphic_identity="baz",
)
- mapper(
+ self.mapper_registry.map_imperatively(
Bar,
bar,
with_polymorphic=(
base, child = self.tables.base, self.tables.child
base_select = select(base).alias()
- mapper(
+ self.mapper_registry.map_imperatively(
Base,
base_select,
polymorphic_on=base_select.c.type,
polymorphic_identity="base",
)
- mapper(Child, child, inherits=Base, polymorphic_identity="child")
+ self.mapper_registry.map_imperatively(
+ Child, child, inherits=Base, polymorphic_identity="child"
+ )
sess = fixture_session()
from sqlalchemy.orm import aliased
from sqlalchemy.orm import Bundle
from sqlalchemy.orm import joinedload
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
from sqlalchemy.orm import subqueryload
cls.classes.Engineer,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Report, reports, properties={"employee": relationship(Employee)}
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Employee,
employees,
polymorphic_on=employees.c.type,
"reports": relationship(Report, back_populates="employee")
},
)
- mapper(Manager, inherits=Employee, polymorphic_identity="manager")
- mapper(Engineer, inherits=Employee, polymorphic_identity="engineer")
- mapper(
+ cls.mapper_registry.map_imperatively(
+ Manager, inherits=Employee, polymorphic_identity="manager"
+ )
+ cls.mapper_registry.map_imperatively(
+ Engineer, inherits=Employee, polymorphic_identity="engineer"
+ )
+ cls.mapper_registry.map_imperatively(
JuniorEngineer,
inherits=Engineer,
polymorphic_identity="juniorengineer",
cls.classes.Manager,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Employee,
employee,
polymorphic_on=employee.c.type,
polymorphic_identity="employee",
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Manager,
inherits=Employee,
polymorphic_identity="manager",
properties={"stuff": relationship(Stuff)},
)
- mapper(Stuff, employee_stuff)
+ cls.mapper_registry.map_imperatively(Stuff, employee_stuff)
@classmethod
def setup_classes(cls):
self.classes.Engineer,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Company,
companies,
properties={
"employees": relationship(Employee, backref="company")
},
)
- mapper(Employee, employees, polymorphic_on=employees.c.type)
- mapper(Manager, inherits=Employee, polymorphic_identity="manager")
- mapper(Engineer, inherits=Employee, polymorphic_identity="engineer")
- mapper(
+ self.mapper_registry.map_imperatively(
+ Employee, employees, polymorphic_on=employees.c.type
+ )
+ self.mapper_registry.map_imperatively(
+ Manager, inherits=Employee, polymorphic_identity="manager"
+ )
+ self.mapper_registry.map_imperatively(
+ Engineer, inherits=Employee, polymorphic_identity="engineer"
+ )
+ self.mapper_registry.map_imperatively(
JuniorEngineer,
inherits=Engineer,
polymorphic_identity="juniorengineer",
)
companies, employees = self.tables.companies, self.tables.employees
- mapper(
+ self.mapper_registry.map_imperatively(
Company, companies, properties={"employee": relationship(Employee)}
)
- mapper(Employee, employees, polymorphic_on=employees.c.type)
- mapper(Engineer, inherits=Employee, polymorphic_identity="engineer")
+ self.mapper_registry.map_imperatively(
+ Employee, employees, polymorphic_on=employees.c.type
+ )
+ self.mapper_registry.map_imperatively(
+ Engineer, inherits=Employee, polymorphic_identity="engineer"
+ )
sess = fixture_session()
self.assert_compile(
)
companies, employees = self.tables.companies, self.tables.employees
- mapper(
+ self.mapper_registry.map_imperatively(
Company,
companies,
properties={"employees": relationship(Employee)},
)
- mapper(Employee, employees)
- mapper(Engineer, inherits=Employee)
+ self.mapper_registry.map_imperatively(Employee, employees)
+ self.mapper_registry.map_imperatively(Engineer, inherits=Employee)
sess = fixture_session()
self.assert_compile(
)
companies, employees = self.tables.companies, self.tables.employees
- mapper(
+ self.mapper_registry.map_imperatively(
Company,
companies,
properties={"engineers": relationship(Engineer)},
)
- mapper(Employee, employees, polymorphic_on=employees.c.type)
- mapper(Engineer, inherits=Employee, polymorphic_identity="engineer")
+ self.mapper_registry.map_imperatively(
+ Employee, employees, polymorphic_on=employees.c.type
+ )
+ self.mapper_registry.map_imperatively(
+ Engineer, inherits=Employee, polymorphic_identity="engineer"
+ )
sess = fixture_session()
self.assert_compile(
)
companies, employees = self.tables.companies, self.tables.employees
- mapper(
+ self.mapper_registry.map_imperatively(
Company,
companies,
properties={"engineers": relationship(Engineer)},
)
- mapper(Employee, employees, polymorphic_on=employees.c.type)
- mapper(Engineer, inherits=Employee, polymorphic_identity="engineer")
+ self.mapper_registry.map_imperatively(
+ Employee, employees, polymorphic_on=employees.c.type
+ )
+ self.mapper_registry.map_imperatively(
+ Engineer, inherits=Employee, polymorphic_identity="engineer"
+ )
eng_alias = aliased(Engineer)
sess = fixture_session()
)
companies, employees = self.tables.companies, self.tables.employees
- mapper(
+ self.mapper_registry.map_imperatively(
Company,
companies,
properties={"engineers": relationship(Engineer)},
)
- mapper(Employee, employees, polymorphic_on=employees.c.type)
- mapper(Engineer, inherits=Employee, polymorphic_identity="engineer")
+ self.mapper_registry.map_imperatively(
+ Employee, employees, polymorphic_on=employees.c.type
+ )
+ self.mapper_registry.map_imperatively(
+ Engineer, inherits=Employee, polymorphic_identity="engineer"
+ )
sess = fixture_session()
self.assert_compile(
)
companies, employees = self.tables.companies, self.tables.employees
- mapper(
+ self.mapper_registry.map_imperatively(
Company,
companies,
properties={"engineers": relationship(Engineer)},
)
- mapper(Employee, employees, polymorphic_on=employees.c.type)
- mapper(Engineer, inherits=Employee, polymorphic_identity="engineer")
+ self.mapper_registry.map_imperatively(
+ Employee, employees, polymorphic_on=employees.c.type
+ )
+ self.mapper_registry.map_imperatively(
+ Engineer, inherits=Employee, polymorphic_identity="engineer"
+ )
eng_alias = aliased(Engineer)
sess = fixture_session()
)
companies, employees = self.tables.companies, self.tables.employees
- mapper(
+ self.mapper_registry.map_imperatively(
Company,
companies,
properties={"engineers": relationship(Engineer)},
)
- mapper(Employee, employees, polymorphic_on=employees.c.type)
- mapper(Engineer, inherits=Employee, polymorphic_identity="engineer")
+ self.mapper_registry.map_imperatively(
+ Employee, employees, polymorphic_on=employees.c.type
+ )
+ self.mapper_registry.map_imperatively(
+ Engineer, inherits=Employee, polymorphic_identity="engineer"
+ )
sess = fixture_session()
self.assert_compile(
)
companies, employees = self.tables.companies, self.tables.employees
- mapper(
+ self.mapper_registry.map_imperatively(
Company,
companies,
properties={"engineers": relationship(Engineer)},
)
- mapper(Employee, employees, polymorphic_on=employees.c.type)
- mapper(Engineer, inherits=Employee, polymorphic_identity="engineer")
+ self.mapper_registry.map_imperatively(
+ Employee, employees, polymorphic_on=employees.c.type
+ )
+ self.mapper_registry.map_imperatively(
+ Engineer, inherits=Employee, polymorphic_identity="engineer"
+ )
eng_alias = aliased(Engineer)
sess = fixture_session()
)
companies, employees = self.tables.companies, self.tables.employees
- mapper(Company, companies)
- mapper(
+ self.mapper_registry.map_imperatively(Company, companies)
+ self.mapper_registry.map_imperatively(
Employee,
employees,
polymorphic_on=employees.c.type,
properties={"company": relationship(Company)},
)
- mapper(Engineer, inherits=Employee, polymorphic_identity="engineer")
+ self.mapper_registry.map_imperatively(
+ Engineer, inherits=Employee, polymorphic_identity="engineer"
+ )
sess = fixture_session()
engineer_count = (
companies, employees = self.tables.companies, self.tables.employees
- mapper(
+ self.mapper_registry.map_imperatively(
Company,
companies,
properties={
"employees": relationship(Employee, backref="company")
},
)
- mapper(Employee, employees, polymorphic_on=employees.c.type)
- mapper(Engineer, inherits=Employee, polymorphic_identity="engineer")
- mapper(Manager, inherits=Employee, polymorphic_identity="manager")
+ self.mapper_registry.map_imperatively(
+ Employee, employees, polymorphic_on=employees.c.type
+ )
+ self.mapper_registry.map_imperatively(
+ Engineer, inherits=Employee, polymorphic_identity="engineer"
+ )
+ self.mapper_registry.map_imperatively(
+ Manager, inherits=Employee, polymorphic_identity="manager"
+ )
s = fixture_session()
self.classes.Engineer,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Company,
companies,
properties={
"engineers": relationship(Engineer, back_populates="company")
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Employee,
employees,
polymorphic_on=employees.c.type,
properties={"company": relationship(Company)},
)
- mapper(Manager, inherits=Employee, polymorphic_identity="manager")
- mapper(Engineer, inherits=Employee, polymorphic_identity="engineer")
- mapper(
+ self.mapper_registry.map_imperatively(
+ Manager, inherits=Employee, polymorphic_identity="manager"
+ )
+ self.mapper_registry.map_imperatively(
+ Engineer, inherits=Employee, polymorphic_identity="engineer"
+ )
+ self.mapper_registry.map_imperatively(
JuniorEngineer,
inherits=Engineer,
polymorphic_identity="juniorengineer",
@classmethod
def setup_mappers(cls):
- mapper(
+ cls.mapper_registry.map_imperatively(
cls.classes.Parent,
cls.tables.parent,
properties={
),
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
cls.classes.Child,
cls.tables.child,
polymorphic_on=cls.tables.child.c.discriminator,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
cls.classes.SubChild1,
inherits=cls.classes.Child,
polymorphic_identity="sub1",
)
- mapper(
+ cls.mapper_registry.map_imperatively(
cls.classes.SubChild2,
inherits=cls.classes.Child,
polymorphic_identity="sub2",
class Manager(Employee):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Person,
persons_table,
polymorphic_on=persons_table.c.type,
polymorphic_identity="person",
)
- mapper(
+ self.mapper_registry.map_imperatively(
Employee,
employees_table,
inherits=Person,
polymorphic_identity="engineer",
)
- mapper(Manager, inherits=Employee, polymorphic_identity="manager")
+ self.mapper_registry.map_imperatively(
+ Manager, inherits=Employee, polymorphic_identity="manager"
+ )
sess = fixture_session()
sess.add(Person(name="p1"))
from sqlalchemy import Integer
from sqlalchemy import select
from sqlalchemy import String
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
"items", "item_keywords", "keywords"
)
- mapper(Keyword, keywords)
- mapper(
+ cls.mapper_registry.map_imperatively(Keyword, keywords)
+ cls.mapper_registry.map_imperatively(
KeywordAssociation,
item_keywords,
properties={"keyword": relationship(Keyword, lazy="joined")},
primary_key=[item_keywords.c.item_id, item_keywords.c.keyword_id],
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Item,
items,
properties={
from sqlalchemy import testing
from sqlalchemy import text
from sqlalchemy.orm import backref
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
from sqlalchemy.testing import eq_
cls.tables.categories,
)
- mapper(Owner, owners)
+ cls.mapper_registry.map_imperatively(Owner, owners)
- mapper(Category, categories)
+ cls.mapper_registry.map_imperatively(Category, categories)
- mapper(
+ cls.mapper_registry.map_imperatively(
Option,
options,
properties=dict(
),
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Thing,
tests,
properties=dict(
)
# set up bi-directional eager loads
- mapper(Left, left)
- mapper(Right, right)
- mapper(
+ cls.mapper_registry.map_imperatively(Left, left)
+ cls.mapper_registry.map_imperatively(Right, right)
+ cls.mapper_registry.map_imperatively(
Middle,
middle,
properties=dict(
self.tables.datas,
)
- mapper(Data, datas)
- mapper(
+ self.mapper_registry.map_imperatively(Data, datas)
+ self.mapper_registry.map_imperatively(
Foo,
foo,
properties={
},
)
- mapper(Stat, stats, properties={"data": relationship(Data)})
+ self.mapper_registry.map_imperatively(
+ Stat, stats, properties={"data": relationship(Data)}
+ )
session = fixture_session()
self.tables.departments,
)
- mapper(Employee, employees)
- mapper(
+ self.mapper_registry.map_imperatively(Employee, employees)
+ self.mapper_registry.map_imperatively(
Department,
departments,
properties=dict(
self.tables.derivedII,
)
- mapper(Comment, comments)
+ self.mapper_registry.map_imperatively(Comment, comments)
- baseMapper = mapper(
+ baseMapper = self.mapper_registry.map_imperatively(
Base,
base,
properties=dict(
),
)
- mapper(Derived, derived, inherits=baseMapper)
+ self.mapper_registry.map_imperatively(
+ Derived, derived, inherits=baseMapper
+ )
- mapper(DerivedII, derivedII, inherits=baseMapper)
+ self.mapper_registry.map_imperatively(
+ DerivedII, derivedII, inherits=baseMapper
+ )
sess = fixture_session()
d = Derived("uid1", "x", "y")
self.classes.InheritedPart,
)
- p_m = mapper(Part, parts)
+ p_m = self.mapper_registry.map_imperatively(Part, parts)
- mapper(
+ self.mapper_registry.map_imperatively(
InheritedPart,
inherited_part,
properties=dict(part=relationship(Part, lazy="joined")),
)
- d_m = mapper(
+ d_m = self.mapper_registry.map_imperatively(
Design,
design,
properties=dict(
),
)
- mapper(DesignType, design_types)
+ self.mapper_registry.map_imperatively(DesignType, design_types)
d_m.add_property(
"type", relationship(DesignType, lazy="joined", backref="designs")
self.classes.Address,
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(
Company,
companies,
properties={"addresses": relationship(Address, lazy="joined")},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Invoice,
invoices,
properties={"company": relationship(Company, lazy="joined")},
# concerning corresponding_column() being extremely accurate
# as well as how mapper sets up its column properties
- mapper(Task_Type, task_type)
+ self.mapper_registry.map_imperatively(Task_Type, task_type)
j = sa.outerjoin(task, msg, task.c.id == msg.c.task_id)
jj = (
)
jjj = sa.join(task, jj, task.c.id == jj.c.task_id)
- mapper(
+ self.mapper_registry.map_imperatively(
Joined,
jjj,
properties=dict(type=relationship(Task_Type, lazy="joined")),
cls.classes.Entry,
)
- mapper(Account, accounts)
+ cls.mapper_registry.map_imperatively(Account, accounts)
- mapper(Transaction, transactions)
+ cls.mapper_registry.map_imperatively(Transaction, transactions)
- mapper(
+ cls.mapper_registry.map_imperatively(
Entry,
entries,
properties=dict(
from sqlalchemy import text
from sqlalchemy.orm import attributes
from sqlalchemy.orm import backref
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
from sqlalchemy.testing import eq_
cls.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ cls.mapper_registry.map_imperatively(Address, addresses)
+ cls.mapper_registry.map_imperatively(
User,
users,
properties=dict(addresses=relationship(Address, backref="user")),
cls.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ cls.mapper_registry.map_imperatively(Address, addresses)
+ cls.mapper_registry.map_imperatively(
User,
users,
properties={
cls.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ cls.mapper_registry.map_imperatively(Address, addresses)
+ cls.mapper_registry.map_imperatively(
User,
users,
properties={
cls.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ cls.mapper_registry.map_imperatively(Address, addresses)
+ cls.mapper_registry.map_imperatively(
User,
users,
properties={
cls.classes.Item,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Item,
items,
properties={
)
},
)
- mapper(Keyword, keywords)
+ cls.mapper_registry.map_imperatively(Keyword, keywords)
def test_add_remove_pending_backref(self):
"""test that pending doesn't add an item that's not a net add."""
cls.classes.Item,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Item,
items,
properties={
)
},
)
- mapper(Keyword, keywords)
+ cls.mapper_registry.map_imperatively(Keyword, keywords)
def test_collection_move_preloaded(self):
Item, Keyword = self.classes.Item, self.classes.Keyword
cls.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ cls.mapper_registry.map_imperatively(Address, addresses)
+ cls.mapper_registry.map_imperatively(
User,
users,
properties=dict(addresses=relationship(Address, backref="user")),
cls.classes.Item,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Item,
items,
properties={
)
},
)
- mapper(Keyword, keywords)
+ cls.mapper_registry.map_imperatively(Keyword, keywords)
def test_backref_pop_m2m(self):
Keyword, Item = self.classes.Keyword, self.classes.Item
from sqlalchemy import update
from sqlalchemy.orm import aliased
from sqlalchemy.orm import backref
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
from sqlalchemy.orm import sessionmaker
users_unbound = users.to_metadata(m2)
addresses_unbound = addresses.to_metadata(m2)
- mapper(Address, addresses_unbound)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses_unbound)
+ self.mapper_registry.map_imperatively(
User,
users_unbound,
properties={
users_unbound = users.to_metadata(m2)
addresses_unbound = addresses.to_metadata(m2)
- mapper(Address, addresses_unbound)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses_unbound)
+ self.mapper_registry.map_imperatively(
User,
users_unbound,
properties={
def test_bind_from_metadata(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
session = fixture_session()
self.classes.User,
)
- mapper(User, users, properties={"addresses": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
e1 = engines.testing_engine()
e2 = engines.testing_engine()
self.classes.User,
)
- mapper(User, users, properties={"addresses": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
e1 = engines.testing_engine()
e2 = engines.testing_engine()
testing.db,
)
- mapper(self.classes.User, self.tables.users)
+ self.mapper_registry.map_imperatively(
+ self.classes.User, self.tables.users
+ )
u_object = self.classes.User()
assert_raises_message(
def test_bound_connection(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
c = testing.db.connect()
sess = Session(bind=c)
sess.begin()
def test_bound_connection_transactional(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
with testing.db.connect() as c:
sess = Session(bind=c, autocommit=False)
test_table.to_metadata(meta)
assert meta.tables["test_table"].bind is None
- mapper(Foo, meta.tables["test_table"])
+ cls.mapper_registry.map_imperatively(Foo, meta.tables["test_table"])
def test_session_bind(self):
Foo = self.classes.Foo
@classmethod
def setup_mappers(cls):
- mapper(cls.classes.ClassWMixin, cls.tables.w_mixin_table)
- mapper(cls.classes.BaseClass, cls.tables.base_table)
- mapper(
+ cls.mapper_registry.map_imperatively(
+ cls.classes.ClassWMixin, cls.tables.w_mixin_table
+ )
+ cls.mapper_registry.map_imperatively(
+ cls.classes.BaseClass, cls.tables.base_table
+ )
+ cls.mapper_registry.map_imperatively(
cls.classes.JoinedSubClass,
cls.tables.joined_sub_table,
inherits=cls.classes.BaseClass,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
cls.classes.ConcreteSubClass,
cls.tables.concrete_sub_table,
inherits=cls.classes.BaseClass,
from sqlalchemy import Integer
from sqlalchemy import String
from sqlalchemy import testing
-from sqlalchemy.orm import mapper
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import mock
def setup_mappers(cls):
Foo, version_table = cls.classes.Foo, cls.tables.version_table
- mapper(Foo, version_table, version_id_col=version_table.c.version_id)
+ cls.mapper_registry.map_imperatively(
+ Foo, version_table, version_id_col=version_table.c.version_id
+ )
@testing.emits_warning(r".*versioning cannot be verified")
def test_bulk_insert_via_save(self):
User, Address, Order = cls.classes("User", "Address", "Order")
u, a, o = cls.tables("users", "addresses", "orders")
- mapper(User, u)
- mapper(Address, a)
- mapper(Order, o)
+ cls.mapper_registry.map_imperatively(User, u)
+ cls.mapper_registry.map_imperatively(Address, a)
+ cls.mapper_registry.map_imperatively(Order, o)
def test_bulk_save_return_defaults(self):
(User,) = self.classes("User")
A = cls.classes.A
a = cls.tables.a
- mapper(A, a)
+ cls.mapper_registry.map_imperatively(A, a)
def test_insert_w_fetch(self):
A = self.classes.A
"people_keys", "people_attrs", "people_both"
)
- mapper(PersonKeys, people_keys)
- mapper(
+ cls.mapper_registry.map_imperatively(PersonKeys, people_keys)
+ cls.mapper_registry.map_imperatively(
PersonAttrs,
people_attrs,
properties={
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
PersonBoth,
people_both,
properties={
)
p, e, m, b = cls.tables("people", "engineers", "managers", "boss")
- mapper(
+ cls.mapper_registry.map_imperatively(
Person, p, polymorphic_on=p.c.type, polymorphic_identity="person"
)
- mapper(Engineer, e, inherits=Person, polymorphic_identity="engineer")
- mapper(Manager, m, inherits=Person, polymorphic_identity="manager")
- mapper(Boss, b, inherits=Manager, polymorphic_identity="boss")
+ cls.mapper_registry.map_imperatively(
+ Engineer, e, inherits=Person, polymorphic_identity="engineer"
+ )
+ cls.mapper_registry.map_imperatively(
+ Manager, m, inherits=Person, polymorphic_identity="manager"
+ )
+ cls.mapper_registry.map_imperatively(
+ Boss, b, inherits=Manager, polymorphic_identity="boss"
+ )
def test_bulk_save_joined_inh_return_defaults(self):
Person, Engineer, Manager, Boss = self.classes(
from sqlalchemy import tuple_
from sqlalchemy.orm import aliased
from sqlalchemy.orm import Bundle
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
from sqlalchemy.sql.elements import ClauseList
@classmethod
def setup_mappers(cls):
- mapper(
+ cls.mapper_registry.map_imperatively(
cls.classes.Data,
cls.tables.data,
properties={"others": relationship(cls.classes.Other)},
)
- mapper(cls.classes.Other, cls.tables.other)
+ cls.mapper_registry.map_imperatively(
+ cls.classes.Other, cls.tables.other
+ )
@classmethod
def insert_data(cls, connection):
from sqlalchemy.orm import lazyload
from sqlalchemy.orm import Load
from sqlalchemy.orm import load_only
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import Query
from sqlalchemy.orm import relationship
from sqlalchemy.orm import selectinload
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
from sqlalchemy.orm import configure_mappers
from sqlalchemy.orm import exc as orm_exc
from sqlalchemy.orm import foreign
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import object_mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
User, Address = self.classes.User, self.classes.Address
users, addresses = self.tables.users, self.tables.addresses
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
assert_raises_message(
sa_exc.ArgumentError,
"On User.addresses, can't set passive_deletes='all' "
def test_bad_cascade(self):
addresses, Address = self.tables.addresses, self.classes.Address
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
assert_raises_message(
sa_exc.ArgumentError,
r"Invalid cascade option\(s\): 'fake', 'fake2'",
rel.cascade = "save-update, merge, expunge"
eq_(rel.cascade, set(["save-update", "merge", "expunge"]))
- mapper(User, users, properties={"addresses": rel})
- am = mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": rel}
+ )
+ am = self.mapper_registry.map_imperatively(Address, addresses)
configure_mappers()
eq_(rel.cascade, set(["save-update", "merge", "expunge"]))
cls.tables.addresses,
)
- mapper(Address, addresses)
- mapper(Order, orders)
- mapper(
+ cls.mapper_registry.map_imperatively(Address, addresses)
+ cls.mapper_registry.map_imperatively(Order, orders)
+ cls.mapper_registry.map_imperatively(
User,
users,
properties={
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Dingaling,
dingalings,
properties={"address": relationship(Address)},
cls.tables.addresses,
)
- mapper(Address, addresses)
- mapper(
+ cls.mapper_registry.map_imperatively(Address, addresses)
+ cls.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
cls.tables.users,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
User,
users,
properties=dict(
- orders=relationship(mapper(Order, orders), cascade="all")
+ orders=relationship(
+ cls.mapper_registry.map_imperatively(Order, orders),
+ cascade="all",
+ )
),
)
cls.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ cls.mapper_registry.map_imperatively(Address, addresses)
+ cls.mapper_registry.map_imperatively(
User,
users,
properties={
cls.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ cls.mapper_registry.map_imperatively(Address, addresses)
+ cls.mapper_registry.map_imperatively(
User,
users,
properties={
addresses_rel = {}
user_rel = {}
- mapper(User, users, properties=addresses_rel)
- mapper(Address, addresses, properties=user_rel)
+ self.mapper_registry.map_imperatively(
+ User, users, properties=addresses_rel
+ )
+ self.mapper_registry.map_imperatively(
+ Address, addresses, properties=user_rel
+ )
def _many_to_many_fixture(
self,
keywords_rel = {}
items_rel = {}
- mapper(Item, items, properties=keywords_rel)
- mapper(Keyword, keywords, properties=items_rel)
+ self.mapper_registry.map_imperatively(
+ Item, items, properties=keywords_rel
+ )
+ self.mapper_registry.map_imperatively(
+ Keyword, keywords, properties=items_rel
+ )
def test_o2m_only_child_pending(self):
User, Address = self.classes.User, self.classes.Address
self.tables.orders,
)
- mapper(Order, orders)
- mapper(
+ self.mapper_registry.map_imperatively(Order, orders)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.tables.orders,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
self.classes.Item,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Item,
items,
properties={
)
},
)
- mapper(Keyword, keywords)
+ self.mapper_registry.map_imperatively(Keyword, keywords)
sess = fixture_session()
cls.classes.Foo,
)
- mapper(Extra, extra)
- mapper(
+ cls.mapper_registry.map_imperatively(Extra, extra)
+ cls.mapper_registry.map_imperatively(
Pref,
prefs,
properties=dict(extra=relationship(Extra, cascade="all, delete")),
)
- mapper(
+ cls.mapper_registry.map_imperatively(
User,
users,
properties=dict(
),
),
) # straight m2o
- mapper(Foo, foo)
+ cls.mapper_registry.map_imperatively(Foo, foo)
@classmethod
def insert_data(cls, connection):
cls.classes.T1,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
T1,
t1,
properties=dict(
)
),
)
- mapper(
+ cls.mapper_registry.map_imperatively(
T2,
t2,
properties=dict(
)
),
)
- mapper(T3, t3)
+ cls.mapper_registry.map_imperatively(T3, t3)
def test_cascade_delete(self):
T2, T3, T1 = (self.classes.T2, self.classes.T3, self.classes.T1)
cls.classes.T1,
)
- mapper(T1, t1, properties={"t2": relationship(T2, cascade="all")})
- mapper(T2, t2, properties={"t3": relationship(T3, cascade="all")})
- mapper(T3, t3)
+ cls.mapper_registry.map_imperatively(
+ T1, t1, properties={"t2": relationship(T2, cascade="all")}
+ )
+ cls.mapper_registry.map_imperatively(
+ T2, t2, properties={"t3": relationship(T3, cascade="all")}
+ )
+ cls.mapper_registry.map_imperatively(T3, t3)
def test_cascade_delete(self):
T2, T3, T1 = (self.classes.T2, self.classes.T3, self.classes.T1)
# if no backref here, delete-orphan failed until [ticket:427]
# was fixed
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
properties={
)
},
)
- mapper(B, b)
+ self.mapper_registry.map_imperatively(B, b)
sess = fixture_session()
b1 = B(data="b1")
self.tables.atob,
)
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
# if no backref here, delete-orphan
},
)
# failed until [ticket:427] was fixed
- mapper(B, b)
+ self.mapper_registry.map_imperatively(B, b)
sess = fixture_session()
b1 = B(data="b1")
self.tables.atob,
)
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
B,
b,
properties={"cs": relationship(C, cascade="all, delete-orphan")},
)
- mapper(C, c)
+ self.mapper_registry.map_imperatively(C, c)
sess = fixture_session()
b1 = B(data="b1", cs=[C(data="c1")])
self.tables.atob,
)
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
properties={
)
},
)
- mapper(B, b)
+ self.mapper_registry.map_imperatively(B, b)
sess = fixture_session()
a1 = A(data="a1", bs=[B(data="b1")])
self.tables.atob,
)
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
properties={
)
},
)
- mapper(B, b)
+ self.mapper_registry.map_imperatively(B, b)
assert_raises_message(
sa_exc.ArgumentError,
"For many-to-many relationship A.bs, delete-orphan cascade",
self.tables.atob,
)
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
properties={
)
},
)
- mapper(B, b)
+ self.mapper_registry.map_imperatively(B, b)
b1 = B(data="b1")
A(data="a1", bs=[b1])
self.tables.atob,
)
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
properties={
)
},
)
- mapper(B, b)
+ self.mapper_registry.map_imperatively(B, b)
b1 = B(data="b1")
a1 = A(data="a1", bs=[b1])
self.tables.atob,
)
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
properties={"bs": relationship(B, secondary=atob, backref="as")},
)
- mapper(B, b)
+ self.mapper_registry.map_imperatively(B, b)
s = fixture_session()
a1 = A(bs=[None])
self.tables.atob,
)
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
properties={"bs": relationship(B, secondary=atob, backref="as")},
)
- mapper(B, b)
+ self.mapper_registry.map_imperatively(B, b)
s = fixture_session()
a1 = A()
def setup_mappers(cls):
Node = cls.classes.Node
node = cls.tables.node
- mapper(
+ cls.mapper_registry.map_imperatively(
Node,
node,
properties={
cls.tables.users,
)
- mapper(Address, addresses)
- mapper(
+ cls.mapper_registry.map_imperatively(Address, addresses)
+ cls.mapper_registry.map_imperatively(
User,
users,
properties={
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Dingaling,
dingalings,
properties={
self.tables.addresses,
)
- mapper(Order, orders)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Order, orders)
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.classes.Item,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
order,
properties={
"items": relationship(Item, cascade="all, delete-orphan")
},
)
- mapper(Item, item)
+ self.mapper_registry.map_imperatively(Item, item)
s = fixture_session()
o1 = Order()
s.add(o1)
self.classes.Order,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
order,
properties={
"items": relationship(Item, cascade="all, delete-orphan")
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Item,
item,
properties={
)
},
)
- mapper(Attribute, attribute)
+ self.mapper_registry.map_imperatively(Attribute, attribute)
s = fixture_session()
o1 = Order()
s.add(o1)
class SalesRep(fixtures.ComparableEntity):
pass
- mapper(Customer, customers, legacy_is_orphan=legacy_is_orphan)
- mapper(
+ self.mapper_registry.map_imperatively(
+ Customer, customers, legacy_is_orphan=legacy_is_orphan
+ )
+ self.mapper_registry.map_imperatively(
Account,
accounts,
properties=dict(
)
),
)
- mapper(
+ self.mapper_registry.map_imperatively(
SalesRep,
sales_reps,
properties=dict(
class Business(fixtures.ComparableEntity):
pass
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
Home,
homes,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Business,
businesses,
properties={
class Business(fixtures.ComparableEntity):
pass
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
Home,
homes,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Business,
businesses,
properties={
class B(fixtures.ComparableEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
A,
table_a,
properties={"bs": relationship(B, cascade="all, delete-orphan")},
)
- mapper(B, table_b)
+ self.mapper_registry.map_imperatively(B, table_b)
a1 = A(name="a1", bs=[B(name="b1"), B(name="b2"), B(name="b3")])
def __init__(self, cores):
self.cores = cores
- mapper(Core, self.tables.core, legacy_is_orphan=legacy_is_orphan)
- mapper(
+ self.mapper_registry.map_imperatively(
+ Core, self.tables.core, legacy_is_orphan=legacy_is_orphan
+ )
+ self.mapper_registry.map_imperatively(
RelatedOne,
self.tables.related_one,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
RelatedTwo,
self.tables.related_two,
properties={
self.tables.child,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
parent,
properties={"child": relationship(Child, uselist=False)},
)
- mapper(Child, child)
+ self.mapper_registry.map_imperatively(Child, child)
self._do_move_test(True)
self._do_move_test(False)
self.tables.child,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
parent,
properties={"child": relationship(Child, uselist=True)},
)
- mapper(Child, child)
+ self.mapper_registry.map_imperatively(Child, child)
self._do_move_test(True)
self._do_move_test(False)
self.tables.child,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
parent,
properties={
)
},
)
- mapper(Child, child)
+ self.mapper_registry.map_imperatively(Child, child)
self._do_move_test(True)
self._do_move_test(False)
self.tables.child,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
parent,
properties={
)
},
)
- mapper(Child, child)
+ self.mapper_registry.map_imperatively(Child, child)
self._do_move_test(True)
self._do_move_test(False)
self.tables.child,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
parent,
properties={
)
},
)
- mapper(Child, child)
+ self.mapper_registry.map_imperatively(Child, child)
self._do_move_test(True)
self._do_move_test(False)
self.tables.child,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
parent,
properties={
)
},
)
- mapper(Child, child)
+ self.mapper_registry.map_imperatively(Child, child)
self._do_move_test(True)
self._do_move_test(False)
self.tables.child,
)
- mapper(Parent, parent)
- mapper(
+ self.mapper_registry.map_imperatively(Parent, parent)
+ self.mapper_registry.map_imperatively(
Child,
child,
properties={
self.tables.child,
)
- mapper(Parent, parent)
- mapper(
+ self.mapper_registry.map_imperatively(Parent, parent)
+ self.mapper_registry.map_imperatively(
Child,
child,
properties={
class Child(fixtures.ComparableEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Base,
base,
properties={"children": relationship(Child, backref="parent")},
)
- mapper(Child, noninh_child)
+ self.mapper_registry.map_imperatively(Child, noninh_child)
sess = fixture_session()
class Child(Base):
pass
- mapper(Base, base)
+ self.mapper_registry.map_imperatively(Base, base)
- mapper(
+ self.mapper_registry.map_imperatively(
Child,
inh_child,
inherits=Base,
},
)
- mapper(Parent, parent, inherits=Base)
+ self.mapper_registry.map_imperatively(Parent, parent, inherits=Base)
sess = fixture_session()
p1 = Parent()
self.tables.users,
)
- mapper(Order, orders)
- mapper(
+ self.mapper_registry.map_imperatively(Order, orders)
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
self.tables.users,
)
- mapper(Order, orders)
- mapper(
+ self.mapper_registry.map_imperatively(Order, orders)
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
self.tables.users,
)
- mapper(Order, orders)
- mapper(
+ self.mapper_registry.map_imperatively(Order, orders)
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
self.tables.users,
)
- mapper(Order, orders)
- umapper = mapper(
+ self.mapper_registry.map_imperatively(Order, orders)
+ umapper = self.mapper_registry.map_imperatively(
User,
users,
properties={
from sqlalchemy.orm import attributes
from sqlalchemy.orm import declarative_base
from sqlalchemy.orm import instrumentation
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
import sqlalchemy.orm.collections as collections
from sqlalchemy.orm.collections import collection
self.classes.Child,
)
- mapper(Child, children)
- mapper(
+ self.mapper_registry.map_imperatively(Child, children)
+ self.mapper_registry.map_imperatively(
Parent,
parents,
properties={
self.classes.Child,
)
- mapper(Child, children)
- mapper(
+ self.mapper_registry.map_imperatively(Child, children)
+ self.mapper_registry.map_imperatively(
Parent,
parents,
properties={
Foo = self.classes.Foo
Bar = self.classes.Bar
bar = self.tables["x.bar"]
- mapper(
+ self.mapper_registry.map_imperatively(
Foo, self.tables.foo, properties={"foo_id": self.tables.foo.c.id}
)
- mapper(Bar, bar, inherits=Foo, properties={"bar_id": bar.c.id})
+ self.mapper_registry.map_imperatively(
+ Bar, bar, inherits=Foo, properties={"bar_id": bar.c.id}
+ )
bar_spec = Bar(foo_id=1, bar_id=2, bat_id=3)
self._run_test(
s = select(self.tables.foo).alias()
Foo = self.classes.Foo
- mapper(Foo, s)
+ self.mapper_registry.map_imperatively(Foo, s)
self._run_test([(Foo.b, Foo(b=5), 5), (s.c.b, Foo(b=5), 5)])
def _run_test(self, specs):
class Bar(object):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
sometable,
properties={"bars": relationship(Bar, collection_class=MyList)},
)
- mapper(Bar, someothertable)
+ self.mapper_registry.map_imperatively(Bar, someothertable)
f = Foo()
assert isinstance(f.bars, MyList)
class Bar(object):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
sometable,
properties={"bars": relationship(Bar, collection_class=set)},
)
- mapper(Bar, someothertable)
+ self.mapper_registry.map_imperatively(Bar, someothertable)
f = Foo()
f.bars.add(Bar())
f.bars.add(Bar())
if id(item) in self:
del self[id(item)]
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
sometable,
properties={
"bars": relationship(Bar, collection_class=AppenderDict)
},
)
- mapper(Bar, someothertable)
+ self.mapper_registry.map_imperatively(Bar, someothertable)
f = Foo()
f.bars.set(Bar())
f.bars.set(Bar())
def __init__(self, data):
self.data = data
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
sometable,
properties={
)
},
)
- mapper(Bar, someothertable)
+ self.mapper_registry.map_imperatively(Bar, someothertable)
f = Foo()
col = collections.collection_adapter(f.bars)
class Child(object):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
sometable,
properties={
"children": relationship(Child, collection_class=listcls)
},
)
- mapper(Child, someothertable)
+ self.mapper_registry.map_imperatively(Child, someothertable)
control = list()
p = Parent()
def __iter__(self):
return iter(self.data)
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
sometable,
properties={
"children": relationship(Child, collection_class=MyCollection)
},
)
- mapper(Child, someothertable)
+ self.mapper_registry.map_imperatively(Child, someothertable)
control = list()
p1 = Parent()
from sqlalchemy.orm import backref
from sqlalchemy.orm import clear_mappers
from sqlalchemy.orm import configure_mappers
-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
-class CompileTest(fixtures.ORMTest):
+class CompileTest(fixtures.MappedTest):
"""test various mapper compilation scenarios"""
def teardown_test(self):
order_join = order.select().alias("pjoin")
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
order,
with_polymorphic=("*", order_join),
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Product,
product,
properties={
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Employee,
employee,
properties={
},
)
- mapper(OrderProduct, orderproduct)
+ self.mapper_registry.map_imperatively(OrderProduct, orderproduct)
# this requires that the compilation of order_mapper's "surrogate
# mapper" occur after the initial setup of MapperProperty objects on
order_join = order.select().alias("pjoin")
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
order,
with_polymorphic=("*", order_join),
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Product,
product,
properties={
},
)
- mapper(OrderProduct, orderproduct)
+ self.mapper_registry.map_imperatively(OrderProduct, orderproduct)
assert_raises_message(
sa_exc.ArgumentError, "Error creating backref", configure_mappers
class Host(object):
pass
- mapper(Node, node_table)
- mapper(Host, host_table)
- mapper(
+ self.mapper_registry.map_imperatively(Node, node_table)
+ self.mapper_registry.map_imperatively(Host, host_table)
+ self.mapper_registry.map_imperatively(
NodeName,
node_name_table,
properties={
class B(object):
pass
- mapper(A, a, properties={"b": relationship(B, backref="a")})
- mapper(B, b, properties={"a": relationship(A, backref="b")})
+ self.mapper_registry.map_imperatively(
+ A, a, properties={"b": relationship(B, backref="a")}
+ )
+ self.mapper_registry.map_imperatively(
+ B, b, properties={"a": relationship(A, backref="b")}
+ )
assert_raises_message(
sa_exc.ArgumentError, "Error creating backref", configure_mappers
class C(B):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
properties={
"c": relationship(C, backref="a"),
},
)
- mapper(B, b)
- mapper(C, None, inherits=B)
+ self.mapper_registry.map_imperatively(B, b)
+ self.mapper_registry.map_imperatively(C, None, inherits=B)
assert_raises_message(
sa_exc.ArgumentError, "Error creating backref", configure_mappers
from sqlalchemy.orm import composite
from sqlalchemy.orm import CompositeProperty
from sqlalchemy.orm import configure_mappers
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
from sqlalchemy.testing import assert_raises_message
if args:
self.start, self.end = args
- mapper(Graph, graphs, properties={"edges": relationship(Edge)})
- mapper(
+ cls.mapper_registry.map_imperatively(
+ Graph, graphs, properties={"edges": relationship(Edge)}
+ )
+ cls.mapper_registry.map_imperatively(
Edge,
edges,
properties={
self.ab = ab
stuff = self.tables.stuff
- mapper(
+ self.mapper_registry.map_imperatively(
Thing,
stuff,
properties={
def __init__(self, version):
self.version = version
- mapper(
+ cls.mapper_registry.map_imperatively(
Graph,
graphs,
properties={
self.x4,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Foobar,
foobars,
properties=dict(
.alias("descriptions_values")
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Descriptions,
descriptions,
properties={
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Values,
desc_values,
properties={
and other.b2 == self.b2
)
- mapper(
+ cls.mapper_registry.map_imperatively(
A,
a,
properties={"b2": relationship(B), "c": composite(C, "b1", "b2")},
)
- mapper(B, b)
+ cls.mapper_registry.map_imperatively(B, b)
def test_early_configure(self):
# test [ticket:2935], that we can call a composite
self.classes.Point,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Edge,
edge,
properties={
self.classes.Point,
)
- m = mapper(Edge, edge)
+ m = self.mapper_registry.map_imperatively(Edge, edge)
m.add_property("start", sa.orm.composite(Point, Edge.x1, Edge.y1))
m.add_property("end", sa.orm.composite(Point, Edge.x2, Edge.y2))
self.classes.Point,
)
- m = mapper(Edge, edge)
+ m = self.mapper_registry.map_imperatively(Edge, edge)
m.add_property("start", sa.orm.composite(Point, "x1", "y1"))
m.add_property("end", sa.orm.composite(Point, "x2", "y2"))
self.classes.Edge,
self.classes.Point,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Edge,
edge,
properties={
self.classes.Edge,
self.classes.Point,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Edge,
edge,
properties={
diff_y = clauses[1] - other.y
return diff_x * diff_x + diff_y * diff_y <= d * d
- mapper(
+ self.mapper_registry.map_imperatively(
Edge,
edge,
properties={
},
)
else:
- mapper(
+ self.mapper_registry.map_imperatively(
Edge,
edge,
properties={
from sqlalchemy.orm import deferred
from sqlalchemy.orm import join as orm_join
from sqlalchemy.orm import joinedload
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import query_expression
from sqlalchemy.orm import relationship
from sqlalchemy.orm import undefer
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, lazy="joined")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
return User, Address
User = self.classes.User
users = self.tables.users
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
User = self.classes.User
users = self.tables.users
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
addresses, Address = (self.tables.addresses, self.classes.Address)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=util.OrderedDict(
]
),
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
return User
)
addresses, Address = (self.tables.addresses, self.classes.Address)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=util.OrderedDict(
]
),
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
return User
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=util.OrderedDict(
),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
class Foo(object):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
self.tables.users,
properties={
from sqlalchemy import String
from sqlalchemy import testing
from sqlalchemy.orm import backref
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
def test_single(self):
C1, t1 = self.classes.C1, self.tables.t1
- mapper(
+ self.mapper_registry.map_imperatively(
C1,
t1,
properties={
C1, t1 = self.classes.C1, self.tables.t1
- mapper(
+ self.mapper_registry.map_imperatively(
C1,
t1,
properties={
self.tables.t1,
)
- mapper(
+ self.mapper_registry.map_imperatively(
C1,
t1,
properties={
"c1s": relationship(C1, cascade="all"),
"c2s": relationship(
- mapper(C2, t2), cascade="all, delete-orphan"
+ self.mapper_registry.map_imperatively(C2, t2),
+ cascade="all, delete-orphan",
),
},
)
def test_setnull_ondelete(self):
C1, t1 = self.classes.C1, self.tables.t1
- mapper(C1, t1, properties={"children": relationship(C1)})
+ self.mapper_registry.map_imperatively(
+ C1, t1, properties={"children": relationship(C1)}
+ )
sess = fixture_session()
c1 = C1()
def setup_mappers(cls):
item, TT = cls.tables.item, cls.classes.TT
- mapper(
+ cls.mapper_registry.map_imperatively(
TT,
item,
properties={
cls.classes.Child2,
)
- mapper(Parent, parent)
- mapper(Child1, child1, inherits=Parent)
- mapper(
+ cls.mapper_registry.map_imperatively(Parent, parent)
+ cls.mapper_registry.map_imperatively(Child1, child1, inherits=Parent)
+ cls.mapper_registry.map_imperatively(
Child2,
child2,
inherits=Parent,
self.classes.B,
)
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
properties={"cs": relationship(C, primaryjoin=a.c.cid == c.c.id)},
)
- mapper(B, b, inherits=A, inherit_condition=b.c.id == a.c.id)
+ self.mapper_registry.map_imperatively(
+ B, b, inherits=A, inherit_condition=b.c.id == a.c.id
+ )
- mapper(
+ self.mapper_registry.map_imperatively(
C,
c,
properties={
cls.classes.T1,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
T1,
t1,
properties={
"t2": relationship(T2, primaryjoin=t1.c.t2id == t2.c.id)
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
T2,
t2,
properties={
"t1": relationship(T1, primaryjoin=t2.c.t1id == t1.c.id)
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
T3, t3, properties={"t1": relationship(T1), "t2": relationship(T2)}
)
self.tables.t1,
)
- mapper(
+ self.mapper_registry.map_imperatively(
C2,
t2,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
C1,
t1,
properties={
cls.classes.C1,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
C2,
t2,
properties={
)
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
C1,
t1,
properties={
"c2s": relationship(
C2, primaryjoin=t1.c.c1 == t2.c.c2, uselist=True
),
- "data": relationship(mapper(C1Data, t1_data)),
+ "data": relationship(
+ cls.mapper_registry.map_imperatively(C1Data, t1_data)
+ ),
},
)
self.classes.Person,
)
- mapper(Ball, ball)
- mapper(
+ self.mapper_registry.map_imperatively(Ball, ball)
+ self.mapper_registry.map_imperatively(
Person,
person,
properties=dict(
self.classes.Person,
)
- mapper(Ball, ball)
- mapper(
+ self.mapper_registry.map_imperatively(Ball, ball)
+ self.mapper_registry.map_imperatively(
Person,
person,
properties=dict(
self.classes.Person,
)
- mapper(Ball, ball)
- mapper(
+ self.mapper_registry.map_imperatively(Ball, ball)
+ self.mapper_registry.map_imperatively(
Person,
person,
properties=dict(
self.classes.Person,
)
- mapper(Ball, ball)
- mapper(
+ self.mapper_registry.map_imperatively(Ball, ball)
+ self.mapper_registry.map_imperatively(
Person,
person,
properties=dict(
self.classes.Person,
)
- mapper(Ball, ball)
- mapper(
+ self.mapper_registry.map_imperatively(Ball, ball)
+ self.mapper_registry.map_imperatively(
Person,
person,
properties=dict(
self.classes.Person,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Ball,
ball,
properties={
)
},
)
- mapper(Person, person)
+ self.mapper_registry.map_imperatively(Person, person)
sess = fixture_session(autocommit=False, expire_on_commit=True)
p1 = Person()
node, Node = self.tables.node, self.classes.Node
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
node,
properties={
A, a_table = self.classes.A, self.tables.a_table
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a_table,
properties={
self.tables.child,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
parent,
properties={
),
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Child,
child,
properties={"parent": relationship(Child, remote_side=child.c.id)},
self.classes.Child3,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
parent,
properties={
),
},
)
- mapper(Child1, child1)
- mapper(Child2, child2)
- mapper(Child3, child3)
+ self.mapper_registry.map_imperatively(Child1, child1)
+ self.mapper_registry.map_imperatively(Child2, child2)
+ self.mapper_registry.map_imperatively(Child3, child3)
sess = fixture_session()
from sqlalchemy import testing
from sqlalchemy.orm import clear_mappers
from sqlalchemy.orm import declared_attr
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import registry as declarative_registry
from sqlalchemy.orm import registry
from sqlalchemy.orm import relationship
Widget = cls.classes.Widget
SpecialWidget = cls.classes.SpecialWidget
- mapper(
+ cls.mapper_registry.map_imperatively(
Widget,
widgets,
polymorphic_on=widgets.c.type,
polymorphic_identity="normal",
)
- mapper(
+ cls.mapper_registry.map_imperatively(
SpecialWidget,
widgets,
inherits=Widget,
polymorphic_identity="special",
)
- mapper(Account, accounts, properties={"widgets": relationship(Widget)})
+ cls.mapper_registry.map_imperatively(
+ Account, accounts, properties={"widgets": relationship(Widget)}
+ )
def check_account_dataclass(self, obj):
assert dataclasses.is_dataclass(obj)
import sqlalchemy as sa
from sqlalchemy import testing
from sqlalchemy import util
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import eq_
self.tables.addresses,
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
- mapper(Keyword, keywords)
+ self.mapper_registry.map_imperatively(Keyword, keywords)
- mapper(
+ self.mapper_registry.map_imperatively(
Item,
items,
properties=dict(
),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=dict(
),
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.tables.addresses,
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
- mapper(Keyword, keywords)
+ self.mapper_registry.map_imperatively(Keyword, keywords)
- mapper(
+ self.mapper_registry.map_imperatively(
Item,
items,
properties=dict(
),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=dict(
),
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.classes.User,
)
- m = mapper(
+ m = self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
addresses=relationship(
- mapper(Address, addresses), lazy="noload"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="noload",
)
),
)
self.classes.User,
)
- m = mapper(
+ m = self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
addresses=relationship(
- mapper(Address, addresses), lazy="noload"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="noload",
)
),
)
self.tables.users,
self.classes.User,
)
- mapper(Address, addresses, properties={"user": relationship(User)})
- mapper(User, users)
+ self.mapper_registry.map_imperatively(
+ Address, addresses, properties={"user": relationship(User)}
+ )
+ self.mapper_registry.map_imperatively(User, users)
s = fixture_session()
a1 = (
s.query(Address)
from sqlalchemy import Integer
from sqlalchemy import String
from sqlalchemy import testing
-from sqlalchemy.orm import mapper
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
from sqlalchemy.testing.assertsql import assert_engine
def setup_mappers(cls):
Default, dt = cls.classes.Default, cls.tables.dt
- mapper(Default, dt)
+ cls.mapper_registry.map_imperatively(Default, dt)
def test_insert(self):
Default = self.classes.Default
class Foo(fixtures.BasicEntity):
pass
- mapper(Foo, dt, exclude_properties=("col1",))
+ self.mapper_registry.map_imperatively(
+ Foo, dt, exclude_properties=("col1",)
+ )
f1 = Foo()
sess = fixture_session()
def setup_mappers(cls):
Thing = cls.classes.Thing
- mapper(Thing, cls.tables.test, eager_defaults=True)
+ cls.mapper_registry.map_imperatively(
+ Thing, cls.tables.test, eager_defaults=True
+ )
ThingNoEager = cls.classes.ThingNoEager
- mapper(ThingNoEager, cls.tables.test, eager_defaults=False)
+ cls.mapper_registry.map_imperatively(
+ ThingNoEager, cls.tables.test, eager_defaults=False
+ )
@testing.combinations(("eager", True), ("noneager", False), id_="ia")
def test_insert_computed(self, eager):
def setup_mappers(cls):
Thing = cls.classes.Thing
- mapper(Thing, cls.tables.test)
+ cls.mapper_registry.map_imperatively(Thing, cls.tables.test)
def test_insert_identity(self):
Thing = self.classes.Thing
from sqlalchemy.orm import joinedload
from sqlalchemy.orm import Load
from sqlalchemy.orm import load_only
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import query_expression
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
Order, orders = self.classes.Order, self.tables.orders
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={"description": deferred(orders.c.description)},
Order, orders = self.classes.Order, self.tables.orders
- mapper(Order, orders, properties={"id": deferred(orders.c.id)})
+ self.mapper_registry.map_imperatively(
+ Order, orders, properties={"id": deferred(orders.c.id)}
+ )
# right now, it's not that graceful :)
q = fixture_session().query(Order)
Order, orders = self.classes.Order, self.tables.orders
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={"description": deferred(orders.c.description)},
def test_synonym_group_bug(self):
orders, Order = self.tables.orders, self.classes.Order
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
def test_unsaved_2(self):
Order, orders = self.classes.Order, self.tables.orders
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={"description": deferred(orders.c.description)},
orders, Order = self.tables.orders, self.classes.Order
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=dict(
def test_unsaved_group_2(self):
orders, Order = self.tables.orders, self.classes.Order
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=dict(
def test_save(self):
Order, orders = self.classes.Order, self.tables.orders
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={"description": deferred(orders.c.description)},
orders, Order = self.tables.orders, self.classes.Order
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=util.OrderedDict(
orders, Order = self.tables.orders, self.classes.Order
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
orders, Order = self.tables.orders, self.classes.Order
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
orders.c.description,
orders.c.isopen,
).alias()
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
order_select,
properties={"description": deferred(order_select.c.description)},
orders, Order = self.tables.orders, self.classes.Order
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(Order, orders)
sess = fixture_session()
q = sess.query(Order).order_by(Order.id).options(defer("user_id"))
def test_undefer_group(self):
orders, Order = self.tables.orders, self.classes.Order
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=util.OrderedDict(
def test_undefer_group_multi(self):
orders, Order = self.tables.orders, self.classes.Order
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=util.OrderedDict(
def test_undefer_group_multi_pathed(self):
orders, Order = self.tables.orders, self.classes.Order
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=util.OrderedDict(
self.tables.orders,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(orders=relationship(Order, order_by=orders.c.id)),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=util.OrderedDict(
self.tables.orders,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(orders=relationship(Order, order_by=orders.c.id)),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=util.OrderedDict(
self.tables.orders,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(orders=relationship(Order, order_by=orders.c.id)),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=util.OrderedDict(
self.tables.orders,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(orders=relationship(Order, order_by=orders.c.id)),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=util.OrderedDict(
def test_undefer_star(self):
orders, Order = self.tables.orders, self.classes.Order
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=util.OrderedDict(
orders, Order = self.tables.orders, self.classes.Order
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={"description": deferred(orders.c.description)},
orders, Order = self.tables.orders, self.classes.Order
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={"description": deferred(orders.c.description)},
def test_raise_on_col_rowproc_only(self):
orders, Order = self.tables.orders, self.classes.Order
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
def test_locates_col_w_option_rowproc_only(self):
orders, Order = self.tables.orders, self.classes.Order
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(Order, orders)
sess = fixture_session()
stmt = sa.select(Order).order_by(Order.id)
def test_raise_on_col_w_option_rowproc_only(self):
orders, Order = self.tables.orders, self.classes.Order
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(Order, orders)
sess = fixture_session()
stmt = sa.select(Order).order_by(Order.id)
self.tables.orders,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Item,
items,
properties=dict(description=deferred(items.c.description)),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=dict(items=relationship(Item, secondary=order_items)),
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(orders=relationship(Order, order_by=orders.c.id)),
items = self.tables.items
order_items = self.tables.order_items
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"orders": relationship(Order, lazy="joined")},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
sess = fixture_session()
users, User = self.tables.users, self.classes.User
orders, Order = self.tables.orders, self.classes.Order
- mapper(User, users, properties={"orders": relationship(Order)})
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"orders": relationship(Order)}
+ )
+ self.mapper_registry.map_imperatively(Order, orders)
sess = fixture_session()
q = sess.query(User).options(
def test_load_only_no_pk(self):
orders, Order = self.tables.orders, self.classes.Order
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(Order, orders)
sess = fixture_session()
q = sess.query(Order).options(load_only("isopen", "description"))
def test_load_only_no_pk_rt(self):
orders, Order = self.tables.orders, self.classes.Order
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(Order, orders)
sess = fixture_session()
q = (
def test_load_only_w_deferred(self):
orders, Order = self.tables.orders, self.classes.Order
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={"description": deferred(orders.c.description)},
def test_load_only_synonym(self, type_):
orders, Order = self.tables.orders, self.classes.Order
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={"desc": synonym("description")},
users = self.tables.users
addresses = self.tables.addresses
- mapper(User, users, properties={"addresses": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
expected = [
addresses = self.tables.addresses
orders = self.tables.orders
- mapper(User, users)
- mapper(Address, addresses)
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(Order, orders)
sess = fixture_session()
q = sess.query(User, Order, Address).options(
addresses = self.tables.addresses
orders = self.tables.orders
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=util.OrderedDict(
),
)
- mapper(Address, addresses)
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(Order, orders)
sess = fixture_session()
class Thing(cls.Basic):
pass
- mapper(Human, human, properties={"thing": relationship(Thing)})
- mapper(Thing, thing, properties={"name": deferred(thing.c.name)})
+ cls.mapper_registry.map_imperatively(
+ Human, human, properties={"thing": relationship(Thing)}
+ )
+ cls.mapper_registry.map_imperatively(
+ Thing, thing, properties={"name": deferred(thing.c.name)}
+ )
@classmethod
def insert_data(cls, connection):
from sqlalchemy import testing
from sqlalchemy import text
from sqlalchemy import true
+from sqlalchemy import util
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 backref
+from sqlalchemy.orm import clear_mappers
from sqlalchemy.orm import collections
from sqlalchemy.orm import column_property
from sqlalchemy.orm import configure_mappers
def setup_mappers(cls):
Node, nodes = cls.classes.Node, cls.tables.nodes
- mapper(
+ cls.mapper_registry.map_imperatively(
Node,
nodes,
properties={
def append(self, node):
self.children.append(node)
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={
cls.tables.t1,
)
- mapper(T1, t1)
- mapper(T2, t2)
+ cls.mapper_registry.map_imperatively(T1, t1)
+ cls.mapper_registry.map_imperatively(T2, t2)
def test_close_transaction_on_commit_fail(self):
T2 = self.classes.T2
# non-standard comparator
return self.__clause_element__().op("&=")(other)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
name = property(_get_name, _set_name)
- m = mapper(User, users)
+ m = self.mapper_registry.map_imperatively(User, users)
m.add_property("_name", deferred(users.c.name))
m.add_property("name", synonym("_name"))
self.classes.Keyword,
self.classes.Item,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"orders": relationship(Order),
},
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
"items": relationship(Item, secondary=self.tables.order_items)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Keyword,
keywords,
properties={
"keywords": column_property(keywords.c.name + "some keyword")
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Item,
items,
properties=dict(
self.tables.addresses,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
openorders = sa.alias(orders, "openorders")
closedorders = sa.alias(orders, "closedorders")
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(Order, orders)
with testing.expect_deprecated(
"The mapper.non_primary parameter is deprecated"
):
- open_mapper = mapper(Order, openorders, non_primary=True)
- closed_mapper = mapper(Order, closedorders, non_primary=True)
- mapper(
+ open_mapper = self.mapper_registry.map_imperatively(
+ Order, openorders, non_primary=True
+ )
+ closed_mapper = self.mapper_registry.map_imperatively(
+ Order, closedorders, non_primary=True
+ )
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
openorders = sa.alias(orders, "openorders")
closedorders = sa.alias(orders, "closedorders")
- mapper(Address, addresses)
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(Order, orders)
with testing.expect_deprecated(
"The mapper.non_primary parameter is deprecated"
):
- open_mapper = mapper(Order, openorders, non_primary=True)
- closed_mapper = mapper(Order, closedorders, non_primary=True)
+ open_mapper = self.mapper_registry.map_imperatively(
+ Order, openorders, non_primary=True
+ )
+ closed_mapper = self.mapper_registry.map_imperatively(
+ Order, closedorders, non_primary=True
+ )
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
openorders = sa.alias(orders, "openorders")
closedorders = sa.alias(orders, "closedorders")
- mapper(Address, addresses)
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(Order, orders)
with testing.expect_deprecated(
"The mapper.non_primary parameter is deprecated"
):
- open_mapper = mapper(Order, openorders, non_primary=True)
- closed_mapper = mapper(Order, closedorders, non_primary=True)
+ open_mapper = self.mapper_registry.map_imperatively(
+ Order, openorders, non_primary=True
+ )
+ closed_mapper = self.mapper_registry.map_imperatively(
+ Order, closedorders, non_primary=True
+ )
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
openorders = sa.alias(orders, "openorders")
closedorders = sa.alias(orders, "closedorders")
- mapper(Address, addresses)
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(Order, orders)
with testing.expect_deprecated(
"The mapper.non_primary parameter is deprecated"
):
- open_mapper = mapper(Order, openorders, non_primary=True)
- closed_mapper = mapper(Order, closedorders, non_primary=True)
+ open_mapper = self.mapper_registry.map_imperatively(
+ Order, openorders, non_primary=True
+ )
+ closed_mapper = self.mapper_registry.map_imperatively(
+ Order, closedorders, non_primary=True
+ )
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
class NonPrimaryMapperTest(_fixtures.FixtureTest, AssertsCompiledSQL):
__dialect__ = "default"
+ def teardown_test(self):
+ clear_mappers()
+
def test_non_primary_identity_class(self):
User = self.classes.User
users, addresses = self.tables.users, self.tables.addresses
class AddressUser(User):
pass
- mapper(User, users, polymorphic_identity="user")
- m2 = mapper(
+ self.mapper_registry.map_imperatively(
+ User, users, polymorphic_identity="user"
+ )
+ m2 = self.mapper_registry.map_imperatively(
AddressUser,
addresses,
inherits=User,
with testing.expect_deprecated(
"The mapper.non_primary parameter is deprecated"
):
- m3 = mapper(AddressUser, addresses, non_primary=True)
+ m3 = self.mapper_registry.map_imperatively(
+ AddressUser, addresses, non_primary=True
+ )
assert m3._identity_class is m2._identity_class
eq_(
m2.identity_key_from_instance(AddressUser()),
self.classes.User,
)
- mapper(User, users)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(Address, addresses)
with testing.expect_deprecated(
"The mapper.non_primary parameter is deprecated"
):
- m = mapper( # noqa F841
+ m = self.mapper_registry.map_imperatively( # noqa F841
User,
users,
non_primary=True,
def test_illegal_non_primary_2(self):
User, users = self.classes.User, self.tables.users
+ assert_raises_message(
+ sa.exc.InvalidRequestError,
+ "Configure a primary mapper first",
+ self.mapper_registry.map_imperatively,
+ User,
+ users,
+ non_primary=True,
+ )
+
+ def test_illegal_non_primary_3(self):
+ users, addresses = self.tables.users, self.tables.addresses
+
+ class Base(object):
+ pass
+
+ class Sub(Base):
+ pass
+
+ self.mapper_registry.map_imperatively(Base, users)
+ assert_raises_message(
+ sa.exc.InvalidRequestError,
+ "Configure a primary mapper first",
+ self.mapper_registry.map_imperatively,
+ Sub,
+ addresses,
+ non_primary=True,
+ )
+
+ def test_illegal_non_primary_legacy(self):
+ users, Address, addresses, User = (
+ self.tables.users,
+ self.classes.Address,
+ self.tables.addresses,
+ self.classes.User,
+ )
+
+ with testing.expect_deprecated(
+ "Calling the mapper.* function directly outside of a declarative "
+ ):
+ mapper(User, users)
+ with testing.expect_deprecated(
+ "Calling the mapper.* function directly outside of a declarative "
+ ):
+ mapper(Address, addresses)
+ with testing.expect_deprecated(
+ "The mapper.non_primary parameter is deprecated"
+ ):
+ m = mapper( # noqa F841
+ User,
+ users,
+ non_primary=True,
+ properties={"addresses": relationship(Address)},
+ )
+ assert_raises_message(
+ sa.exc.ArgumentError,
+ "Attempting to assign a new relationship 'addresses' "
+ "to a non-primary mapper on class 'User'",
+ configure_mappers,
+ )
+
+ def test_illegal_non_primary_2_legacy(self):
+ User, users = self.classes.User, self.tables.users
+
with testing.expect_deprecated(
"The mapper.non_primary parameter is deprecated"
):
non_primary=True,
)
- def test_illegal_non_primary_3(self):
+ def test_illegal_non_primary_3_legacy(self):
users, addresses = self.tables.users, self.tables.addresses
class Base(object):
class Sub(Base):
pass
- mapper(Base, users)
with testing.expect_deprecated(
- "The mapper.non_primary parameter is deprecated"
+ "Calling the mapper.* function directly outside of a declarative "
+ ):
+ mapper(Base, users)
+ with testing.expect_deprecated(
+ "The mapper.non_primary parameter is deprecated",
):
assert_raises_message(
sa.exc.InvalidRequestError,
event.listen(sess, "after_bulk_update", legacy)
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
with testing.expect_deprecated(
'The argument signature for the "SessionEvents.after_bulk_update" '
event.listen(sess, "after_bulk_delete", legacy)
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
with testing.expect_deprecated(
'The argument signature for the "SessionEvents.after_bulk_delete" '
cls.classes.User,
)
- mapper(Address, addresses)
+ cls.mapper_registry.map_imperatively(Address, addresses)
- mapper(User, users, properties=dict(addresses=relationship(Address)))
+ cls.mapper_registry.map_imperatively(
+ User, users, properties=dict(addresses=relationship(Address))
+ )
def test_value(self):
User = self.classes.User
def setup_mappers(cls):
Node, nodes = cls.classes.Node, cls.tables.nodes
- mapper(
+ cls.mapper_registry.map_imperatively(
Node,
nodes,
properties={
@classmethod
def setup_classes(cls):
- table1, table2 = cls.tables.table1, cls.tables.table2
-
class T1(cls.Comparable):
pass
class T2(cls.Comparable):
pass
- mapper(T1, table1)
- mapper(T2, table2)
+ @classmethod
+ def setup_mappers(cls):
+ T1, T2 = cls.classes("T1", "T2")
+ table1, table2 = cls.tables.table1, cls.tables.table2
+ cls.mapper_registry.map_imperatively(T1, table1)
+ cls.mapper_registry.map_imperatively(T2, table2)
def test_mapped_to_select_implicit_left_w_aliased(self):
T1, T2 = self.classes.T1, self.classes.T2
class T2(object):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
T1,
t1,
properties={
"t2s_2": relationship(T2, secondary=t1t2_2),
},
)
- mapper(T2, t2)
+ self.mapper_registry.map_imperatively(T2, t2)
with testing.expect_deprecated_20(join_strings_dep):
q = (
)
-class BindSensitiveStringifyTest(fixtures.TestBase):
+class BindSensitiveStringifyTest(fixtures.MappedTest):
def _fixture(self):
# building a totally separate metadata /mapping here
# because we need to control if the MetaData is bound or not
Column("name", String(50)),
)
- mapper(User, user_table)
+ clear_mappers()
+ self.mapper_registry.map_imperatively(User, user_table)
return User
def _dialect_fixture(self):
.all(),
[],
)
+
+
+class RequirementsTest(fixtures.MappedTest):
+
+ """Tests the contract for user classes."""
+
+ @classmethod
+ def define_tables(cls, metadata):
+ Table(
+ "ht1",
+ metadata,
+ Column(
+ "id", Integer, primary_key=True, test_needs_autoincrement=True
+ ),
+ Column("value", String(10)),
+ )
+ Table(
+ "ht2",
+ metadata,
+ Column(
+ "id", Integer, primary_key=True, test_needs_autoincrement=True
+ ),
+ Column("ht1_id", Integer, ForeignKey("ht1.id")),
+ Column("value", String(10)),
+ )
+ Table(
+ "ht3",
+ metadata,
+ Column(
+ "id", Integer, primary_key=True, test_needs_autoincrement=True
+ ),
+ Column("value", String(10)),
+ )
+ Table(
+ "ht4",
+ metadata,
+ Column("ht1_id", Integer, ForeignKey("ht1.id"), primary_key=True),
+ Column("ht3_id", Integer, ForeignKey("ht3.id"), primary_key=True),
+ )
+ Table(
+ "ht5",
+ metadata,
+ Column("ht1_id", Integer, ForeignKey("ht1.id"), primary_key=True),
+ )
+ Table(
+ "ht6",
+ metadata,
+ Column("ht1a_id", Integer, ForeignKey("ht1.id"), primary_key=True),
+ Column("ht1b_id", Integer, ForeignKey("ht1.id"), primary_key=True),
+ Column("value", String(10)),
+ )
+
+ if util.py2k:
+
+ def test_baseclass_map_imperatively(self):
+ ht1 = self.tables.ht1
+
+ class OldStyle:
+ pass
+
+ assert_raises(
+ sa.exc.ArgumentError,
+ self.mapper_registry.map_imperatively,
+ OldStyle,
+ ht1,
+ )
+
+ assert_raises(
+ sa.exc.ArgumentError,
+ self.mapper_registry.map_imperatively,
+ 123,
+ )
+
+ def test_baseclass_legacy_mapper(self):
+ ht1 = self.tables.ht1
+
+ class OldStyle:
+ pass
+
+ assert_raises(
+ sa.exc.ArgumentError,
+ mapper,
+ OldStyle,
+ ht1,
+ )
+
+ assert_raises(
+ sa.exc.ArgumentError,
+ mapper,
+ 123,
+ )
+
+ class NoWeakrefSupport(str):
+ pass
+
+ # TODO: is weakref support detectable without an instance?
+ # self.assertRaises(
+ # sa.exc.ArgumentError, mapper, NoWeakrefSupport, t2)
from sqlalchemy.orm import backref
from sqlalchemy.orm import configure_mappers
from sqlalchemy.orm import exc as orm_exc
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import noload
from sqlalchemy.orm import Query
from sqlalchemy.orm import relationship
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
return User, Address
def _order_item_fixture(self, items_args={}):
self.classes.Item,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
return Order, Item
def _user_order_item_fixture(self):
self.tables.orders,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
),
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Item,
items,
properties={
) # m2m
},
)
- mapper(Keyword, keywords)
+ self.mapper_registry.map_imperatively(Keyword, keywords)
return User, Order, Item, Keyword
self.tables.addresses,
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={"user": relationship(User, lazy="dynamic")},
)
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
assert_raises_message(
exc.InvalidRequestError,
"On relationship Address.user, 'dynamic' loaders cannot be "
self.tables.addresses,
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
"user": relationship(User, uselist=True, lazy="dynamic")
},
)
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
assert_raises_message(
exc.SAWarning,
"On relationship Address.user, 'dynamic' loaders cannot be "
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
)
},
)
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
ad = sess.query(Address).get(1)
self.classes.Item,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
sess = fixture_session()
o = sess.query(Order).first()
self.classes.Item,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
sess = fixture_session()
u1 = sess.query(User).first()
class ItemKeyword(object):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
ItemKeyword,
item_keywords,
primary_key=[item_keywords.c.item_id, item_keywords.c.keyword_id],
)
- mapper(
+ self.mapper_registry.map_imperatively(
Item,
items,
properties={"item_keywords": relationship(ItemKeyword)},
def test_self_referential(self):
Node, nodes = self.classes.Node, self.tables.nodes
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={
from sqlalchemy.orm import lazyload
from sqlalchemy.orm import Load
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 undefer
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
lazy="joined",
order_by=Address.id,
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
lazy="joined",
order_by=Address.id,
)
self.tables.users,
)
- m = mapper(User, users)
+ m = self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
sess.query(User).all()
- m.add_property("addresses", relationship(mapper(Address, addresses)))
+ m.add_property(
+ "addresses",
+ relationship(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ ),
+ )
sess.expunge_all()
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
user = sess.query(User).get(7)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
lazy="joined",
order_by=addresses.c.email_address,
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
lazy="joined",
order_by=[addresses.c.email_address, addresses.c.id],
)
self.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.classes.User,
)
- mapper(Address, addresses)
- mapper(User, users, properties=dict(addresses=relationship(Address)))
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties=dict(addresses=relationship(Address))
+ )
sess = fixture_session()
q = (
self.tables.addresses,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
"user": relationship(User, lazy="joined"),
},
)
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
# trigger, etc.)
sa.orm.clear_mappers()
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={"user_id": deferred(addresses.c.user_id)},
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, lazy="joined")},
sa.orm.clear_mappers()
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
"dingalings": relationship(Dingaling, lazy="joined"),
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Dingaling,
dingalings,
properties={"address_id": deferred(dingalings.c.address_id)},
def test_aliased_stmt_includes_unnamed_fn(self):
User, Address = self.classes("User", "Address")
users, addresses = self.tables("users", "addresses")
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, lazy="joined")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
s = fixture_session()
User, Address = self.classes("User", "Address")
users, addresses = self.tables("users", "addresses")
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(Address, order_by=addresses.c.id)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
s = fixture_session()
self.tables.item_keywords,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"orders": relationship(Order, order_by=orders.c.id) # o2m, m2o
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
) # m2m
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Item,
items,
properties={
) # m2m
},
)
- mapper(Keyword, keywords)
+ self.mapper_registry.map_imperatively(Keyword, keywords)
for opt, count in [
((joinedload(User.orders, Order.items),), 10),
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, lazy="dynamic")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
assert_raises_message(
sa.exc.InvalidRequestError,
self.classes.Item,
)
- mapper(Keyword, keywords)
- mapper(
+ self.mapper_registry.map_imperatively(Keyword, keywords)
+ self.mapper_registry.map_imperatively(
Item,
items,
properties=dict(
self.classes.Item,
)
- mapper(Keyword, keywords)
- mapper(
+ self.mapper_registry.map_imperatively(Keyword, keywords)
+ self.mapper_registry.map_imperatively(
Item,
items,
properties=dict(
self.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.tables.order_items,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
open_mapper = aliased(Order, orders)
closed_mapper = aliased(Order, orders)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.tables.order_items,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
open_mapper = aliased(
Order, select(orders).where(orders.c.isopen == 1).alias()
Order, select(orders).where(orders.c.isopen == 0).alias()
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.tables.users,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(Item, items)
- mapper(
+ self.mapper_registry.map_imperatively(Item, items)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
elif type_ == "subquery":
target = select(users).subquery()
- mapper(
+ self.mapper_registry.map_imperatively(
User,
target,
properties={"addresses": relationship(Address, backref="user")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
self.tables.users,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"orders": relationship(Order, lazy="joined"),
},
)
- mapper(Address, addresses)
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(Order, orders)
self.allusers = fixture_session().query(User).all()
self.tables.addresses,
)
- mapper(Item, items)
- mapper(
+ self.mapper_registry.map_imperatively(Item, items)
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
lazy="joined",
order_by=addresses.c.id,
),
u2.select(),
).alias("u")
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
lazy="joined",
order_by=addresses.c.id,
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
lazy="joined",
order_by=addresses.c.email_address,
)
self.classes.Item,
)
- mapper(Keyword, keywords)
- mapper(
+ self.mapper_registry.map_imperatively(Keyword, keywords)
+ self.mapper_registry.map_imperatively(
Item,
items,
properties=dict(
self.tables.users,
)
- mapper(Item, items)
- mapper(
+ self.mapper_registry.map_imperatively(Item, items)
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=dict(
),
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
)
.alias("useralias")
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
sel,
properties={
)
},
)
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(Order, orders)
sess = fixture_session()
eq_(
self.classes.User,
)
- mapper(User, users)
- mapper(
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
self.classes.User,
)
- mapper(User, users)
- mapper(
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
self.tables.addresses,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=odict(orders=relationship(Order, backref="user")),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=odict(
]
),
)
- mapper(Address, addresses)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(Item, items)
sess = fixture_session()
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
address=relationship(
- mapper(Address, addresses), lazy="joined", uselist=False
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="joined",
+ uselist=False,
)
),
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
address=relationship(
- mapper(Address, addresses), lazy="joined", uselist=False
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="joined",
+ uselist=False,
)
),
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties=dict(
- user=relationship(mapper(User, users), lazy="joined")
+ user=relationship(
+ self.mapper_registry.map_imperatively(User, users),
+ lazy="joined",
+ )
),
)
sess = fixture_session()
# use a primaryjoin intended to defeat SA's usage of
# query.get() for a many-to-one lazyload
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=dict(
address=relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
primaryjoin=and_(
addresses.c.id == orders.c.address_id,
addresses.c.email_address != None, # noqa
self.classes.Order,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Item, items)
- mapper(
+ self.mapper_registry.map_imperatively(Item, items)
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=dict(
.alias("max_orders")
)
- mapper(Order, orders)
- mapper(
+ self.mapper_registry.map_imperatively(Order, orders)
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
self.classes.Order,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"order": relationship(Order, uselist=False)},
)
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(Order, orders)
s = fixture_session()
assert_raises(
sa.exc.SAWarning, s.query(User).options(joinedload(User.order)).all
self.tables.addresses,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(Item, items)
- mapper(
+ self.mapper_registry.map_imperatively(Item, items)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
addresses=relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
lazy=False,
order_by=addresses.c.id,
),
s = sa.select(orders).where(orders.c.isopen == 1).alias("openorders")
- mapper(
+ self.mapper_registry.map_imperatively(
Order, s, properties={"user": relationship(User, lazy="joined")}
)
- mapper(User, users)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(Item, items)
q = fixture_session().query(Order)
eq_(
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
addresses=relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
lazy="joined",
order_by=addresses.c.id,
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
addresses=relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
lazy="joined",
innerjoin=True,
order_by=addresses.c.id,
self.tables.orders,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
orders=relationship(Order, innerjoin="unnested", lazy=False)
),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=dict(
)
),
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
sess = fixture_session()
self.assert_compile(
self.tables.orders,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
)
),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=dict(
)
),
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
sess = fixture_session()
self.assert_compile(
self.tables.orders,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(orders=relationship(Order, order_by=orders.c.id)),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=dict(
)
),
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
sess = fixture_session()
q = sess.query(User).options(
Order, orders = self.classes.Order, self.tables.orders
Address, addresses = self.classes.Address, self.tables.addresses
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=odict(
]
),
)
- mapper(Order, orders)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Order, orders)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
q = sess.query(User).options(
Order, orders = self.classes.Order, self.tables.orders
Address, addresses = self.classes.Address, self.tables.addresses
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=odict(
]
),
)
- mapper(Order, orders)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Order, orders)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
q = sess.query(User).options(
self.tables.item_keywords,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"orders": relationship(Order, backref="user")
}, # o2m, m2o
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
) # m2m
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Item,
items,
properties={
) # m2m
},
)
- mapper(Keyword, keywords)
+ self.mapper_registry.map_imperatively(Keyword, keywords)
sess = fixture_session()
q = (
self.tables.orders,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(orders=relationship(Order, lazy=False)),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=dict(
)
),
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
sess = fixture_session()
self.tables.orders,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(orders=relationship(Order, lazy=False)),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=dict(
)
),
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
sess = fixture_session()
self.tables.orders,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
)
),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=dict(
)
),
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
sess = fixture_session()
self.assert_compile(
sess.query(User).options(joinedload(User.orders, innerjoin=True)),
self.tables.orders,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(orders=relationship(Order, lazy="select")),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=dict(
items=relationship(Item, secondary=order_items, lazy="joined")
),
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
sess = fixture_session()
cls.classes.D2,
cls.classes.E1,
)
- mapper(A, cls.tables.a, properties={"bs": relationship(B)})
- mapper(
+ cls.mapper_registry.map_imperatively(
+ A, cls.tables.a, properties={"bs": relationship(B)}
+ )
+ cls.mapper_registry.map_imperatively(
B,
cls.tables.b,
properties=odict(
]
),
)
- mapper(
+ cls.mapper_registry.map_imperatively(
C1,
cls.tables.c1,
properties={"d1s": relationship(D1, order_by=cls.tables.d1.c.id)},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
C2,
cls.tables.c2,
properties={"d2s": relationship(D2, order_by=cls.tables.d2.c.id)},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
D1,
cls.tables.d1,
properties={"e1s": relationship(E1, order_by=cls.tables.e1.c.id)},
)
- mapper(D2, cls.tables.d2)
- mapper(E1, cls.tables.e1)
+ cls.mapper_registry.map_imperatively(D2, cls.tables.d2)
+ cls.mapper_registry.map_imperatively(E1, cls.tables.e1)
@classmethod
def _fixture_data(cls):
cls.classes.C,
cls.classes.D,
)
- mapper(A, cls.tables.a, properties={"b": relationship(B)})
- mapper(B, cls.tables.b, properties=odict([("c", relationship(C))]))
- mapper(
+ cls.mapper_registry.map_imperatively(
+ A, cls.tables.a, properties={"b": relationship(B)}
+ )
+ cls.mapper_registry.map_imperatively(
+ B, cls.tables.b, properties=odict([("c", relationship(C))])
+ )
+ cls.mapper_registry.map_imperatively(
C,
cls.tables.c,
properties=odict(
]
),
)
- mapper(D, cls.tables.d)
+ cls.mapper_registry.map_imperatively(D, cls.tables.d)
@classmethod
def _fixture_data(cls):
def _fixture(self, props):
A, B = self.classes.A, self.classes.B
b_table, a_table = self.tables.b, self.tables.a
- mapper(A, a_table, properties=props)
- mapper(B, b_table, properties={"a": relationship(A, backref="bs")})
+ self.mapper_registry.map_imperatively(A, a_table, properties=props)
+ self.mapper_registry.map_imperatively(
+ B, b_table, properties={"a": relationship(A, backref="bs")}
+ )
def test_column_property(self):
A = self.classes.A
self.classes.Address,
self.classes.Dingaling,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
self.tables.users,
properties={"addresses": relationship(Address)},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
self.tables.addresses,
properties={"dingaling": relationship(Dingaling)},
)
- mapper(Dingaling, self.tables.dingalings)
+ self.mapper_registry.map_imperatively(
+ Dingaling, self.tables.dingalings
+ )
sess = fixture_session(autoflush=False)
return User, Address, Dingaling, sess
self.classes.Order,
self.classes.Item,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User, self.tables.users, properties={"orders": relationship(Order)}
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
self.tables.orders,
properties={
"items": relationship(Item, secondary=self.tables.order_items)
},
)
- mapper(Item, self.tables.items)
+ self.mapper_registry.map_imperatively(Item, self.tables.items)
sess = fixture_session(autoflush=False)
return User, Order, Item, sess
def _eager_config_fixture(self):
User, Address = self.classes.User, self.classes.Address
- mapper(
+ self.mapper_registry.map_imperatively(
User,
self.tables.users,
properties={"addresses": relationship(Address, lazy="joined")},
)
- mapper(Address, self.tables.addresses)
+ self.mapper_registry.map_imperatively(Address, self.tables.addresses)
sess = fixture_session(autoflush=False)
return User, Address, sess
)
def test_refresh_no_recursion(self, strat):
User, Address = self.classes.User, self.classes.Address
- mapper(
+ self.mapper_registry.map_imperatively(
User,
self.tables.users,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
self.tables.addresses,
properties={
self.tables.addresses,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"orders": relationship(Order),
},
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
sess = fixture_session()
oalias = sa.orm.aliased(Order)
self.tables.addresses,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"orders": relationship(Order),
},
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
sess = fixture_session()
class B(fixtures.ComparableEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
properties={
)
},
)
- mapper(B, b)
+ self.mapper_registry.map_imperatively(B, b)
sess = fixture_session()
eq_(
def append(self, node):
self.children.append(node)
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={
def append(self, node):
self.children.append(node)
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={
def append(self, node):
self.children.append(node)
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={
def append(self, node):
self.children.append(node)
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={
def append(self, node):
self.children.append(node)
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={"children": relationship(Node, lazy="joined")},
class B(cls.Comparable):
pass
- mapper(A, a_table)
- mapper(
+ cls.mapper_registry.map_imperatively(A, a_table)
+ cls.mapper_registry.map_imperatively(
B,
b_table,
properties={
class Widget(fixtures.ComparableEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Widget,
widget,
properties={
cls.tables.addresses,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
User,
users,
properties={
"orders": relationship(Order, backref="user"), # o2m, m2o
},
)
- mapper(Address, addresses)
- mapper(
+ cls.mapper_registry.map_imperatively(Address, addresses)
+ cls.mapper_registry.map_imperatively(
Order,
orders,
properties={
) # m2m
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Item,
items,
properties={
) # m2m
},
)
- mapper(Keyword, keywords)
+ cls.mapper_registry.map_imperatively(Keyword, keywords)
def test_two_entities(self):
Item, Order, User, Address = (
else:
user_score = user_score.scalar_subquery()
- mapper(
+ self.mapper_registry.map_imperatively(
Tag,
tags_table,
properties={"query_score": sa.orm.column_property(tag_score)},
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users_table,
properties={
class Stuff(fixtures.ComparableEntity):
pass
- mapper(Stuff, stuff)
+ self.mapper_registry.map_imperatively(Stuff, stuff)
if aliasstuff:
salias = stuff.alias()
else:
stuff_view = stuff_view.scalar_subquery()
if ondate:
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
},
)
else:
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
class SubT2(T2):
pass
- mapper(T, t1, polymorphic_on=t1.c.type, polymorphic_identity="t1")
- mapper(
+ self.mapper_registry.map_imperatively(
+ T, t1, polymorphic_on=t1.c.type, polymorphic_identity="t1"
+ )
+ self.mapper_registry.map_imperatively(
SubT,
None,
inherits=T,
)
},
)
- mapper(T2, t2, polymorphic_on=t2.c.type, polymorphic_identity="t2")
- mapper(SubT2, None, inherits=T2, polymorphic_identity="subt2")
+ self.mapper_registry.map_imperatively(
+ T2, t2, polymorphic_on=t2.c.type, polymorphic_identity="t2"
+ )
+ self.mapper_registry.map_imperatively(
+ SubT2, None, inherits=T2, polymorphic_identity="subt2"
+ )
# testing a particular endless loop condition in eager load setup
fixture_session().query(SubT).all()
cls.tables.orders,
)
- mapper(Keyword, keywords)
+ cls.mapper_registry.map_imperatively(Keyword, keywords)
- mapper(
+ cls.mapper_registry.map_imperatively(
Item,
items,
properties=dict(
),
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Order,
orders,
properties=dict(
),
)
- mapper(
+ cls.mapper_registry.map_imperatively(
User,
users,
properties=dict(orders=relationship(Order, order_by=orders.c.id)),
class Related(cls.Comparable):
pass
- mapper(
+ cls.mapper_registry.map_imperatively(
Base,
base,
polymorphic_on=base.c.type,
properties={"related": relationship(Related, uselist=False)},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Child1,
child1,
inherits=Base,
)
},
)
- mapper(Child2, child2, inherits=Base, polymorphic_identity="child2")
- mapper(Related, related)
+ cls.mapper_registry.map_imperatively(
+ Child2, child2, inherits=Base, polymorphic_identity="child2"
+ )
+ cls.mapper_registry.map_imperatively(Related, related)
@classmethod
def insert_data(cls, connection):
from sqlalchemy import tuple_
from sqlalchemy.orm import evaluator
from sqlalchemy.orm import exc as orm_exc
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import assert_raises
from sqlalchemy.testing import assert_raises_message
def setup_mappers(cls):
users, User = cls.tables.users, cls.classes.User
- mapper(User, users)
+ cls.mapper_registry.map_imperatively(User, users)
def test_compare_to_value(self):
User = self.classes.User
class B(A):
pass
- mapper(A, users)
- mapper(
+ self.mapper_registry.map_imperatively(A, users)
+ self.mapper_registry.map_imperatively(
B, addresses, inherits=A, properties={"address_id": addresses.c.id}
)
def test_init_allow_kw_modify(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
@event.listens_for(User, "init")
def add_name(obj, args, kwargs):
if kw.get("fail"):
raise Exception("failure")
- mapper(Thing, users)
+ self.mapper_registry.map_imperatively(Thing, users)
canary = Mock()
event.listen(Thing, "init_failure", canary)
def test_listen_doesnt_force_compile(self):
User, users = self.classes.User, self.tables.users
- m = mapper(
+ m = self.mapper_registry.map_imperatively(
User,
users,
properties={
def test_basic(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
canary = self.listen_all(User)
named_canary = self.listen_all(User, named=True)
def test_insert_before_configured(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
canary = Mock()
def test_insert_flags(self):
users, User = self.tables.users, self.classes.User
- m = mapper(User, users)
+ m = self.mapper_registry.map_imperatively(User, users)
canary = Mock()
def test_merge(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
canary = []
class AdminUser(User):
pass
- mapper(User, users)
- mapper(
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
AdminUser,
addresses,
inherits=User,
self.classes.User,
)
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
canary1 = self.listen_all(User, propagate=True)
canary2 = self.listen_all(User)
class AdminUser(User):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
AdminUser,
addresses,
inherits=User,
self.classes.Item,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Item,
items,
properties={
"keywords": relationship(Keyword, secondary=item_keywords)
},
)
- mapper(Keyword, keywords)
+ self.mapper_registry.map_imperatively(Keyword, keywords)
canary1 = self.listen_all(Item)
canary2 = self.listen_all(Keyword)
m1 = Mock()
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
assert_raises_message(
sa.exc.SAWarning,
r"before_configured' and 'after_configured' ORM events only "
m1 = Mock()
m2 = Mock()
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
event.listen(mapper, "before_configured", m1)
event.listen(mapper, "after_configured", m2)
event.listen(Mapper, "instrument_class", instrument_class)
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
eq_(canary, [User])
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
eq_(canary, [User, Address])
def test_instrument_class_precedes_class_instrumentation(self):
def class_instrument(class_):
canary.class_instrument(class_)
- mapper(MyClass, users)
+ self.mapper_registry.map_imperatively(MyClass, users)
- mapper(MySubClass, inherits=MyClass)
+ self.mapper_registry.map_imperatively(MySubClass, inherits=MyClass)
m1 = MyClass()
assert attributes.instance_state(m1)
"""
User, users = self.classes.User, self.tables.users
- ump = mapper(User, users)
+ ump = self.mapper_registry.map_imperatively(User, users)
AnotherBase = declarative_base()
event.listen(User, "before_insert", evt, raw=True)
- m = mapper(User, users)
+ m = self.mapper_registry.map_imperatively(User, users)
m.dispatch.before_insert(5, 6, 7)
eq_(canary, [5])
event.listen(User, "before_insert", canary, propagate=True, raw=True)
- m = mapper(SubUser, users)
+ m = self.mapper_registry.map_imperatively(SubUser, users)
m.dispatch.before_insert(5, 6, 7)
eq_(canary.mock_calls, [call(5, 6, 7)])
- m2 = mapper(SubSubUser, users)
+ m2 = self.mapper_registry.map_imperatively(SubSubUser, users)
m2.dispatch.before_insert(8, 9, 10)
eq_(canary.mock_calls, [call(5, 6, 7), call(8, 9, 10)])
event.listen(User, "before_insert", evt, propagate=False)
- m = mapper(SubUser, users)
+ m = self.mapper_registry.map_imperatively(SubUser, users)
m.dispatch.before_insert(5, 6, 7)
eq_(canary, [])
class SubUser(User):
pass
- m = mapper(SubUser, users)
+ m = self.mapper_registry.map_imperatively(SubUser, users)
canary = []
class SubSubUser(SubUser):
pass
- m = mapper(SubUser, users)
+ m = self.mapper_registry.map_imperatively(SubUser, users)
canary = Mock()
event.listen(User, "before_insert", canary, propagate=True, raw=True)
- m2 = mapper(SubSubUser, users)
+ m2 = self.mapper_registry.map_imperatively(SubSubUser, users)
m.dispatch.before_insert(5, 6, 7)
eq_(canary.mock_calls, [call(5, 6, 7)])
class SubUser(User):
pass
- m = mapper(SubUser, users)
+ m = self.mapper_registry.map_imperatively(SubUser, users)
canary = []
event.listen(User, "load", evt, raw=True)
- m = mapper(User, users)
+ m = self.mapper_registry.map_imperatively(User, users)
m.class_manager.dispatch.load(5)
eq_(canary, [5])
event.listen(User, "load", evt, propagate=True, raw=True)
- m = mapper(SubUser, users)
- m2 = mapper(SubUser2, users)
+ m = self.mapper_registry.map_imperatively(SubUser, users)
+ m2 = self.mapper_registry.map_imperatively(SubUser2, users)
m.class_manager.dispatch.load(5)
eq_(canary, [5])
event.listen(User, "load", canary, propagate=True, raw=False)
# reversing these fixes....
- m = mapper(SubUser, users)
- m2 = mapper(User, users)
+ m = self.mapper_registry.map_imperatively(SubUser, users)
+ m2 = self.mapper_registry.map_imperatively(User, users)
instance = Mock()
m.class_manager.dispatch.load(instance)
m2.class_manager.dispatch.load(instance)
eq_(canary.mock_calls, [call(instance.obj()), call(instance.obj())])
- m3 = mapper(SubUser2, users)
+ m3 = self.mapper_registry.map_imperatively(SubUser2, users)
m3.class_manager.dispatch.load(instance)
eq_(
canary.mock_calls,
event.listen(User, "load", evt, propagate=False)
- m = mapper(SubUser, users)
+ m = self.mapper_registry.map_imperatively(SubUser, users)
m.class_manager.dispatch.load(5)
eq_(canary, [])
event.listen(User, "attribute_instrument", evt, propagate=False)
- mapper(SubUser, users)
+ self.mapper_registry.map_imperatively(SubUser, users)
instrumentation._instrumentation_factory.dispatch.attribute_instrument(
5
)
def setup_mappers(cls):
User, users = cls.classes.User, cls.tables.users
- mapper(User, users)
+ cls.mapper_registry.map_imperatively(User, users)
def _fixture(self):
User = self.classes.User
class AdminUser(User):
pass
- mapper(User, users)
- mapper(
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
AdminUser,
addresses,
inherits=User,
class User(Foo):
pass
- m = mapper(User, users)
+ m = self.mapper_registry.map_imperatively(User, users)
u1 = User()
m.dispatch.before_insert(m, None, attributes.instance_state(u1))
class Bar(Foo):
pass
- m = mapper(Bar, users)
+ m = self.mapper_registry.map_imperatively(Bar, users)
b1 = Bar()
m.dispatch.before_insert(m, None, attributes.instance_state(b1))
eq_(fn.call_count, 1)
pass
event.listen(User, "load", fn)
- m = mapper(User, users)
+ m = self.mapper_registry.map_imperatively(User, users)
u1 = User()
m.class_manager.dispatch.load(u1._sa_instance_state, "u1")
def setup_mappers(cls):
User, users = cls.classes.User, cls.tables.users
- mapper(User, users)
+ cls.mapper_registry.map_imperatively(User, users)
def _fixture(self):
User = self.classes.User
def test_flush_autocommit_hook(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess, canary = self._listener_fixture(
autoflush=False, autocommit=True, expire_on_commit=False
def test_rollback_hook(self):
User, users = self.classes.User, self.tables.users
sess, canary = self._listener_fixture()
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
u = User(name="u1", id=1)
sess.add(u)
def test_can_use_session_in_outer_rollback_hook(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
sess, canary = self._listener_fixture()
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
u = User(name="u1")
sess.add(u)
sess, canary = self._listener_fixture()
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
u = User(name="u1")
sess.add(u)
sess.flush()
else:
assert inst not in session.new
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
u = User(name="u1")
sess.add(u)
sess.flush()
else:
assert inst in session.new
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
u = User(name="u1")
sess.add(u)
sess.flush()
event.listen(sess, "after_begin", canary.after_begin)
event.listen(sess, "after_bulk_update", canary.after_bulk_update)
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess.query(User).update({"name": "foo"})
event.listen(sess, "after_begin", canary.after_begin)
event.listen(sess, "after_bulk_delete", canary.after_bulk_delete)
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess.query(User).delete()
def test_reentrant_flush(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
def before_flush(session, flush_context, objects):
session.flush()
def test_before_flush_affects_flush_plan(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
def before_flush(session, flush_context, objects):
for obj in list(session.new) + list(session.dirty):
def test_before_flush_affects_dirty(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
def before_flush(session, flush_context, objects):
for obj in list(session.identity_map.values()):
def test_snapshot_still_present_after_commit(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
def test_snapshot_still_present_after_rollback(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
if include_address:
addresses, Address = self.tables.addresses, self.classes.Address
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
else:
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
listener = Mock()
User = cls.classes.User
users = cls.tables.users
- mapper(User, users)
+ cls.mapper_registry.map_imperatively(User, users)
def test_before_compile(self):
@event.listens_for(query.Query, "before_compile", retval=True)
def setup_mappers(cls):
Thing = cls.classes.Thing
- mapper(Thing, cls.tables.test, eager_defaults=True)
+ cls.mapper_registry.map_imperatively(
+ Thing, cls.tables.test, eager_defaults=True
+ )
def test_no_attr_events_flush(self):
Thing = self.classes.Thing
from sqlalchemy.orm import joinedload
from sqlalchemy.orm import lazyload
from sqlalchemy.orm import make_transient_to_detached
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
from sqlalchemy.orm import strategies
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session(autoflush=False)
u = sess.query(User).get(7)
User, users = self.classes.User, self.tables.users
Address, addresses = self.classes.Address, self.tables.addresses
- mapper(User, users)
- mapper(Address, addresses, properties={"user": relationship(User)})
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
+ Address, addresses, properties={"user": relationship(User)}
+ )
s = fixture_session()
def test_persistence_check(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s = fixture_session()
u = s.query(User).get(7)
s.expunge_all()
def test_get_refreshes(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s = fixture_session(autocommit=False)
u = s.query(User).get(10)
s.expire_all()
def test_get_on_deleted_expunges(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s = fixture_session(autocommit=False)
u = s.query(User).get(10)
def test_refresh_on_deleted_raises(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s = fixture_session(autocommit=False)
u = s.query(User).get(10)
s.expire_all()
def test_rollback_undoes_expunge_from_deleted(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s = fixture_session(autocommit=False)
u = s.query(User).get(10)
s.expire_all()
Order, orders = self.classes.Order, self.tables.orders
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={"description": deferred(orders.c.description)},
def test_deferred_notfound(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users, properties={"name": deferred(users.c.name)})
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"name": deferred(users.c.name)}
+ )
s = fixture_session(autocommit=False)
u = s.query(User).get(10)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
s = fixture_session(autoflush=True, autocommit=False)
u = s.query(User).get(8)
adlist = u.addresses
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
s = fixture_session(autoflush=True, autocommit=False)
u = s.query(User).get(8)
assert_raises_message(
def test_refresh_cancels_expire(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s = fixture_session()
u = s.query(User).get(7)
s.expire(u)
def test_expire_doesntload_on_set(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session(autoflush=False)
u = sess.query(User).get(7)
def test_no_session(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u = sess.query(User).get(7)
# 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)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u = User(id=15)
sess.add(u)
# an instance is pending, but has expired attributes. this
# 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)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session(autoflush=False)
u = sess.query(User).get(7)
# same as test_no_instance_key, but the PK columns
# are absent. ensure an error is raised.
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u = sess.query(User).get(7)
Order, orders = self.classes.Order, self.tables.orders
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(Order, orders)
sess = fixture_session(autoflush=False)
o = sess.query(Order).get(3)
sess.expire(o)
orders, Order = self.tables.orders, self.classes.Order
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(Order, orders)
sess = fixture_session(autoflush=False)
o = sess.query(Order).get(3)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
s = fixture_session(autoflush=False)
u = s.query(User).get(8)
assert u.addresses[0].email_address == "ed@wood.com"
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
s = fixture_session(autoflush=False)
u = s.query(User).get(8)
assert u.addresses[0].email_address == "ed@wood.com"
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, cascade=cascade)},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
s = fixture_session(autoflush=False)
u = s.query(User).get(8)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
u = sess.query(User).get(7)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
u = sess.query(User).get(7)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session(autoflush=False)
u = sess.query(User).get(7)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"orders": relationship(Order, order_by=orders.c.id)},
)
- mapper(Address, addresses, properties={"user": relationship(User)})
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(
+ Address, addresses, properties={"user": relationship(User)}
+ )
+ self.mapper_registry.map_imperatively(Order, orders)
sess = fixture_session(autoflush=False)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session(autoflush=False)
u = sess.query(User).get(8)
sess.expire(u, ["name", "addresses"])
# changed in #1763, eager loaders are run when we unexpire
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
u = sess.query(User).get(8)
sess.expire(u)
# changed in #1763, eager loaders are run when we unexpire
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
u = sess.query(User).options(joinedload(User.addresses)).get(8)
sess.expire(u)
self.tables.addresses,
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
u = sess.query(User).get(8)
sess.expire(u)
def test_expire_synonym(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users, properties={"uname": sa.orm.synonym("name")})
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"uname": sa.orm.synonym("name")}
+ )
sess = fixture_session()
u = sess.query(User).get(7)
def test_partial_expire(self):
orders, Order = self.tables.orders, self.classes.Order
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(Order, orders)
sess = fixture_session(autoflush=False)
o = sess.query(Order).get(3)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session(autoflush=False)
u = sess.query(User).get(8)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session(autoflush=False)
u = sess.query(User).get(8)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session(autoflush=False)
u = sess.query(User).get(8)
def test_partial_expire_deferred(self):
orders, Order = self.tables.orders, self.classes.Order
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={"description": sa.orm.deferred(orders.c.description)},
sa.orm.clear_mappers()
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(Order, orders)
sess.expunge_all()
# same tests, using deferred at the options level
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session(autoflush=False)
u = sess.query(User).get(8)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session(autoflush=False)
userlist = sess.query(User).order_by(User.id).all()
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session(autoflush=False)
users, User = self.tables.users, self.classes.User
- mapper(User, users, properties={"name": deferred(users.c.name)})
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"name": deferred(users.c.name)}
+ )
sess = fixture_session(autoflush=False)
u1 = sess.query(User).options(undefer(User.name)).first()
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, lazy="noload")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session(autoflush=False)
u1 = sess.query(User).options(lazyload(User.addresses)).first()
def test_deferred_expire_w_transient_to_detached(self):
orders, Order = self.tables.orders, self.classes.Order
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={"description": deferred(orders.c.description)},
def test_deferred_expire_normally(self):
orders, Order = self.tables.orders, self.classes.Order
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={"description": deferred(orders.c.description)},
def test_deferred_expire_explicit_attrs(self):
orders, Order = self.tables.orders, self.classes.Order
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={"description": deferred(orders.c.description)},
cls.classes.Engineer,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Person,
people,
polymorphic_on=people.c.type,
polymorphic_identity="person",
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Engineer,
engineers,
inherits=Person,
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session(autoflush=False)
a1 = Address(email_address="a1")
@classmethod
def setup_mappers(cls):
- mapper(cls.classes.Data, cls.tables.data)
- mapper(cls.classes.DataFetched, cls.tables.data_fetched)
- mapper(
+ cls.mapper_registry.map_imperatively(cls.classes.Data, cls.tables.data)
+ cls.mapper_registry.map_imperatively(
+ cls.classes.DataFetched, cls.tables.data_fetched
+ )
+ cls.mapper_registry.map_imperatively(
cls.classes.DataDefer,
cls.tables.data_defer,
properties={"data": deferred(cls.tables.data_defer.c.data)},
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses), backref="user"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ backref="user",
)
},
)
def test_persistence_check(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s = fixture_session()
u = s.query(User).get(7)
s.expunge_all()
User, users = self.classes.User, self.tables.users
Address, addresses = self.classes.Address, self.tables.addresses
- mapper(User, users)
- mapper(Address, addresses, properties={"user": relationship(User)})
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
+ Address, addresses, properties={"user": relationship(User)}
+ )
s = fixture_session()
def test_refresh_expired(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s = fixture_session()
u = s.query(User).get(7)
s.expire(u)
)
s = fixture_session()
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
- properties={"addresses": relationship(mapper(Address, addresses))},
+ properties={
+ "addresses": relationship(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ )
+ },
)
q = s.query(User).options(sa.orm.lazyload("addresses"))
u = q.filter(users.c.id == 8).first()
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses), lazy="joined"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="joined",
)
},
)
"users", "addresses", "dingalings"
)
- mapper(User, users, properties={"addresses": relationship(Address)})
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={"dingalings": relationship(Dingaling)},
)
- mapper(Dingaling, dingalings)
+ self.mapper_registry.map_imperatively(Dingaling, dingalings)
s = fixture_session()
q = (
)
s = fixture_session()
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
from sqlalchemy.orm import contains_eager
from sqlalchemy.orm import declarative_base
from sqlalchemy.orm import joinedload
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
from sqlalchemy.orm.context import ORMSelectCompileState
cls.tables.addresses,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
User,
users,
properties={
), # o2m, m2o
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Address,
addresses,
properties={
) # o2o
},
)
- mapper(Dingaling, dingalings)
- mapper(
+ cls.mapper_registry.map_imperatively(Dingaling, dingalings)
+ cls.mapper_registry.map_imperatively(
Order,
orders,
properties={
"address": relationship(Address), # m2o
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Item,
items,
properties={
"keywords": relationship(Keyword, secondary=item_keywords)
},
) # m2m
- mapper(Keyword, keywords)
+ cls.mapper_registry.map_imperatively(Keyword, keywords)
- mapper(
+ cls.mapper_registry.map_imperatively(
Node,
nodes,
properties={
},
)
- mapper(CompositePk, composite_pk_table)
+ cls.mapper_registry.map_imperatively(CompositePk, composite_pk_table)
configure_mappers()
@classmethod
def setup_classes(cls):
- a, c, b, d = (cls.tables.a, cls.tables.c, cls.tables.b, cls.tables.d)
-
class A(cls.Comparable):
pass
class D(A):
pass
- mapper(
+ @classmethod
+ def setup_mappers(cls):
+ a, c, b, d = (cls.tables.a, cls.tables.c, cls.tables.b, cls.tables.d)
+ A, B, C, D = cls.classes("A", "B", "C", "D")
+
+ cls.mapper_registry.map_imperatively(
A,
a,
polymorphic_identity="a",
"link": relationship(B, uselist=False, backref="back")
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
B,
b,
polymorphic_identity="b",
polymorphic_on=b.c.type,
with_polymorphic=("*", None),
)
- mapper(C, c, inherits=B, polymorphic_identity="c")
- mapper(D, d, inherits=A, polymorphic_identity="d")
+ cls.mapper_registry.map_imperatively(
+ C, c, inherits=B, polymorphic_identity="c"
+ )
+ cls.mapper_registry.map_imperatively(
+ D, d, inherits=A, polymorphic_identity="d"
+ )
@classmethod
def insert_data(cls, connection):
self.classes.User,
)
- mapper(User, users, properties={"addresses": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
sel = users.select().where(users.c.id.in_([7, 8])).alias()
sess = fixture_session()
def test_select_from_aliased_one(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
def test_select_from_aliased_two(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
def test_select_from_core_alias_one(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
def test_aliased_class_vs_nonaliased(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
ua = aliased(User)
def test_join_no_order_by(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sel = users.select().where(users.c.id.in_([7, 8]))
sess = fixture_session()
def test_join_relname_from_selected_from(self):
User, Address = self.classes.User, self.classes.Address
users, addresses = self.tables.users, self.tables.addresses
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses), backref="user"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ backref="user",
)
},
)
def test_filter_by_selected_from(self):
User, Address = self.classes.User, self.classes.Address
users, addresses = self.tables.users, self.tables.addresses
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
- properties={"addresses": relationship(mapper(Address, addresses))},
+ properties={
+ "addresses": relationship(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ )
+ },
)
sess = fixture_session()
def test_join_ent_selected_from(self):
User, Address = self.classes.User, self.classes.Address
users, addresses = self.tables.users, self.tables.addresses
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
- properties={"addresses": relationship(mapper(Address, addresses))},
+ properties={
+ "addresses": relationship(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ )
+ },
)
sess = fixture_session()
self.classes.User,
)
- mapper(User, users, properties={"addresses": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
sel = users.select().where(users.c.id.in_([7, 8]))
sess = fixture_session()
self.tables.item_keywords,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"orders": relationship(Order, backref="user")},
) # o2m, m2o
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
},
) # m2m
- mapper(
+ self.mapper_registry.map_imperatively(
Item,
items,
properties={
)
},
) # m2m
- mapper(Keyword, keywords)
+ self.mapper_registry.map_imperatively(Keyword, keywords)
sess = fixture_session()
sel = users.select().where(users.c.id.in_([7, 8]))
self.tables.item_keywords,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"orders": relationship(Order, backref="user")},
) # o2m, m2o
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
) # m2m
- mapper(
+ self.mapper_registry.map_imperatively(
Item,
items,
properties={
)
},
) # m2m
- mapper(Keyword, keywords)
+ self.mapper_registry.map_imperatively(Keyword, keywords)
sess = fixture_session()
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(Address, order_by=addresses.c.id)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sel = users.select().where(users.c.id.in_([7, 8]))
sess = fixture_session()
self.tables.users,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(Item, items)
- mapper(
+ self.mapper_registry.map_imperatively(Item, items)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.tables.users,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(Item, items)
- mapper(
+ self.mapper_registry.map_imperatively(Item, items)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
assert_raises_message(
sa_exc.ArgumentError,
"not represented in the mapper's table",
- mapper,
+ self.mapper_registry.map_imperatively,
User,
users,
properties={"concat": (users.c.id * 2)},
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
# subquery, but "user" still needs to be adapted. therefore the long
# standing practice of eager adapters being "chained" has been removed
# since its unnecessary and breaks this exact condition.
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
),
},
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
Order, orders, properties={"address": relationship(Address)}
) # m2o
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"fullname": column_property(users.c.name.label("x"))},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
class Sub2(fixtures.ComparableEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Base,
base,
properties={
},
)
- mapper(Sub1, sub1)
- mapper(Sub2, sub2)
+ self.mapper_registry.map_imperatively(Sub1, sub1)
+ self.mapper_registry.map_imperatively(Sub2, sub2)
sess = fixture_session()
s11 = Sub1(data="s11")
@classmethod
def setup_mappers(cls):
- mapper(cls.classes.Foo, cls.tables.foo)
- mapper(cls.classes.Bar, cls.tables.foo_bar)
+ cls.mapper_registry.map_imperatively(cls.classes.Foo, cls.tables.foo)
+ cls.mapper_registry.map_imperatively(
+ cls.classes.Bar, cls.tables.foo_bar
+ )
@classmethod
def insert_data(cls, connection):
from sqlalchemy import func
from sqlalchemy import Integer
from sqlalchemy import testing
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
class Foo(cls.Basic):
pass
- mapper(Foo, foo)
+ cls.mapper_registry.map_imperatively(Foo, foo)
def test_selectby(self):
Foo = self.classes.Foo
class Obj2(cls.Basic):
pass
- mapper(Obj1, table1)
- mapper(Obj2, table2)
+ cls.mapper_registry.map_imperatively(Obj1, table1)
+ cls.mapper_registry.map_imperatively(Obj2, table2)
@classmethod
def fixtures(cls):
cls.tables.users,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
User,
users,
properties={
"orders": relationship(
- mapper(
+ cls.mapper_registry.map_imperatively(
Order,
orders,
properties={
"addresses": relationship(
- mapper(Address, addresses)
+ cls.mapper_registry.map_imperatively(
+ Address, addresses
+ )
)
},
)
class Obj2(cls.Basic):
pass
- mapper(Obj1, Table1)
- mapper(Obj2, Table2)
+ cls.mapper_registry.map_imperatively(Obj1, Table1)
+ cls.mapper_registry.map_imperatively(Obj2, Table2)
@classmethod
def fixtures(cls):
from sqlalchemy import testing
from sqlalchemy.orm import attributes
from sqlalchemy.orm import exc as orm_exc
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import eq_
@classmethod
def setup_mappers(cls):
- mapper(cls.classes.Address, cls.tables.addresses)
- mapper(
+ cls.mapper_registry.map_imperatively(
+ cls.classes.Address, cls.tables.addresses
+ )
+ cls.mapper_registry.map_imperatively(
cls.classes.User,
cls.tables.users,
properties={
from sqlalchemy import testing
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
self.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, lazy=default_lazy)},
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={"user": relationship(User, lazy=default_lazy)},
)
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
result = (
self.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, lazy="immediate")},
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
assert not insp.is_aliased_class
def test_mapper_selectable_fixed(self):
- from sqlalchemy.orm import mapper
-
class Foo(object):
pass
user_table = self.tables.users
addresses_table = self.tables.addresses
- mapper(Foo, user_table, with_polymorphic=(Bar,))
- mapper(
+ self.mapper_registry.map_imperatively(
+ Foo, user_table, with_polymorphic=(Bar,)
+ )
+ self.mapper_registry.map_imperatively(
Bar,
addresses_table,
inherits=Foo,
HYBRID_METHOD,
)
from sqlalchemy import Table, MetaData, Integer, Column
- from sqlalchemy.orm import mapper
from sqlalchemy.orm.interfaces import NOT_EXTENSION
class SomeClass(self.classes.User):
Column("id", Integer, primary_key=True),
Column("s_id", ForeignKey("sometable.id")),
)
- mapper(SomeClass, t, properties={"addresses": relationship(Address)})
- mapper(Address, ta)
- mapper(SomeSubClass, inherits=SomeClass)
+ self.mapper_registry.map_imperatively(
+ SomeClass, t, properties={"addresses": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, ta)
+ self.mapper_registry.map_imperatively(SomeSubClass, inherits=SomeClass)
insp = inspect(SomeSubClass)
eq_(
__foo__ = "bar"
__bat__ = Thing()
- from sqlalchemy.orm import mapper, column_property
+ from sqlalchemy.orm import column_property
from sqlalchemy.ext.hybrid import hybrid_property
- m = mapper(AnonClass, self.tables.users)
+ m = self.mapper_registry.map_imperatively(AnonClass, self.tables.users)
eq_(set(inspect(AnonClass).attrs.keys()), set(["id", "name"]))
eq_(
class MyClass(object):
pass
- from sqlalchemy.orm import mapper
from sqlalchemy import Table, MetaData, Column, Integer
names = self._random_names()
*[Column(name, Integer) for name in names]
)
- m = mapper(MyClass, t)
+ m = self.mapper_registry.map_imperatively(MyClass, t)
eq_(m.all_orm_descriptors.keys(), ["id"] + names)
from sqlalchemy.orm import class_mapper
from sqlalchemy.orm import clear_mappers
from sqlalchemy.orm import instrumentation
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import assert_raises
from sqlalchemy.testing import assert_raises_message
assert o.o is Y.outofscope
-class MapperInitTest(fixtures.ORMTest):
+class MapperInitTest(fixtures.MappedTest):
def fixture(self):
return Table(
"t",
def __init__(self, x):
pass
- mapper(A, self.fixture())
+ self.mapper_registry.map_imperatively(A, self.fixture())
# B is not mapped in the current implementation
assert_raises(sa.orm.exc.UnmappedClassError, class_mapper, B)
r"unreachable cycles and memory leaks, as SQLAlchemy "
r"instrumentation often creates reference cycles. "
r"Please remove this method.",
- mapper,
+ self.mapper_registry.map_imperatively,
A,
self.fixture(),
)
del A
-class NativeInstrumentationTest(fixtures.ORMTest):
+class NativeInstrumentationTest(fixtures.MappedTest):
def test_register_reserved_attribute(self):
class T(object):
pass
class T(object):
pass
- assert_raises(KeyError, mapper, T, t)
+ assert_raises(KeyError, self.mapper_registry.map_imperatively, T, t)
def test_mapped_managerattr(self):
t = Table(
class T(object):
pass
- assert_raises(KeyError, mapper, T, t)
+ assert_raises(KeyError, self.mapper_registry.map_imperatively, T, t)
class Py3KFunctionInstTest(fixtures.ORMTest):
setattr(Py3KFunctionInstTest, k, _locals[k])
-class MiscTest(fixtures.ORMTest):
+class MiscTest(fixtures.MappedTest):
"""Seems basic, but not directly covered elsewhere!"""
def test_compileonattr(self):
class A(object):
pass
- mapper(A, t)
+ self.mapper_registry.map_imperatively(A, t)
a = A()
assert a.id is None
class B(object):
pass
- mapper(A, t1, properties=dict(bs=relationship(B)))
- mapper(B, t2)
+ self.mapper_registry.map_imperatively(
+ A, t1, properties=dict(bs=relationship(B))
+ )
+ self.mapper_registry.map_imperatively(B, t2)
a = A()
assert not a.bs
class B(base):
pass
- mapper(A, t1, properties=dict(bs=relationship(B, backref="a")))
- mapper(B, t2)
+ self.mapper_registry.map_imperatively(
+ A, t1, properties=dict(bs=relationship(B, backref="a"))
+ )
+ self.mapper_registry.map_imperatively(B, t2)
b = B()
assert b.a is None
class B(base):
pass
- mapper(A, t1)
- mapper(B, t2, properties=dict(a=relationship(A, backref="bs")))
+ self.mapper_registry.map_imperatively(A, t1)
+ self.mapper_registry.map_imperatively(
+ B, t2, properties=dict(a=relationship(A, backref="bs"))
+ )
a = A()
b = B()
from sqlalchemy.orm import backref
from sqlalchemy.orm import join
from sqlalchemy.orm import joinedload
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import outerjoin
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
User = cls.classes.User
Address = cls.classes.Address
users, addresses = (cls.tables.users, cls.tables.addresses)
- mapper(
+ cls.mapper_registry.map_imperatively(
User,
users,
properties={
"ad_syn": synonym("addresses"),
},
)
- mapper(Address, addresses)
+ cls.mapper_registry.map_imperatively(Address, addresses)
def test_join_on_synonym(self):
User = self.classes.User
@classmethod
def setup_classes(cls):
- table1, table2 = cls.tables.table1, cls.tables.table2
-
class T1(cls.Comparable):
pass
class T2(cls.Comparable):
pass
- mapper(T1, table1)
- mapper(T2, table2)
+ @classmethod
+ def setup_mappers(cls):
+ table1, table2 = cls.tables.table1, cls.tables.table2
+ T1, T2 = cls.classes("T1", "T2")
+ cls.mapper_registry.map_imperatively(T1, table1)
+ cls.mapper_registry.map_imperatively(T2, table2)
def test_select_mapped_to_mapped_explicit_left(self):
T1, T2 = self.classes.T1, self.classes.T2
@classmethod
def setup_classes(cls):
+ class Node(cls.Comparable):
+ pass
+
+ class Sub(cls.Comparable):
+ pass
+
+ @classmethod
+ def setup_mappers(cls):
nodes, assoc_table, sub_table = (
cls.tables.nodes,
cls.tables.assoc_table,
cls.tables.sub_table,
)
- class Node(cls.Comparable):
- pass
-
- class Sub(cls.Comparable):
- pass
+ Node, Sub = cls.classes("Node", "Sub")
- mapper(
+ cls.mapper_registry.map_imperatively(
Node,
nodes,
properties={
),
},
)
- mapper(Sub, sub_table)
+ cls.mapper_registry.map_imperatively(Sub, sub_table)
def test_o2m_aliased_plus_o2m(self):
Node, Sub = self.classes.Node, self.classes.Sub
)
-class CreateJoinsTest(fixtures.ORMTest, AssertsCompiledSQL):
+class CreateJoinsTest(fixtures.MappedTest, AssertsCompiledSQL):
__dialect__ = "default"
def _inherits_fixture(self):
class C(Base):
pass
- mapper(Base, base)
- mapper(
+ self.mapper_registry.map_imperatively(Base, base)
+ self.mapper_registry.map_imperatively(
A,
a,
inherits=Base,
properties={"b": relationship(B, primaryjoin=a.c.b_id == b.c.id)},
)
- mapper(
+ self.mapper_registry.map_imperatively(
B,
b,
inherits=Base,
properties={"c": relationship(C, primaryjoin=b.c.c_id == c.c.id)},
)
- mapper(C, c, inherits=Base)
+ self.mapper_registry.map_imperatively(C, c, inherits=Base)
return A, B, C, Base
def test_double_level_aliased_exists(self):
class Child(cls.Comparable):
pass
- mp = mapper(Parent, parent)
- mapper(Child, child)
+ mp = cls.mapper_registry.map_imperatively(Parent, parent)
+ cls.mapper_registry.map_imperatively(Child, child)
derived = select(child).alias()
npc = aliased(Child, derived)
def setup_mappers(cls):
Node, nodes = cls.classes.Node, cls.tables.nodes
- mapper(
+ cls.mapper_registry.map_imperatively(
Node,
nodes,
properties={
cls.tables.node_to_nodes,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Node,
nodes,
properties={
@classmethod
def setup_classes(cls):
- people, bookcases, books = cls.tables("people", "bookcases", "books")
-
class Person(cls.Comparable):
pass
class Book(cls.Comparable):
pass
- mapper(Person, people)
- mapper(
+ @classmethod
+ def setup_mappers(cls):
+ Person, Bookcase, Book = cls.classes("Person", "Bookcase", "Book")
+ people, bookcases, books = cls.tables("people", "bookcases", "books")
+ cls.mapper_registry.map_imperatively(Person, people)
+ cls.mapper_registry.map_imperatively(
Bookcase,
bookcases,
properties={
"books": relationship(Book),
},
)
- mapper(Book, books)
+ cls.mapper_registry.map_imperatively(Book, books)
def test_select_subquery(self):
Person, Book = self.classes("Person", "Book")
from sqlalchemy import update
from sqlalchemy.future import select
from sqlalchemy.orm import aliased
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import selectinload
from sqlalchemy.orm import Session
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
Address = cls.classes.Address
addresses = cls.tables.addresses
- mapper(
+ cls.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(Address),
},
)
- mapper(Address, addresses)
+ cls.mapper_registry.map_imperatively(Address, addresses)
def test_update(self):
User, Address = self.classes("User", "Address")
from sqlalchemy.orm import attributes
from sqlalchemy.orm import configure_mappers
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
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses), lazy="select"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="select",
)
},
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses), lazy="select"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="select",
)
},
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
lazy="select",
order_by=addresses.c.email_address,
)
self.classes.User,
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(addresses=relationship(Address, lazy="select")),
self.classes.User,
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
user = sess.query(User).get(7)
self.tables.addresses,
)
- mapper(Item, items)
- mapper(
+ self.mapper_registry.map_imperatively(Item, items)
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses), lazy="select"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="select",
),
"orders": relationship(Order, lazy="select"),
},
self.tables.addresses,
)
- mapper(Item, items)
- mapper(
+ self.mapper_registry.map_imperatively(Item, items)
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses), lazy="select"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="select",
),
"orders": relationship(Order, lazy="select"),
},
self.classes.Order,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"order": relationship(Order, uselist=False)},
)
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(Order, orders)
s = fixture_session()
u1 = s.query(User).filter(User.id == 7).one()
assert_raises(sa.exc.SAWarning, getattr, u1, "order")
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
addresses=relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
lazy="select",
primaryjoin=and_(
users.c.id == addresses.c.user_id,
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
address=relationship(
- mapper(Address, addresses), lazy="select", uselist=False
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="select",
+ uselist=False,
)
),
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
primary_key=[addresses.c.user_id, addresses.c.email_address],
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.tables.order_items,
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
open_mapper = aliased(
Order, select(orders).where(orders.c.isopen == 1).alias()
Order, select(orders).where(orders.c.isopen == 0).alias()
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.tables.order_items,
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
open_mapper = aliased(Order, orders)
closed_mapper = aliased(Order, orders)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
elif type_ == "subquery":
target = select(users).subquery()
- mapper(
+ self.mapper_registry.map_imperatively(
User,
target,
properties={"addresses": relationship(Address, backref="user")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
self.classes.Item,
)
- mapper(Keyword, keywords)
- mapper(
+ self.mapper_registry.map_imperatively(Keyword, keywords)
+ self.mapper_registry.map_imperatively(
Item,
items,
properties=dict(
users.c.id == addresses.c.user_id,
addresses.c.user_id == users.c.id,
):
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties=dict(
user=relationship(
- mapper(User, users), lazy="select", primaryjoin=pj
+ self.mapper_registry.map_imperatively(User, users),
+ lazy="select",
+ primaryjoin=pj,
)
),
)
self.tables.users,
self.classes.User,
)
- um = mapper(User, users)
- am = mapper(
+ um = self.mapper_registry.map_imperatively(User, users)
+ am = self.mapper_registry.map_imperatively(
Address, addresses, properties={"user": relationship(User)}
)
Column("email_address", String(50), nullable=False),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
- properties=dict(user=relationship(mapper(User, users))),
+ properties=dict(
+ user=relationship(
+ self.mapper_registry.map_imperatively(User, users)
+ )
+ ),
)
with fixture_session() as sess:
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties=dict(
- user=relationship(mapper(User, users), lazy="select")
+ user=relationship(
+ self.mapper_registry.map_imperatively(User, users),
+ lazy="select",
+ )
),
)
sess = fixture_session()
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session(autoflush=False)
ad = sess.query(Address).filter_by(id=1).one()
assert ad.user.id == 7
class Article(fixtures.ComparableEntity):
pass
- mapper(Category, category)
- mapper(
+ self.mapper_registry.map_imperatively(Category, category)
+ self.mapper_registry.map_imperatively(
Article,
article,
properties={
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(Address, back_populates="user")
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
self.classes.User,
)
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
- mapper(Address, addresses, properties={"user": relationship(User)})
+ self.mapper_registry.map_imperatively(
+ Address, addresses, properties={"user": relationship(User)}
+ )
sess = fixture_session()
ad1 = Address(email_address="somenewaddress", id=12)
class Stuff(fixtures.ComparableEntity):
pass
- mapper(Stuff, stuff)
+ self.mapper_registry.map_imperatively(Stuff, stuff)
stuff_view = (
sa.select(stuff.c.id)
.limit(1)
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
user_t,
properties={
Person, City = cls.classes.Person, cls.classes.City
city, person = cls.tables.city, cls.tables.person
- mapper(
+ cls.mapper_registry.map_imperatively(
Person,
person,
properties={
)
},
)
- mapper(City, city)
+ cls.mapper_registry.map_imperatively(City, city)
def _fixture(self, include_other):
city, person = self.tables.city, self.tables.person
@classmethod
def setup_mappers(cls):
- mapper(
+ cls.mapper_registry.map_imperatively(
cls.classes.A,
cls.tables.a,
properties={"b": relationship(cls.classes.B)},
)
- bm = mapper(
+ bm = cls.mapper_registry.map_imperatively(
cls.classes.B,
cls.tables.b,
properties={
"zc": relationship(cls.classes.C),
},
)
- mapper(cls.classes.C, cls.tables.c)
+ cls.mapper_registry.map_imperatively(cls.classes.C, cls.tables.c)
bmp = bm._props
configure_mappers()
@classmethod
def setup_mappers(cls):
- mapper(
+ cls.mapper_registry.map_imperatively(
cls.classes.Person,
cls.tables.person,
properties=dict(
),
)
- mapper(cls.classes.Pet, cls.tables.pets)
+ cls.mapper_registry.map_imperatively(cls.classes.Pet, cls.tables.pets)
def test_lazyload_singlecast(self):
Person = self.classes.Person
pass
def test_use_get_sameorder(self):
- mapper(self.classes.A, self.tables.a)
- m_b = mapper(
+ self.mapper_registry.map_imperatively(self.classes.A, self.tables.a)
+ m_b = self.mapper_registry.map_imperatively(
self.classes.B,
self.tables.b_sameorder,
properties={"a": relationship(self.classes.A)},
is_true(m_b.relationships.a.strategy.use_get)
def test_use_get_reverseorder(self):
- mapper(self.classes.A, self.tables.a)
- m_b = mapper(
+ self.mapper_registry.map_imperatively(self.classes.A, self.tables.a)
+ m_b = self.mapper_registry.map_imperatively(
self.classes.B,
self.tables.b_differentorder,
properties={"a": relationship(self.classes.A)},
is_true(m_b.relationships.a.strategy.use_get)
def test_dont_use_get_pj_is_different(self):
- mapper(self.classes.A, self.tables.a)
- m_b = mapper(
+ self.mapper_registry.map_imperatively(self.classes.A, self.tables.a)
+ m_b = self.mapper_registry.map_imperatively(
self.classes.B,
self.tables.b_sameorder,
properties={
from sqlalchemy.engine import result_tuple
from sqlalchemy.orm import aliased
from sqlalchemy.orm import loading
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import mock
from sqlalchemy.testing.assertions import assert_raises
User, Order, Address = self.classes("User", "Order", "Address")
users, orders, addresses = self.tables("users", "orders", "addresses")
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
),
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={"address": relationship(Address, lazy="joined")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
s = fixture_session()
from sqlalchemy import testing
from sqlalchemy.engine import default
from sqlalchemy.orm import joinedload
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import AssertsCompiledSQL
@classmethod
def setup_mappers(cls):
User, users = cls.classes.User, cls.tables.users
- mapper(User, users)
+ cls.mapper_registry.map_imperatively(User, users)
def _assert(
self,
def setup_mappers(cls):
User, users = cls.classes.User, cls.tables.users
Address, addresses = cls.classes.Address, cls.tables.addresses
- mapper(User, users, properties={"addresses": relationship(Address)})
- mapper(Address, addresses)
+ cls.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
+ cls.mapper_registry.map_imperatively(Address, addresses)
def test_inner_joinedload_w_limit(self):
User = self.classes.User
def setup_mappers(cls):
User, users = cls.classes.User, cls.tables.users
Address, addresses = cls.classes.Address, cls.tables.addresses
- mapper(User, users, properties={"addresses": relationship(Address)})
- mapper(Address, addresses)
+ cls.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
+ cls.mapper_registry.map_imperatively(Address, addresses)
def test_default_update(self):
User = self.classes.User
from sqlalchemy import testing
from sqlalchemy.orm import backref
from sqlalchemy.orm import exc as orm_exc
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import eq_
self.tables.transition,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Place,
place,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Transition,
transition,
properties={
self.tables.place_place,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Place,
place,
properties={
self.tables.place_place,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Place,
place,
properties={
self.tables.place_output,
)
- mapper(PlaceThingy, place_thingy)
- mapper(
+ self.mapper_registry.map_imperatively(PlaceThingy, place_thingy)
+ self.mapper_registry.map_imperatively(
Place,
place,
properties={"thingies": relationship(PlaceThingy, lazy="joined")},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Transition,
transition,
properties=dict(
self.tables.place_output,
)
- mapper(Place, place)
- mapper(
+ self.mapper_registry.map_imperatively(Place, place)
+ self.mapper_registry.map_imperatively(
Transition,
transition,
properties=dict(
self.tables.transition,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Place,
place,
properties={
)
},
)
- mapper(Transition, transition)
+ self.mapper_registry.map_imperatively(Transition, transition)
p1 = Place("place1")
t1 = Transition("t1")
self.tables.right,
)
A, B = self.classes.A, self.classes.B
- mapper(
+ self.mapper_registry.map_imperatively(
A,
left,
properties={
)
},
)
- mapper(B, right)
+ self.mapper_registry.map_imperatively(B, right)
def _bidirectional_onescalar_fixture(self):
left, secondary, right = (
self.tables.right,
)
A, B = self.classes.A, self.classes.B
- mapper(
+ self.mapper_registry.map_imperatively(
A,
left,
properties={
)
},
)
- mapper(B, right)
+ self.mapper_registry.map_imperatively(B, right)
def test_session_delete(self):
self._standard_bidirectional_fixture()
from sqlalchemy.orm import dynamic_loader
from sqlalchemy.orm import Load
from sqlalchemy.orm import load_only
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import reconstructor
from sqlalchemy.orm import registry
from sqlalchemy.orm import relationship
User, users = self.classes.User, self.tables.users
s = sa.select(users.c.name).alias("foo")
- assert_raises(sa.exc.ArgumentError, mapper, User, s)
+ assert_raises(
+ sa.exc.ArgumentError,
+ self.mapper_registry.map_imperatively,
+ User,
+ s,
+ )
def test_no_pks_2(self):
User, users = self.classes.User, self.tables.users
s = sa.select(users.c.name).alias()
- assert_raises(sa.exc.ArgumentError, mapper, User, s)
+ assert_raises(
+ sa.exc.ArgumentError,
+ self.mapper_registry.map_imperatively,
+ User,
+ s,
+ )
def test_reconfigure_on_other_mapper(self):
"""A configure trigger on an already-configured mapper
assert_raises_message(
sa.exc.ArgumentError,
"not represented in the mapper's table",
- mapper,
+ self.mapper_registry.map_imperatively,
User,
users,
properties={"foo": addresses.c.user_id},
assert_raises_message(
sa.exc.SAWarning,
"Reassigning polymorphic association for identity 'user'",
- mapper,
+ self.mapper_registry.map_imperatively,
MyUser,
users,
inherits=User,
assert_raises_message(
sa.exc.InvalidRequestError,
"Implicitly",
- mapper,
+ self.mapper_registry.map_imperatively,
User,
usersaddresses,
primary_key=[users.c.id],
assert_raises(
sa.exc.ArgumentError,
- mapper,
+ self.mapper_registry.map_imperatively,
User,
users,
properties=util.OrderedDict(
),
)
+ clear_mappers()
assert_raises(
sa.exc.ArgumentError,
- mapper,
+ self.mapper_registry.map_imperatively,
User,
users,
properties=util.OrderedDict(
Column("value", String(10)),
)
- if util.py2k:
-
- def test_baseclass(self):
- ht1 = self.tables.ht1
-
- class OldStyle:
- pass
-
- assert_raises(sa.exc.ArgumentError, mapper, OldStyle, ht1)
-
- assert_raises(sa.exc.ArgumentError, mapper, 123)
-
- class NoWeakrefSupport(str):
- pass
-
- # TODO: is weakref support detectable without an instance?
- # self.assertRaises(
- # sa.exc.ArgumentError, mapper, NoWeakrefSupport, t2)
-
class _ValueBase(object):
def __init__(self, value="abc", id_=None):
self.id = id_
class T(object):
pass
+ clear_mappers()
assert_raises_message(
KeyError,
(
"%r: requested attribute name conflicts with "
"instrumentation attribute of the same name." % reserved
),
- mapper,
+ self.mapper_registry.map_imperatively,
T,
t,
)
class M(object):
pass
+ clear_mappers()
assert_raises_message(
KeyError,
(
"requested attribute name conflicts with "
"instrumentation attribute of the same name"
),
- mapper,
+ self.mapper_registry.map_imperatively,
M,
maps,
properties={reserved: maps.c.state},
users = self.tables.users
- um = mapper(User, users)
+ um = self.mapper_registry.map_imperatively(User, users)
if use_bound:
stmt = select(User).options(
User, Address = self.classes("User", "Address")
users, addresses = self.tables("users", "addresses")
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
)
- am = mapper(Address, addresses)
+ am = self.mapper_registry.map_imperatively(Address, addresses)
if use_legacy_query:
s = 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 selectinload
from sqlalchemy.orm import Session
self.tables.users,
)
- mapper(
+ self.mapper(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
)
- mapper(Address, addresses)
+ self.mapper(Address, addresses)
s = fixture_session()
u = User(
def test_transient_to_pending(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
load = self.load_tracker(User)
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u = User(name="fred")
def test_warn_transient_already_pending_nopk(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session(autoflush=False)
u = User(name="fred")
def test_warn_transient_already_pending_pk(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session(autoflush=False)
u = User(id=1, name="fred")
self.tables.users,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
load = self.load_tracker(User)
self.load_tracker(Address, load)
self.tables.users,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
s = fixture_session()
u = User(
self.tables.users,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
load = self.load_tracker(User)
self.load_tracker(Address, load)
def test_transient_to_persistent(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
load = self.load_tracker(User)
sess = fixture_session()
self.tables.users,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
load = self.load_tracker(User)
self.load_tracker(Address, load)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
load = self.load_tracker(User)
self.load_tracker(Address, load)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses), cascade="all", backref="user"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ cascade="all",
+ backref="user",
)
},
)
def test_merge_empty_attributes(self):
User, dingalings = self.classes.User, self.tables.dingalings
- mapper(User, dingalings)
+ self.mapper_registry.map_imperatively(User, dingalings)
sess = fixture_session(autoflush=False)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
backref="user",
collection_class=attribute_mapped_collection(
"email_address"
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses), backref="user"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ backref="user",
)
},
)
self.classes.CompositePk,
self.tables.composite_pk_table,
)
- mapper(CompositePk, composite_pk_table)
+ self.mapper_registry.map_imperatively(CompositePk, composite_pk_table)
cp1 = CompositePk(j=1, k=1)
sess = fixture_session()
self.tables.composite_pk_table,
)
User, users = (self.classes.User, self.tables.users)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(CompositePk, composite_pk_table)
+ self.mapper_registry.map_imperatively(CompositePk, composite_pk_table)
u1 = User(id=5, name="some user")
cp1 = CompositePk(j=1, k=1)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={"user": relationship(User, cascade="save-update")},
)
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u1 = User(name="fred")
a1 = Address(email_address="asdf", user=u1)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
- properties={"addresses": relationship(mapper(Address, addresses))},
+ properties={
+ "addresses": relationship(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ )
+ },
)
load = self.load_tracker(User)
self.classes.User,
)
- mapper(Address, addresses, properties={"user": relationship(User)})
- mapper(User, users)
+ self.mapper_registry.map_imperatively(
+ Address, addresses, properties={"user": relationship(User)}
+ )
+ self.mapper_registry.map_imperatively(User, users)
u1 = User(id=1, name="u1")
a1 = Address(id=1, email_address="a1", user=u1)
self.classes.Item,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
"items": relationship(
- mapper(Item, items), secondary=order_items
+ self.mapper_registry.map_imperatively(Item, items),
+ secondary=order_items,
)
},
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"address": relationship(
- mapper(Address, addresses), uselist=False
+ self.mapper_registry.map_imperatively(Address, addresses),
+ uselist=False,
)
},
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"address": relationship(
- mapper(Address, addresses), uselist=False, backref="user"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ uselist=False,
+ backref="user",
)
},
)
def test_transient_no_load(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u = User()
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses), backref="user"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ backref="user",
)
},
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
- properties={"addresses": relationship(mapper(Address, addresses))},
+ properties={
+ "addresses": relationship(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ )
+ },
)
with fixture_session(expire_on_commit=False) as sess:
u = User()
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
with fixture_session(expire_on_commit=False) as sess:
u = User()
u.id = 7
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses), backref="user"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ backref="user",
)
},
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
backref="user",
cascade="all, delete-orphan",
)
value = property(_getValue, _setValue)
- mapper(User, users, properties={"uid": synonym("id")})
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"uid": synonym("id")}
+ )
sess = fixture_session()
u = User()
)
s = fixture_session(autoflush=True, autocommit=False)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses), backref="user"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ backref="user",
)
},
)
)
sess = fixture_session(autoflush=True, autocommit=False)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses), backref="user"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ backref="user",
)
},
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
u = User(
id=7, name="fred", addresses=[Address(id=1, email_address="fred1")]
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
u = User(id=7)
sess = fixture_session(autoflush=True, autocommit=False)
u = sess.merge(u)
sess = fixture_session()
- umapper = mapper(User, users)
+ umapper = self.mapper_registry.map_imperatively(User, users)
sess.add_all([User(id=1, name="u1"), User(id=2, name="u2")])
sess.commit()
self.tables.orders,
)
- mapper(User, users, properties={"orders": relationship(Order)})
- mapper(Order, orders, properties={"address": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"orders": relationship(Order)}
+ )
+ self.mapper_registry.map_imperatively(
+ Order, orders, properties={"address": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
u1 = User(id=7, name="x")
u1.orders = [
self.tables.orders,
)
- mapper(User, users, properties={"orders": relationship(Order)})
- mapper(Order, orders, properties={"address": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"orders": relationship(Order)}
+ )
+ self.mapper_registry.map_imperatively(
+ Order, orders, properties={"address": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
u1 = User(id=7, name="x")
u1.orders = [
self.tables.orders,
)
- mapper(User, users, properties={"orders": relationship(Order)})
- mapper(Order, orders, properties={"address": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"orders": relationship(Order)}
+ )
+ self.mapper_registry.map_imperatively(
+ Order, orders, properties={"address": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
sess.add(Address(id=1, email_address="z"))
def setup_mappers(cls):
User, Address = cls.classes.User, cls.classes.Address
user, address = cls.tables.user, cls.tables.address
- mapper(
+ cls.mapper_registry.map_imperatively(
User,
user,
properties={
)
},
)
- mapper(Address, address)
+ cls.mapper_registry.map_imperatively(Address, address)
configure_mappers()
assert Address.user.property._use_get is False
def test_deferred_column_mapping(self):
# 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)})
+ self.mapper_registry.map_imperatively(
+ Book, book, properties={"excerpt": deferred(book.c.excerpt)}
+ )
sess = fixture_session()
b = Book(
def test_deferred_column_query(self):
Book, book = self.classes.Book, self.tables.book
- mapper(Book, book)
+ self.mapper_registry.map_imperatively(Book, book)
sess = fixture_session()
b = Book(
def test_list(self):
Data, data = self.classes.Data, self.tables.data
- mapper(Data, data)
+ self.mapper_registry.map_imperatively(Data, data)
sess = fixture_session()
d = Data(data=["this", "is", "a", "list"])
def test_merge_allow_partial(self):
Data, data = self.classes.Data, self.tables.data
- mapper(Data, data)
+ self.mapper_registry.map_imperatively(Data, data)
sess = fixture_session()
d1 = Data(pk1="someval", pk2=None)
def test_merge_disallow_partial(self):
Data, data = self.classes.Data, self.tables.data
- mapper(Data, data, allow_partial_pks=False)
+ self.mapper_registry.map_imperatively(
+ Data, data, allow_partial_pks=False
+ )
sess = fixture_session()
d1 = Data(pk1="someval", pk2=None)
pass
def _setup_delete_orphan_o2o(self):
- mapper(
+ self.mapper_registry.map_imperatively(
self.classes.Rock,
self.tables.rocks,
properties={
)
},
)
- mapper(self.classes.Bug, self.tables.bugs)
+ self.mapper_registry.map_imperatively(
+ self.classes.Bug, self.tables.bugs
+ )
self.sess = fixture_session()
def _merge_delete_orphan_o2o_with(self, bug):
pass
def _setup_polymorphic_on_mappers(self):
- employee_mapper = mapper(
+ employee_mapper = self.mapper_registry.map_imperatively(
self.classes.Employee,
self.tables.employees,
polymorphic_on=case(
),
polymorphic_identity="employee",
)
- mapper(
+ self.mapper_registry.map_imperatively(
self.classes.Manager,
inherits=employee_mapper,
polymorphic_identity="manager",
)
- mapper(
+ self.mapper_registry.map_imperatively(
self.classes.Engineer,
inherits=employee_mapper,
polymorphic_identity="engineer",
from sqlalchemy import String
from sqlalchemy import testing
from sqlalchemy import TypeDecorator
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm.session import make_transient
from sqlalchemy.testing import assert_raises
def test_entity(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u1 = User(username="jack", fullname="jack")
def test_load_after_expire(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u1 = User(username="jack", fullname="jack")
def test_update_to_sql_expr(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u1 = User(username="jack", fullname="jack")
# such as to bump a server side trigger
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u1 = User(username="jack", fullname="jack")
def test_flush_new_pk_after_expire(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u1 = User(username="jack", fullname="jack")
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
u1 = User(username="jack", fullname="jack")
addresses.insert(), dict(email="jack2", username="jack")
)
- mapper(User, users)
- mapper(
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={"user": relationship(User, passive_updates=False)},
self.classes.User,
)
- mapper(User, users)
- mapper(
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
u1 = User(username="jack", fullname="jack")
self.classes.User,
)
- mapper(User, users)
- mapper(
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
self.tables.users_to_items,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
sess = fixture_session()
u1 = User(username="jack")
self.classes.User,
)
- mapper(User, users)
- mapper(
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
self.classes.User,
)
- mapper(User, users)
- mapper(Address, addresses, properties={"user": relationship(User)})
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
+ Address, addresses, properties={"user": relationship(User)}
+ )
sess = fixture_session()
u1 = User(id=5, name="u1")
PUBLISHED, EDITABLE, ARCHIVED = 1, 2, 3
- mapper(User, user)
+ self.mapper_registry.map_imperatively(User, user)
session = fixture_session()
PUBLISHED, EDITABLE, ARCHIVED = 1, 2, 3
- mapper(User, user)
+ self.mapper_registry.map_imperatively(User, user)
session = fixture_session()
def test_one_to_many_on_m2o(self):
Node, nodes = self.classes.Node, self.tables.nodes
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={
def test_one_to_many_on_o2m(self):
Node, nodes = self.classes.Node, self.tables.nodes
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={
def _test_many_to_one(self, passive):
Node, nodes = self.classes.Node, self.tables.nodes
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={
self.tables.addresses,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
u1 = User(username="jack", fullname="jack")
self.tables.addresses,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
a1 = Address(username="ed", email="ed@host1")
self.tables.addresses,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session(autoflush=False)
a1 = Address(username="ed", email="ed@host1")
self.tables.addresses,
)
- mapper(User, users)
- mapper(
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
)
# tests [ticket:1856]
- mapper(User, users)
- mapper(
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
self.tables.addresses,
)
- mapper(User, users)
- mapper(
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={"user": relationship(User, passive_updates=True)},
self.tables.addresses,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
a1, a2 = (
"person", "manager", "engineer", "owner"
)
- mapper(
+ self.mapper_registry.map_imperatively(
Person,
person,
polymorphic_on=person.c.type,
passive_updates=passive_updates,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Engineer,
engineer,
inherits=Person,
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Manager, manager, inherits=Person, polymorphic_identity="manager"
)
if threelevel:
- mapper(
+ self.mapper_registry.map_imperatively(
Owner, owner, inherits=Manager, polymorphic_identity="owner"
)
@classmethod
def setup_mappers(cls):
- mapper(cls.classes.Data, cls.tables.data)
+ cls.mapper_registry.map_imperatively(cls.classes.Data, cls.tables.data)
def test_updates_sorted(self):
Data = self.classes.Data
self.tables.engineer,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Person,
person,
polymorphic_on=person.c.type,
polymorphic_identity="person",
passive_updates=passive_updates,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Engineer,
engineer,
inherits=Person,
from sqlalchemy import Integer
from sqlalchemy import String
from sqlalchemy import testing
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.testing import fixtures
from sqlalchemy.testing.fixtures import fixture_session
self.classes.Jack,
)
- mapper(Port, port)
- mapper(
+ self.mapper_registry.map_imperatively(Port, port)
+ self.mapper_registry.map_imperatively(
Jack,
jack,
properties=dict(
self.classes.Jack,
)
- mapper(Port, port)
- mapper(
+ self.mapper_registry.map_imperatively(Port, port)
+ self.mapper_registry.map_imperatively(
Jack,
jack,
properties=dict(
self.classes.Jack,
)
- mapper(Port, port)
- mapper(
+ self.mapper_registry.map_imperatively(Port, port)
+ self.mapper_registry.map_imperatively(
Jack,
jack,
properties=dict(
from sqlalchemy.orm import joinedload
from sqlalchemy.orm import Load
from sqlalchemy.orm import load_only
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import strategy_options
from sqlalchemy.orm import subqueryload
from sqlalchemy.testing import fixtures
from sqlalchemy.testing.assertions import assert_raises_message
from sqlalchemy.testing.assertions import AssertsCompiledSQL
+from sqlalchemy.testing.assertions import emits_warning
from sqlalchemy.testing.assertions import eq_
from sqlalchemy.testing.fixtures import fixture_session
from test.orm import _fixtures
class SubItem(cls.classes.Item):
pass
- mapper(
+ cls.mapper_registry.map_imperatively(
SubItem,
None,
inherits=cls.classes.Item,
def some_attr(self):
return "hi"
- mapper(OrderWProp, None, inherits=cls.classes.Order)
+ cls.mapper_registry.map_imperatively(
+ OrderWProp, None, inherits=cls.classes.Order
+ )
class PathTest(object):
class SubAddr(Address):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
SubAddr,
inherits=Address,
properties={
return User, Address, SubAddr
+ @emits_warning("This declarative base already contains a class")
def test_oftype_only_col_attr_unbound(self):
User, Address, SubAddr = self._fixture()
[(User, "addresses"), (User, "addresses", SubAddr, "sub_attr")],
)
+ @emits_warning("This declarative base already contains a class")
def test_oftype_only_col_attr_bound(self):
User, Address, SubAddr = self._fixture()
[(User, "addresses"), (User, "addresses", SubAddr, "sub_attr")],
)
+ @emits_warning("This declarative base already contains a class")
def test_oftype_only_col_attr_string_unbound(self):
User, Address, SubAddr = self._fixture()
[(User, "addresses"), (User, "addresses", SubAddr, "sub_attr")],
)
+ @emits_warning("This declarative base already contains a class")
def test_oftype_only_col_attr_string_bound(self):
User, Address, SubAddr = self._fixture()
[(User, "addresses"), (User, "addresses", SubAddr, "sub_attr")],
)
+ @emits_warning("This declarative base already contains a class")
def test_oftype_only_rel_attr_unbound(self):
User, Address, SubAddr = self._fixture()
l1, q, [(User, "addresses"), (User, "addresses", SubAddr, "dings")]
)
+ @emits_warning("This declarative base already contains a class")
def test_oftype_only_rel_attr_bound(self):
User, Address, SubAddr = self._fixture()
l1, q, [(User, "addresses"), (User, "addresses", SubAddr, "dings")]
)
+ @emits_warning("This declarative base already contains a class")
def test_oftype_only_rel_attr_string_unbound(self):
User, Address, SubAddr = self._fixture()
l1, q, [(User, "addresses"), (User, "addresses", SubAddr, "dings")]
)
+ @emits_warning("This declarative base already contains a class")
def test_oftype_only_rel_attr_string_bound(self):
User, Address, SubAddr = self._fixture()
opt = self._option_fixture(ac.orders, Order.items)
self._assert_path_result(opt, q, [])
+ @emits_warning("This declarative base already contains a class")
def test_from_base_to_subclass_attr(self):
Dingaling, Address = self.classes.Dingaling, self.classes.Address
class SubAddr(Address):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
SubAddr,
inherits=Address,
properties={"flub": relationship(Dingaling, viewonly=True)},
self._assert_path_result(opt, q, [(SubAddr, "flub")])
+ @emits_warning("This declarative base already contains a class")
def test_from_subclass_to_subclass_attr(self):
Dingaling, Address = self.classes.Dingaling, self.classes.Address
class SubAddr(Address):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
SubAddr,
inherits=Address,
properties={"flub": relationship(Dingaling, viewonly=True)},
class SubAddr(Address):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
SubAddr,
inherits=Address,
properties={"flub": relationship(Dingaling, viewonly=True)},
opt, q, [(Address, inspect(Address).attrs.user)]
)
+ @emits_warning("This declarative base already contains a class")
def test_of_type(self):
User, Address = self.classes.User, self.classes.Address
class SubAddr(Address):
pass
- mapper(SubAddr, inherits=Address)
+ self.mapper_registry.map_imperatively(SubAddr, inherits=Address)
q = sess.query(User)
opt = self._option_fixture(
],
)
+ @emits_warning("This declarative base already contains a class")
def test_of_type_string_attr(self):
User, Address = self.classes.User, self.classes.Address
class SubAddr(Address):
pass
- mapper(SubAddr, inherits=Address)
+ self.mapper_registry.map_imperatively(SubAddr, inherits=Address)
q = sess.query(User)
opt = self._option_fixture(User.addresses.of_type(SubAddr), "user")
],
)
+ @emits_warning("This declarative base already contains a class")
def test_of_type_plus_level(self):
Dingaling, User, Address = (
self.classes.Dingaling,
class SubAddr(Address):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
SubAddr,
inherits=Address,
properties={"flub": relationship(Dingaling, viewonly=True)},
cls.tables.orders,
cls.classes.Order,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
User,
users,
properties={
"orders": relationship(Order),
},
)
- mapper(Address, addresses)
- mapper(Order, orders)
+ cls.mapper_registry.map_imperatively(Address, addresses)
+ cls.mapper_registry.map_imperatively(Order, orders)
keywords, items, item_keywords, Keyword, Item = (
cls.tables.keywords,
cls.tables.items,
cls.classes.Keyword,
cls.classes.Item,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Keyword,
keywords,
properties={
"keywords": column_property(keywords.c.name + "some keyword")
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Item,
items,
properties=dict(
def some_attr(self):
return "hi"
- mapper(OrderWProp, None, inherits=cls.classes.Order)
+ cls.mapper_registry.map_imperatively(
+ OrderWProp, None, inherits=cls.classes.Order
+ )
def _assert_option(self, entity_list, option):
Item = self.classes.Item
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
addresses=relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
lazy="select",
order_by=addresses.c.id,
),
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
addresses=relationship(
- mapper(Address, addresses), order_by=addresses.c.id
+ self.mapper_registry.map_imperatively(Address, addresses),
+ order_by=addresses.c.id,
)
),
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
addresses=relationship(
- mapper(Address, addresses), lazy="select"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="select",
)
),
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
addresses=relationship(
- mapper(Address, addresses), lazy="joined"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="joined",
)
),
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
addresses=relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
lazy="joined",
order_by=addresses.c.id,
)
# users, they will have no addresses or orders. the number of lazy
# loads when traversing the whole thing will be three for the
# addresses and three for the orders.
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
- mapper(Keyword, keywords)
+ self.mapper_registry.map_imperatively(Keyword, keywords)
- mapper(
+ self.mapper_registry.map_imperatively(
Item,
items,
properties=dict(
),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=dict(
),
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
addresses=relationship(
- mapper(Address, addresses), lazy="joined"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="joined",
)
),
)
self.tables.orders,
)
- mapper(User, users, properties=dict(orders=relationship(Order)))
- mapper(
+ self.mapper_registry.map_imperatively(
+ User, users, properties=dict(orders=relationship(Order))
+ )
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties=dict(items=relationship(Item, secondary=order_items)),
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
sess = fixture_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 state as sa_state
from sqlalchemy.orm import subqueryload
self.tables.dingalings,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={"dingaling": relationship(Dingaling)},
)
- mapper(Dingaling, dingalings)
+ self.mapper_registry.map_imperatively(Dingaling, dingalings)
sess = fixture_session()
u1 = User(name="ed")
u1.addresses.append(Address(email_address="ed@bar.com"))
def test_transient(self):
users, addresses = (self.tables.users, self.tables.addresses)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
u1 = User(name="ed")
def test_no_mappers(self):
users = self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
u1 = User(name="ed")
u1_pickled = pickle.dumps(u1, -1)
def test_no_instrumentation(self):
users = self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
u1 = User(name="ed")
u1_pickled = pickle.dumps(u1, -1)
clear_mappers()
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
u1 = pickle.loads(u1_pickled)
# this fails unless the InstanceState
def test_class_deferred_cols(self):
addresses, users = (self.tables.addresses, self.tables.users)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(Address, backref="user"),
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
def test_instance_lazy_relation_loaders(self):
users, addresses = (self.tables.users, self.tables.addresses)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, lazy="noload")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
u1 = User(name="ed", addresses=[Address(email_address="ed@bar.com")])
def test_lazyload_extra_criteria_not_supported(self):
users, addresses = (self.tables.users, self.tables.addresses)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address)},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
u1 = User(
def test_invalidated_flag_pickle(self):
users, addresses = (self.tables.users, self.tables.addresses)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, lazy="noload")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
u1 = User()
u1.addresses.append(Address())
def test_invalidated_flag_deepcopy(self):
users, addresses = (self.tables.users, self.tables.addresses)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, lazy="noload")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
u1 = User()
u1.addresses.append(Address())
def test_instance_deferred_cols(self):
users, addresses = (self.tables.users, self.tables.addresses)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
with fixture_session(expire_on_commit=False) as sess:
u1 = User(name="ed")
def test_pickle_protocols(self):
users, addresses = (self.tables.users, self.tables.addresses)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
u1 = User(name="ed")
def test_09_pickle(self):
users = self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
sess.add(User(id=1, name="ed"))
sess.commit()
def test_11_pickle(self):
users = self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u1 = User(id=1, name="ed")
sess.add(u1)
def test_state_info_pickle(self):
users = self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
u1 = User(id=1, name="ed")
)
p = Table("p", m, Column("id", String, primary_key=True))
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
p,
properties={
"children2": relationship(Child2),
},
)
- mapper(Child1, c1)
- mapper(Child2, c2)
+ self.mapper_registry.map_imperatively(Child1, c1)
+ self.mapper_registry.map_imperatively(Child2, c2)
obj = Parent()
screen1 = Screen(obj)
pass
users = self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
for sa_exc in (
orm_exc.UnmappedInstanceError(Foo()),
def test_attribute_mapped_collection(self):
users, addresses = self.tables.users, self.tables.addresses
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
u1 = User()
u1.addresses = {"email1": Address(email_address="email1")}
for loads, dumps in picklers():
def test_column_mapped_collection(self):
users, addresses = self.tables.users, self.tables.addresses
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
u1 = User()
u1.addresses = {
"email1": Address(email_address="email1"),
def test_composite_column_mapped_collection(self):
users, addresses = self.tables.users, self.tables.addresses
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
u1 = User()
u1.addresses = {
(1, "email1"): Address(id=1, email_address="email1"),
def test_polymorphic_deferred(self):
email_users, users = (self.tables.email_users, self.tables.users)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
polymorphic_identity="user",
polymorphic_on=users.c.type,
)
- mapper(
+ self.mapper_registry.map_imperatively(
EmailUser,
email_users,
inherits=User,
cls.tables.addresses,
cls.tables.orders,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
User,
users,
properties={
),
},
)
- mapper(Address, addresses)
- mapper(
+ cls.mapper_registry.map_imperatively(Address, addresses)
+ cls.mapper_registry.map_imperatively(
Order, orders, properties={"address": relationship(Address)}
) # m2o
users = self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
u1 = User()
attributes.manager_of_class(User).teardown_instance(u1)
from sqlalchemy.orm import attributes
from sqlalchemy.orm import backref
from sqlalchemy.orm import Bundle
+from sqlalchemy.orm import clear_mappers
from sqlalchemy.orm import column_property
from sqlalchemy.orm import contains_eager
from sqlalchemy.orm import defer
from sqlalchemy.orm import deferred
from sqlalchemy.orm import joinedload
from sqlalchemy.orm import lazyload
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import Query
from sqlalchemy.orm import relationship
from sqlalchemy.orm import selectinload
Column("id", Integer, primary_key=True),
Column("name", String, key="uname"),
)
- mapper(User, uwkey)
+ self.mapper_registry.map_imperatively(User, uwkey)
else:
- mapper(User, users, properties={"uname": users.c.name})
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"uname": users.c.name}
+ )
s = fixture_session()
if legacy:
"""test #6979"""
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s = fixture_session()
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s = fixture_session()
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s = fixture_session()
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s = fixture_session()
User, users = self.classes.User, self.tables.users
Address, addresses = self.classes.Address, self.tables.addresses
- mapper(User, users, properties={"addresses": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
s = fixture_session()
self.classes.User,
)
- mapper(User, users)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
user_alias = aliased(User)
user_alias_id_label = user_alias.id.label("foo")
User, users = self.classes.User, self.tables.users
Address, addresses = self.classes.Address, self.tables.addresses
- mapper(User, users, properties={"addresses": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
s = fixture_session()
q = (
User, users = self.classes.User, self.tables.users
Address, addresses = self.classes.Address, self.tables.addresses
- mapper(User, users, properties={"addresses": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
s = fixture_session()
User, users = self.classes.User, self.tables.users
Address, addresses = self.classes.Address, self.tables.addresses
- mapper(User, users, properties={"addresses": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
s = fixture_session()
User, users = self.classes.User, self.tables.users
Address, addresses = self.classes.Address, self.tables.addresses
- mapper(User, users, properties={"addresses": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
s = fixture_session()
User, users = self.classes.User, self.tables.users
Address, addresses = self.classes.Address, self.tables.addresses
- mapper(User, users, properties={"addresses": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
class MyType(TypeDecorator):
impl = Integer
String,
),
)
- mapper(Foo, users, properties={"uname": users.c.name})
+ self.mapper_registry.map_imperatively(
+ Foo, users, properties={"uname": users.c.name}
+ )
else:
users = self.tables.users
- mapper(Foo, users, properties={"uname": users.c.name})
+ clear_mappers()
+ self.mapper_registry.map_imperatively(
+ Foo, users, properties={"uname": users.c.name}
+ )
return Foo
assert_raises(sa_exc.InvalidRequestError, q.get, (5,))
@testing.fixture
- def outerjoin_mapping(self):
+ def outerjoin_mapping(self, registry):
users, addresses = self.tables.users, self.tables.addresses
s = users.outerjoin(addresses)
class UserThing(fixtures.ComparableEntity):
pass
- mapper(
+ registry.map_imperatively(
UserThing,
s,
properties={
pass
s = users.select().where(users.c.id != 12).alias("users")
- m = mapper(SomeUser, s)
+ m = self.mapper_registry.map_imperatively(SomeUser, s)
assert s.primary_key == m.primary_key
sess = fixture_session()
class LocalFoo(self.classes.Base):
pass
- mapper(LocalFoo, table)
+ self.mapper_registry.map_imperatively(LocalFoo, table)
with Session(connection) as sess:
eq_(
sess.get(LocalFoo, ustring),
else:
stmt = stmt.scalar_subquery()
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"ead": column_property(stmt)},
with_polymorphic="*" if polymorphic else None,
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
def _func_fixture(self, label=False):
User = self.classes.User
users = self.tables.users
if label:
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
},
)
else:
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
User = self.classes.User
users = self.tables.users
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
def _eagerload_mappings(self, addresses_lazy=True, user_lazy=True):
User, Address = self.classes("User", "Address")
users, addresses = self.tables("users", "addresses")
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
def test_basic(self):
self._eagerload_mappings()
def setup_mappers(cls):
User = cls.classes.User
users = cls.tables.users
- mapper(User, users)
+ cls.mapper_registry.map_imperatively(User, users)
@classmethod
def fixtures(cls):
self.tables.has_dingaling,
)
- mapper(User, users)
- mapper(
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
),
},
)
- mapper(Dingaling, dingalings)
- mapper(
+ self.mapper_registry.map_imperatively(Dingaling, dingalings)
+ self.mapper_registry.map_imperatively(
HasDingaling,
has_dingaling,
properties={
cls.tables.addresses,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
User,
users,
properties={
"orders_syn_2": synonym("orders_syn"),
},
)
- mapper(Address, addresses)
- mapper(
+ cls.mapper_registry.map_imperatively(Address, addresses)
+ cls.mapper_registry.map_imperatively(
Order,
orders,
properties={
"items_syn": synonym("items"),
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Item,
items,
properties={
) # m2m
},
)
- mapper(Keyword, keywords)
+ cls.mapper_registry.map_imperatively(Keyword, keywords)
def test_options(self):
User, Order = self.classes.User, self.classes.Order
cls.classes.User,
)
- mapper(Address, addresses)
+ cls.mapper_registry.map_imperatively(Address, addresses)
- mapper(User, users, properties=dict(addresses=relationship(Address)))
+ cls.mapper_registry.map_imperatively(
+ User, users, properties=dict(addresses=relationship(Address))
+ )
def test_one(self):
User, Address = self.classes.User, self.classes.Address
from sqlalchemy.orm import defer
from sqlalchemy.orm import joinedload
from sqlalchemy.orm import lazyload
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import registry
from sqlalchemy.orm import relationship
from sqlalchemy.orm import selectinload
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses), order_by=Address.id
+ self.mapper_registry.map_imperatively(Address, addresses),
+ order_by=Address.id,
)
},
)
"orders", "items", "order_items"
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
),
},
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
return Order, Item
"users", "orders", "items", "order_items"
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"orders": relationship(Order, order_by=orders.c.id)},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
),
},
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
return User, Order, Item
class UserWFoob(HasFoob, self.Comparable):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
UserWFoob,
users,
)
class UserWFoob(HasFoob, self.Comparable):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
UserWFoob,
users,
)
from sqlalchemy.orm import exc as orm_exc
from sqlalchemy.orm import foreign
from sqlalchemy.orm import joinedload
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import remote
from sqlalchemy.orm import selectinload
cls.tables.tbl_d,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
A,
tbl_a,
properties=dict(
)
),
)
- mapper(B, tbl_b)
- mapper(
+ cls.mapper_registry.map_imperatively(B, tbl_b)
+ cls.mapper_registry.map_imperatively(
C,
tbl_c,
properties=dict(
)
),
)
- mapper(D, tbl_d, properties=dict(b_row=relationship(B)))
+ cls.mapper_registry.map_imperatively(
+ D, tbl_d, properties=dict(b_row=relationship(B))
+ )
@classmethod
def insert_data(cls, connection):
class B(fixtures.BasicEntity):
pass
- mapper(A, a, properties={"b": relationship(B, uselist=uselist)})
- mapper(B, b)
+ self.mapper_registry.map_imperatively(
+ A, a, properties={"b": relationship(B, uselist=uselist)}
+ )
+ self.mapper_registry.map_imperatively(B, b)
return A, B
def test_joinedload_doesnt_produce_bogus_event(self):
Entity = self.classes.Entity
entity = self.tables.entity
- m = mapper(
+ m = self.mapper_registry.map_imperatively(
Entity,
entity,
properties={
Entity = self.classes.Entity
entity = self.tables.entity
- m = mapper(
+ m = self.mapper_registry.map_imperatively(
Entity,
entity,
properties={
)
-class OverlappingFksSiblingTest(fixtures.TestBase):
+class OverlappingFksSiblingTest(fixtures.MappedTest):
"""Test multiple relationships that use sections of the same
composite foreign key.
"""
- def teardown_test(self):
- clear_mappers()
+ run_define_tables = "each"
def _fixture_one(
self,
add_b_a_overlaps=None,
):
- Base = declarative_base(metadata=self.metadata)
+ Base = self.mapper_registry.generate_base()
class A(Base):
__mapper_args__ = {"polymorphic_identity": "bsub2"}
configure_mappers()
- self.metadata.create_all(testing.db)
+ assert self.tables_test_metadata is Base.metadata
+ self.tables_test_metadata.create_all(testing.db)
return A, AMember, B, BSub1, BSub2
def _fixture_two(self, setup_backrefs=False, setup_overlaps=False):
- Base = declarative_base(metadata=self.metadata)
+ Base = self.mapper_registry.generate_base()
# purposely using the comma to make sure parsing the comma works
configure_mappers()
def _fixture_three(self, use_same_mappers, setup_overlaps):
- Base = declarative_base(metadata=self.metadata)
+ Base = self.mapper_registry.generate_base()
class Child(Base):
__tablename__ = "child"
configure_mappers()
def _fixture_four(self):
- Base = declarative_base(metadata=self.metadata)
+ Base = self.mapper_registry.generate_base()
class A(Base):
__tablename__ = "a"
@testing.combinations((True,), (False,), argnames="set_overlaps")
def test_fixture_five(self, metadata, set_overlaps):
- Base = declarative_base(metadata=self.metadata)
+ Base = self.mapper_registry.generate_base()
if set_overlaps:
overlaps = "as,cs"
self.tables.company_t,
)
- mapper(Company, company_t)
- mapper(
+ self.mapper_registry.map_imperatively(Company, company_t)
+ self.mapper_registry.map_imperatively(
Employee,
employee_t,
properties={
self.tables.company_t,
)
- mapper(Company, company_t)
- mapper(
+ self.mapper_registry.map_imperatively(Company, company_t)
+ self.mapper_registry.map_imperatively(
Employee,
employee_t,
properties={
self.tables.company_t,
)
- mapper(Company, company_t)
- mapper(
+ self.mapper_registry.map_imperatively(Company, company_t)
+ self.mapper_registry.map_imperatively(
Employee,
employee_t,
properties={
self.tables.company_t,
)
- mapper(Company, company_t)
- mapper(
+ self.mapper_registry.map_imperatively(Company, company_t)
+ self.mapper_registry.map_imperatively(
Employee,
employee_t,
properties={
self.tables.company_t,
)
- mapper(Company, company_t)
- mapper(
+ self.mapper_registry.map_imperatively(Company, company_t)
+ self.mapper_registry.map_imperatively(
Employee,
employee_t,
properties={
self.tables.company_t,
)
- mapper(Company, company_t)
- mapper(
+ self.mapper_registry.map_imperatively(Company, company_t)
+ self.mapper_registry.map_imperatively(
Employee,
employee_t,
properties={
self.tables.company_t,
)
- mapper(Company, company_t)
- mapper(
+ self.mapper_registry.map_imperatively(Company, company_t)
+ self.mapper_registry.map_imperatively(
Employee,
employee_t,
properties={
class Child(cls.Comparable):
pass
- mapper(
+ cls.mapper_registry.map_imperatively(
Parent,
parent,
properties={
)
},
)
- mapper(Child, child)
+ cls.mapper_registry.map_imperatively(Child, child)
def test_joins_fully(self):
Parent = self.classes.Parent
self.tables.tableA,
)
- mapper(
+ self.mapper_registry.map_imperatively(
B, tableB, properties={"a_id": synonym("_a_id", map_column=True)}
)
- mapper(
+ self.mapper_registry.map_imperatively(
A,
tableA,
properties={
self.tables.tableA,
)
- mapper(
+ self.mapper_registry.map_imperatively(
A,
tableA,
properties={
)
},
)
- mapper(B, tableB)
+ self.mapper_registry.map_imperatively(B, tableB)
configure_mappers()
assert A.b.property.strategy.use_get
self.tables.tableA,
)
- mapper(
+ self.mapper_registry.map_imperatively(
A,
tableA,
properties={"bs": relationship(B, cascade="save-update")},
)
- mapper(B, tableB)
+ self.mapper_registry.map_imperatively(B, tableB)
a1 = A()
a1.bs.append(B())
self.tables.tableA,
)
- mapper(
+ self.mapper_registry.map_imperatively(
B, tableB, properties={"a": relationship(A, cascade="save-update")}
)
- mapper(A, tableA)
+ self.mapper_registry.map_imperatively(A, tableA)
b1 = B()
a1 = A()
class C(fixtures.BasicEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
C, tableC, properties={"a": relationship(A, cascade="save-update")}
)
- mapper(A, tableA)
+ self.mapper_registry.map_imperatively(A, tableA)
c1 = C()
c1.id = 5
# test that no error is raised.
sess.flush()
- def test_delete_cascade_BtoA(self):
+ @testing.combinations(
+ "save-update, delete",
+ # "save-update, delete-orphan",
+ "save-update, delete, delete-orphan",
+ )
+ def test_delete_cascade_BtoA(self, cascade):
"""No 'blank the PK' error when the child is to
be deleted as part of a cascade"""
self.tables.tableA,
)
- for cascade in (
- "save-update, delete",
- # "save-update, delete-orphan",
- "save-update, delete, delete-orphan",
- ):
- mapper(
- B,
- tableB,
- properties={
- "a": relationship(A, cascade=cascade, single_parent=True)
- },
- )
- mapper(A, tableA)
+ self.mapper_registry.map_imperatively(
+ B,
+ tableB,
+ properties={
+ "a": relationship(A, cascade=cascade, single_parent=True)
+ },
+ )
+ self.mapper_registry.map_imperatively(A, tableA)
- b1 = B()
- a1 = A()
- b1.a = a1
- 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):
+ b1 = B()
+ a1 = A()
+ b1.a = a1
+ 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
+
+ @testing.combinations(
+ "save-update, delete",
+ # "save-update, delete-orphan",
+ "save-update, delete, delete-orphan",
+ )
+ def test_delete_cascade_AtoB(self, cascade):
"""No 'blank the PK' error when the child is to
be deleted as part of a cascade"""
self.tables.tableA,
)
- for cascade in (
- "save-update, delete",
- # "save-update, delete-orphan",
- "save-update, delete, delete-orphan",
- ):
- mapper(
- A, tableA, properties={"bs": relationship(B, cascade=cascade)}
- )
- mapper(B, tableB)
-
- a1 = A()
- b1 = B()
- a1.bs.append(b1)
- with fixture_session() as sess:
- sess.add(a1)
- sess.flush()
+ self.mapper_registry.map_imperatively(
+ A, tableA, properties={"bs": relationship(B, cascade=cascade)}
+ )
+ self.mapper_registry.map_imperatively(B, tableB)
- sess.delete(a1)
- sess.flush()
- assert a1 not in sess
- assert b1 not in sess
+ a1 = A()
+ b1 = B()
+ a1.bs.append(b1)
+ with fixture_session() as sess:
+ sess.add(a1)
+ sess.flush()
- sa.orm.clear_mappers()
+ sess.delete(a1)
+ sess.flush()
+ assert a1 not in sess
+ assert b1 not in sess
def test_delete_manual_AtoB(self):
tableB, A, B, tableA = (
self.tables.tableA,
)
- mapper(A, tableA, properties={"bs": relationship(B, cascade="none")})
- mapper(B, tableB)
+ self.mapper_registry.map_imperatively(
+ A, tableA, properties={"bs": relationship(B, cascade="none")}
+ )
+ self.mapper_registry.map_imperatively(B, tableB)
a1 = A()
b1 = B()
self.tables.tableA,
)
- mapper(B, tableB, properties={"a": relationship(A, cascade="none")})
- mapper(A, tableA)
+ self.mapper_registry.map_imperatively(
+ B, tableB, properties={"a": relationship(A, cascade="none")}
+ )
+ self.mapper_registry.map_imperatively(A, tableA)
b1 = B()
a1 = A()
self.tables.table_a,
)
- mapper(A, table_a)
- mapper(B, table_b, properties={"a": relationship(A, backref="bs")})
+ self.mapper_registry.map_imperatively(A, table_a)
+ self.mapper_registry.map_imperatively(
+ B, table_b, properties={"a": relationship(A, backref="bs")}
+ )
session = fixture_session()
a1, a2 = A(ident="uuid1"), A(ident="uuid2")
.alias("container_select")
)
- mapper(LineItem, items)
+ self.mapper_registry.map_imperatively(LineItem, items)
- mapper(
+ self.mapper_registry.map_imperatively(
Container,
container_select,
properties=dict(
class TagInstance(fixtures.ComparableEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Tag,
tags,
properties={
},
)
- mapper(TagInstance, tag_foo)
+ self.mapper_registry.map_imperatively(TagInstance, tag_foo)
sess = fixture_session()
t1 = Tag(data="some tag")
self.tables.addresses,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
u1 = User(name="u1", addresses=[Address(email="a1")])
class Subscriber(cls.Comparable):
pass
- mapper(Address, address)
+ cls.mapper_registry.map_imperatively(Address, address)
- mapper(
+ cls.mapper_registry.map_imperatively(
Subscriber,
subscriber_and_address,
properties={
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
self.tables.users,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
},
)
- mapper(Dingaling, dingalings)
- mapper(
+ self.mapper_registry.map_imperatively(Dingaling, dingalings)
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={"dingaling": relationship(Dingaling)},
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Addr,
addr,
properties={
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
},
)
- mapper(Address, addresses, properties={"user": relationship(User)})
+ self.mapper_registry.map_imperatively(
+ Address, addresses, properties={"user": relationship(User)}
+ )
u1 = User()
a1 = Address()
self.classes.User,
)
- mapper(User, users, properties={"addresses": relationship(Address)})
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
class JoinConditionErrorTest(fixtures.TestBase):
- def test_clauseelement_pj(self):
- from sqlalchemy.orm import declarative_base
-
- Base = declarative_base()
+ def test_clauseelement_pj(self, registry):
+ Base = registry.generate_base()
class C1(Base):
__tablename__ = "c1"
assert_raises(sa.exc.ArgumentError, configure_mappers)
- def test_clauseelement_pj_false(self):
- from sqlalchemy.orm import declarative_base
-
- Base = declarative_base()
+ def test_clauseelement_pj_false(self, registry):
+ Base = registry.generate_base()
class C1(Base):
__tablename__ = "c1"
assert_raises(sa.exc.ArgumentError, configure_mappers)
- def test_only_column_elements(self):
+ def test_only_column_elements(self, registry):
m = MetaData()
t1 = Table(
"t1",
class C2(object):
pass
- mapper(
+ registry.map_imperatively(
C1,
t1,
properties={"c2": relationship(C2, primaryjoin=t1.join(t2))},
)
- mapper(C2, t2)
+ registry.map_imperatively(C2, t2)
assert_raises(sa.exc.ArgumentError, configure_mappers)
- def test_invalid_string_args(self):
- from sqlalchemy.orm import declarative_base
-
- for argname, arg in [
- ("remote_side", ["c1.id"]),
- ("remote_side", ["id"]),
- ("foreign_keys", ["c1id"]),
- ("foreign_keys", ["C2.c1id"]),
- ("order_by", ["id"]),
- ]:
- clear_mappers()
- kw = {argname: arg}
- Base = declarative_base()
-
- class C1(Base):
- __tablename__ = "c1"
- id = Column("id", Integer, primary_key=True)
-
- class C2(Base):
- __tablename__ = "c2"
- id_ = Column("id", Integer, primary_key=True)
- c1id = Column("c1id", Integer, ForeignKey("c1.id"))
- c2 = relationship(C1, **kw)
+ @testing.combinations(
+ ("remote_side", ["c1.id"]),
+ ("remote_side", ["id"]),
+ ("foreign_keys", ["c1id"]),
+ ("foreign_keys", ["C2.c1id"]),
+ ("order_by", ["id"]),
+ argnames="argname, arg",
+ )
+ def test_invalid_string_args(self, registry, argname, arg):
- assert_raises_message(
- sa.exc.ArgumentError,
- "Column expression expected "
- "for argument '%s'; got '%s'" % (argname, arg[0]),
- configure_mappers,
- )
+ kw = {argname: arg}
+ Base = registry.generate_base()
+
+ class C1(Base):
+ __tablename__ = "c1"
+ id = Column("id", Integer, primary_key=True)
+
+ class C2(Base):
+ __tablename__ = "c2"
+ id_ = Column("id", Integer, primary_key=True)
+ c1id = Column("c1id", Integer, ForeignKey("c1.id"))
+ c2 = relationship(C1, **kw)
+
+ assert_raises_message(
+ sa.exc.ArgumentError,
+ "Column expression expected "
+ "for argument '%s'; got '%s'" % (argname, arg[0]),
+ configure_mappers,
+ )
- def test_fk_error_not_raised_unrelated(self):
+ def test_fk_error_not_raised_unrelated(self, registry):
m = MetaData()
t1 = Table(
"t1",
class C2(object):
pass
- mapper(C1, t1, properties={"c2": relationship(C2)})
- mapper(C2, t3)
+ registry.map_imperatively(C1, t1, properties={"c2": relationship(C2)})
+ registry.map_imperatively(C2, t3)
assert C1.c2.property.primaryjoin.compare(t1.c.id == t3.c.t1id)
- def test_join_error_raised(self):
+ def test_join_error_raised(self, registry):
m = MetaData()
t1 = Table("t1", m, Column("id", Integer, primary_key=True))
t2 = Table("t2", m, Column("id", Integer, primary_key=True)) # noqa
class C2(object):
pass
- mapper(C1, t1, properties={"c2": relationship(C2)})
- mapper(C2, t3)
+ registry.map_imperatively(C1, t1, properties={"c2": relationship(C2)})
+ registry.map_imperatively(C2, t3)
assert_raises(sa.exc.ArgumentError, configure_mappers)
class C(fixtures.BasicEntity):
pass
- mapper(A, a, properties={"bs": relationship(B)})
- mapper(B, b)
- mapper(C, c)
+ self.mapper_registry.map_imperatively(
+ A, a, properties={"bs": relationship(B)}
+ )
+ self.mapper_registry.map_imperatively(B, b)
+ self.mapper_registry.map_imperatively(C, c)
a1 = A()
b1 = B()
class C(fixtures.BasicEntity):
pass
- mapper(A, a, properties={"bs": relationship(B, cascade="none")})
- mapper(B, b)
- mapper(C, c)
+ self.mapper_registry.map_imperatively(
+ A, a, properties={"bs": relationship(B, cascade="none")}
+ )
+ self.mapper_registry.map_imperatively(B, b)
+ self.mapper_registry.map_imperatively(C, c)
a1 = A()
b1 = B()
class C(B):
pass
- mapper(A, a, properties={"bs": relationship(B, cascade="none")})
- mapper(B, b)
- mapper(C, c, inherits=B)
+ self.mapper_registry.map_imperatively(
+ A, a, properties={"bs": relationship(B, cascade="none")}
+ )
+ self.mapper_registry.map_imperatively(B, b)
+ self.mapper_registry.map_imperatively(C, c, inherits=B)
a1 = A()
b1 = B()
class D(fixtures.BasicEntity):
pass
- mapper(A, a)
- mapper(B, b, inherits=A)
- mapper(D, d, properties={"a": relationship(A, cascade="none")})
+ self.mapper_registry.map_imperatively(A, a)
+ self.mapper_registry.map_imperatively(B, b, inherits=A)
+ self.mapper_registry.map_imperatively(
+ D, d, properties={"a": relationship(A, cascade="none")}
+ )
b1 = B()
d1 = D()
d1.a = b1
class D(fixtures.BasicEntity):
pass
- mapper(A, a)
- mapper(B, b)
- mapper(D, d, properties={"a": relationship(A)})
+ self.mapper_registry.map_imperatively(A, a)
+ self.mapper_registry.map_imperatively(B, b)
+ self.mapper_registry.map_imperatively(
+ D, d, properties={"a": relationship(A)}
+ )
b1 = B()
d1 = D()
d1.a = b1
class T2(fixtures.BasicEntity):
pass
- mapper(T2, t2)
- mapper(
+ self.mapper_registry.map_imperatively(T2, t2)
+ self.mapper_registry.map_imperatively(
T1,
t1,
properties={"t2s": relationship(T2, secondary=t3, backref="t1s")},
class B(fixtures.BasicEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
A,
self.tables.a,
properties={
)
},
)
- mapper(B, self.tables.b)
+ self.mapper_registry.map_imperatively(B, self.tables.b)
self.assert_compile(
fixture_session().query(A).join(A.bs),
"SELECT a.id AS a_id, a.foo AS a_foo "
class B(fixtures.ComparableEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
A,
self.tables.t1,
properties={
)
},
)
- mapper(B, self.tables.t2)
+ self.mapper_registry.map_imperatively(B, self.tables.t2)
configure_mappers()
class B(fixtures.ComparableEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
A,
self.tables.t1,
properties={
)
},
)
- mapper(B, self.tables.t2)
+ self.mapper_registry.map_imperatively(B, self.tables.t2)
configure_mappers()
class B(fixtures.ComparableEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
A,
self.tables.t1,
properties={"bs": relationship(B, viewonly=True)},
)
- mapper(B, self.tables.t2)
+ self.mapper_registry.map_imperatively(B, self.tables.t2)
a1 = A()
b1 = B()
class B(fixtures.ComparableEntity):
pass
- mapper(A, self.tables.t1)
- mapper(
+ self.mapper_registry.map_imperatively(A, self.tables.t1)
+ self.mapper_registry.map_imperatively(
B, self.tables.t2, properties={"a": relationship(A, viewonly=True)}
)
class B(fixtures.ComparableEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
A,
t1,
properties={
)
},
)
- mapper(B, t2)
+ self.mapper_registry.map_imperatively(B, t2)
configure_mappers()
class C3(fixtures.BasicEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
C1,
t1,
properties={
),
},
)
- mapper(C2, t2)
- mapper(C3, t3, properties={"t2": relationship(C2)})
+ self.mapper_registry.map_imperatively(C2, t2)
+ self.mapper_registry.map_imperatively(
+ C3, t3, properties={"t2": relationship(C2)}
+ )
c1 = C1()
c1.data = "c1data"
)
return
- mapper(
+ self.mapper_registry.map_imperatively(
A,
self.tables.t1,
properties={"bs": rel()},
)
- mapper(B, self.tables.t2)
+ self.mapper_registry.map_imperatively(B, self.tables.t2)
if case.B_a_init_error:
assert_raises_message(
class C3(fixtures.BasicEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
C1,
t1,
properties={
),
},
)
- mapper(C2, t2)
- mapper(C3, t3, properties={"t2": relationship(C2)})
+ self.mapper_registry.map_imperatively(C2, t2)
+ self.mapper_registry.map_imperatively(
+ C3, t3, properties={"t2": relationship(C2)}
+ )
c1 = C1()
c1.data = "c1data"
"""test that local-remote is correctly determined for m2m"""
- def test_local_remote(self):
+ def test_local_remote(self, registry):
meta = MetaData()
t1 = Table("t1", meta, Column("id", Integer, primary_key=True))
class B(object):
pass
- mapper(B, t2)
- m = mapper(
+ registry.map_imperatively(B, t2)
+ m = registry.map_imperatively(
A,
t1,
properties=dict(
class Bar(fixtures.ComparableEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
with fixture_session() as sess:
sess.add_all(
class Bar(fixtures.ComparableEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
)
},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
sess = fixture_session()
b1 = Bar(id=1, data="b1")
class Bar(fixtures.ComparableEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
)
},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
sess = fixture_session()
f1 = Foo(id=1, data="f1")
self.tables.t1,
)
- mapper(
+ self.mapper_registry.map_imperatively(
T1,
t1,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
T2,
t2,
properties={
"t3s": relationship(T3, secondary=t2tot3),
},
)
- mapper(T3, t3)
+ self.mapper_registry.map_imperatively(T3, t3)
sess = fixture_session()
sess.add(T2(data="t2", t1=T1(data="t1"), t3s=[T3(data="t3")]))
self.tables.t1,
)
- mapper(
+ self.mapper_registry.map_imperatively(
T1,
t1,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
T2,
t2,
properties={
"t3s": relationship(T3, secondary=t2tot3),
},
)
- mapper(T3, t3)
+ self.mapper_registry.map_imperatively(T3, t3)
self._assert_raises_no_local_remote(configure_mappers, "T1.t3s")
)
# old _local_remote_pairs
- mapper(
+ self.mapper_registry.map_imperatively(
T1,
t1,
properties={
)
},
)
- mapper(T2, t2)
+ self.mapper_registry.map_imperatively(T2, t2)
self._test_onetomany()
def test_onetomany_funcfk_annotated(self):
)
# use annotation
- mapper(
+ self.mapper_registry.map_imperatively(
T1,
t1,
properties={
)
},
)
- mapper(T2, t2)
+ self.mapper_registry.map_imperatively(T2, t2)
self._test_onetomany()
def _test_onetomany(self):
self.tables.t1,
)
- mapper(T1, t1)
- mapper(
+ self.mapper_registry.map_imperatively(T1, t1)
+ self.mapper_registry.map_imperatively(
T2,
t2,
properties={
self.tables.t1,
)
- mapper(
+ self.mapper_registry.map_imperatively(
T1,
t1,
properties={
)
},
)
- mapper(T2, t2)
+ self.mapper_registry.map_imperatively(T2, t2)
sess = fixture_session()
a1 = T1(id="NuMbeR1", data="a1")
self.tables.t1,
)
- mapper(T1, t1)
- mapper(
+ self.mapper_registry.map_imperatively(T1, t1)
+ self.mapper_registry.map_imperatively(
T2,
t2,
properties={
self.tables.t1,
)
- mapper(
+ self.mapper_registry.map_imperatively(
T1,
t1,
properties={
)
},
)
- mapper(T2, t2)
+ self.mapper_registry.map_imperatively(T2, t2)
assert_raises(sa.exc.ArgumentError, sa.orm.configure_mappers)
def test_escalation_2(self):
self.tables.t1,
)
- mapper(
+ self.mapper_registry.map_imperatively(
T1,
t1,
properties={
)
},
)
- mapper(T2, t2)
+ self.mapper_registry.map_imperatively(T2, t2)
assert_raises(sa.exc.ArgumentError, sa.orm.configure_mappers)
def test_o2m_backref(self):
T1, t1 = self.classes.T1, self.tables.t1
- mapper(T1, t1, properties={"t1s": relationship(T1, backref="parent")})
+ self.mapper_registry.map_imperatively(
+ T1, t1, properties={"t1s": relationship(T1, backref="parent")}
+ )
assert_raises_message(
sa.exc.ArgumentError,
def test_m2o_backref(self):
T1, t1 = self.classes.T1, self.tables.t1
- mapper(
+ self.mapper_registry.map_imperatively(
T1,
t1,
properties={
def test_o2m_explicit(self):
T1, t1 = self.classes.T1, self.tables.t1
- mapper(
+ self.mapper_registry.map_imperatively(
T1,
t1,
properties={
def test_m2o_explicit(self):
T1, t1 = self.classes.T1, self.tables.t1
- mapper(
+ self.mapper_registry.map_imperatively(
T1,
t1,
properties={
def test_ambiguous_fks_o2m(self):
A, B = self.classes.A, self.classes.B
a, b = self.tables.a, self.tables.b
- mapper(A, a, properties={"bs": relationship(B)})
- mapper(B, b)
+ self.mapper_registry.map_imperatively(
+ A, a, properties={"bs": relationship(B)}
+ )
+ self.mapper_registry.map_imperatively(B, b)
self._assert_raises_ambig_join(configure_mappers, "A.bs", None)
def test_with_fks_o2m(self):
A, B = self.classes.A, self.classes.B
a, b = self.tables.a, self.tables.b
- mapper(
+ self.mapper_registry.map_imperatively(
A, a, properties={"bs": relationship(B, foreign_keys=b.c.aid_1)}
)
- mapper(B, b)
+ self.mapper_registry.map_imperatively(B, b)
sa.orm.configure_mappers()
assert A.bs.property.primaryjoin.compare(a.c.id == b.c.aid_1)
eq_(A.bs.property._calculated_foreign_keys, set([b.c.aid_1]))
def test_with_pj_o2m(self):
A, B = self.classes.A, self.classes.B
a, b = self.tables.a, self.tables.b
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
properties={
"bs": relationship(B, primaryjoin=a.c.id == b.c.aid_1)
},
)
- mapper(B, b)
+ self.mapper_registry.map_imperatively(B, b)
sa.orm.configure_mappers()
assert A.bs.property.primaryjoin.compare(a.c.id == b.c.aid_1)
eq_(A.bs.property._calculated_foreign_keys, set([b.c.aid_1]))
def test_with_annotated_pj_o2m(self):
A, B = self.classes.A, self.classes.B
a, b = self.tables.a, self.tables.b
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
properties={
"bs": relationship(B, primaryjoin=a.c.id == foreign(b.c.aid_1))
},
)
- mapper(B, b)
+ self.mapper_registry.map_imperatively(B, b)
sa.orm.configure_mappers()
assert A.bs.property.primaryjoin.compare(a.c.id == b.c.aid_1)
eq_(A.bs.property._calculated_foreign_keys, set([b.c.aid_1]))
def test_no_fks_m2m(self):
A, B = self.classes.A, self.classes.B
a, b, a_to_b = self.tables.a, self.tables.b, self.tables.atob
- mapper(A, a, properties={"bs": relationship(B, secondary=a_to_b)})
- mapper(B, b)
+ self.mapper_registry.map_imperatively(
+ A, a, properties={"bs": relationship(B, secondary=a_to_b)}
+ )
+ self.mapper_registry.map_imperatively(B, b)
self._assert_raises_no_join(sa.orm.configure_mappers, "A.bs", a_to_b)
def test_ambiguous_fks_m2m(self):
A, B = self.classes.A, self.classes.B
a, b, a_to_b = self.tables.a, self.tables.b, self.tables.atob_ambiguous
- mapper(A, a, properties={"bs": relationship(B, secondary=a_to_b)})
- mapper(B, b)
+ self.mapper_registry.map_imperatively(
+ A, a, properties={"bs": relationship(B, secondary=a_to_b)}
+ )
+ self.mapper_registry.map_imperatively(B, b)
self._assert_raises_ambig_join(
configure_mappers, "A.bs", "atob_ambiguous"
def test_with_fks_m2m(self):
A, B = self.classes.A, self.classes.B
a, b, a_to_b = self.tables.a, self.tables.b, self.tables.atob_ambiguous
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
properties={
)
},
)
- mapper(B, b)
+ self.mapper_registry.map_imperatively(B, b)
sa.orm.configure_mappers()
j = sa.join(b, d, b.c.d_id == d.c.id).join(c, c.c.d_id == d.c.id)
# j = join(b, d, b.c.d_id == d.c.id).join(c, c.c.d_id == d.c.id) \
# .alias()
- mapper(
+ cls.mapper_registry.map_imperatively(
A,
a,
properties={
),
},
)
- mapper(B, b, properties={"d": relationship(D)})
- mapper(C, c, properties={"a": relationship(A), "d": relationship(D)})
- mapper(D, d)
+ cls.mapper_registry.map_imperatively(
+ B, b, properties={"d": relationship(D)}
+ )
+ cls.mapper_registry.map_imperatively(
+ C, c, properties={"a": relationship(A), "d": relationship(D)}
+ )
+ cls.mapper_registry.map_imperatively(D, d)
@classmethod
def insert_data(cls, connection):
self.tables.foos,
)
- mapper(Foo, foos, properties={"bars": relationship(Bar)})
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(
+ Foo, foos, properties={"bars": relationship(Bar)}
+ )
+ self.mapper_registry.map_imperatively(Bar, bars)
self._assert_raises_no_join(sa.orm.configure_mappers, "Foo.bars", None)
self.tables.foos,
)
- mapper(Foo, foos, properties={"foos": relationship(Foo)})
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(
+ Foo, foos, properties={"foos": relationship(Foo)}
+ )
+ self.mapper_registry.map_imperatively(Bar, bars)
self._assert_raises_no_join(configure_mappers, "Foo.foos", None)
self.tables.foos,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
"bars": relationship(Bar, primaryjoin=foos.c.id > bars.c.fid)
},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
self._assert_raises_no_relevant_fks(
configure_mappers, "foos.id > bars.fid", "Foo.bars", "primary"
self.tables.foos,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
)
},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
self._assert_raises_no_equality(
sa.orm.configure_mappers,
"foos.id > bars.fid",
# in this case we don't get eq_pairs, but we hit the
# "works if viewonly" rule. so here we add another clause regarding
# "try foreign keys".
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
)
},
)
- mapper(Bar, bars_with_fks)
+ self.mapper_registry.map_imperatively(Bar, bars_with_fks)
self._assert_raises_no_equality(
sa.orm.configure_mappers,
self.tables.foos,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
)
},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
self._assert_raises_ambiguous_direction(
sa.orm.configure_mappers, "Foo.bars"
self.tables.foos,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
)
},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
self._assert_raises_no_local_remote(configure_mappers, "Foo.bars")
self.tables.foos,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
)
},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
self._assert_raises_no_local_remote(configure_mappers, "Foo.bars")
self.tables.foos,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
"foos": relationship(Foo, primaryjoin=foos.c.id > foos.c.fid)
},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
self._assert_raises_no_relevant_fks(
configure_mappers, "foos.id > foos.fid", "Foo.foos", "primary"
self.tables.foos,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
)
},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
self._assert_raises_no_equality(
configure_mappers, "foos.id > foos.fid", "Foo.foos", "primary"
self.tables.foos,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
)
},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
self._assert_raises_no_relevant_fks(
sa.orm.configure_mappers,
"primary",
)
- sa.orm.clear_mappers()
- mapper(
+ self.mapper_registry.dispose()
+ self.mapper_registry.map_imperatively(
Foo,
foos_with_fks,
properties={
)
},
)
- mapper(Bar, bars_with_fks)
+ self.mapper_registry.map_imperatively(Bar, bars_with_fks)
sa.orm.configure_mappers()
def test_no_equated_self_ref_viewonly(self):
self.tables.foos,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
)
},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
self._assert_raises_no_relevant_fks(
sa.orm.configure_mappers,
"primary",
)
- sa.orm.clear_mappers()
- mapper(
+ self.mapper_registry.dispose()
+ self.mapper_registry.map_imperatively(
Foo,
foos_with_fks,
properties={
)
},
)
- mapper(Bar, bars_with_fks)
+ self.mapper_registry.map_imperatively(Bar, bars_with_fks)
sa.orm.configure_mappers()
def test_no_equated_self_ref_viewonly_fks(self):
Foo, foos = self.classes.Foo, self.tables.foos
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
self.tables.foos,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
"bars": relationship(Bar, primaryjoin=foos.c.id == bars.c.fid)
},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
self._assert_raises_no_relevant_fks(
configure_mappers, "foos.id = bars.fid", "Foo.bars", "primary"
)
- sa.orm.clear_mappers()
- mapper(
+ self.mapper_registry.dispose()
+
+ self.mapper_registry.map_imperatively(
Foo,
foos_with_fks,
properties={
)
},
)
- mapper(Bar, bars_with_fks)
+ self.mapper_registry.map_imperatively(Bar, bars_with_fks)
sa.orm.configure_mappers()
def test_equated_self_ref(self):
Foo, foos = self.classes.Foo, self.tables.foos
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
self.tables.foos,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
self.tables.foos,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={"bars": relationship(Bar, secondary=foobars)},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
self._assert_raises_no_join(configure_mappers, "Foo.bars", "foobars")
self.tables.foos,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
)
},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
self._assert_raises_no_join(configure_mappers, "Foo.bars", "foobars")
self.tables.foos,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
)
},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
sa.orm.configure_mappers()
eq_(Foo.bars.property.synchronize_pairs, [(foos.c.id, foobars.c.fid)])
eq_(
[(bars.c.id, foobars.c.bid)],
)
- sa.orm.clear_mappers()
- mapper(
+ self.mapper_registry.dispose()
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
)
},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
sa.orm.configure_mappers()
eq_(
Foo.bars.property.synchronize_pairs,
# ensure m2m backref is set up with correct annotations
# [ticket:2578]
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
)
},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
sa.orm.configure_mappers()
eq_(Foo.bars.property._join_condition.local_columns, set([foos.c.id]))
eq_(Bar.foos.property._join_condition.local_columns, set([bars.c.id]))
self.tables.foos,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
)
},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
self._assert_raises_no_equality(
configure_mappers, "foos.id > foobars.fid", "Foo.bars", "primary"
)
- sa.orm.clear_mappers()
- mapper(
+ self.mapper_registry.dispose()
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
)
},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
self._assert_raises_no_equality(
configure_mappers,
"foos.id > foobars_with_fks.fid",
"primary",
)
- sa.orm.clear_mappers()
- mapper(
+ self.mapper_registry.dispose()
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
)
},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
sa.orm.configure_mappers()
def test_bad_secondaryjoin(self):
self.tables.foos,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
)
},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
self._assert_raises_no_relevant_fks(
configure_mappers,
"foobars.bid <= bars.id",
self.tables.foos,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
foos,
properties={
)
},
)
- mapper(Bar, bars)
+ self.mapper_registry.map_imperatively(Bar, bars)
self._assert_raises_no_equality(
configure_mappers,
def test_column_property_flag(self):
User, users = self.classes.User, self.tables.users
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={"user": relationship(User, active_history=True)},
)
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
u1 = User(name="jack")
u2 = User(name="ed")
a1 = Address(email_address="a1", user=u1)
and other.description == self.description
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
opts["lazy"] = "raise"
opts["_legacy_inactive_history_style"] = legacy_inactive_history_style
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
"user": relationship(User, back_populates="addresses", **opts)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
self.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(addresses=relationship(Address, lazy="raise")),
self.classes.User,
)
- mapper(Address, addresses)
- mapper(User, users, properties=dict(addresses=relationship(Address)))
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties=dict(addresses=relationship(Address))
+ )
q = fixture_session().query(User)
result = [None]
self.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(addresses=relationship(Address, lazy="raise")),
self.tables.users,
self.classes.User,
)
- mapper(Address, addresses, properties={"user": relationship(User)})
- mapper(User, users)
+ self.mapper_registry.map_imperatively(
+ Address, addresses, properties={"user": relationship(User)}
+ )
+ self.mapper_registry.map_imperatively(User, users)
s = fixture_session()
a1 = (
s.query(Address)
self.tables.users,
self.classes.User,
)
- mapper(Address, addresses, properties={"user": relationship(User)})
- mapper(User, users)
+ self.mapper_registry.map_imperatively(
+ Address, addresses, properties={"user": relationship(User)}
+ )
+ self.mapper_registry.map_imperatively(User, users)
s = fixture_session()
a1 = (
s.query(Address)
self.tables.users,
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
)
},
)
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s = fixture_session()
u1 = s.query(User).first() # noqa
a1 = (
self.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(addresses=relationship(Address, backref="user")),
self.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(addresses=relationship(Address, backref="user")),
self.classes.Address,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users_table,
properties=dict(addresses=relationship(Address, backref="user")),
)
- mapper(Address, addresses_table)
+ self.mapper_registry.map_imperatively(Address, addresses_table)
session = fixture_session()
.alias()
)
- mapper(
+ cls.mapper_registry.map_imperatively(
A,
a,
properties=dict(
)
),
)
- mapper(B, b)
+ cls.mapper_registry.map_imperatively(B, b)
@classmethod
def insert_data(cls, connection):
from sqlalchemy import Integer
from sqlalchemy import String
from sqlalchemy import testing
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import query
from sqlalchemy.orm import relationship
from sqlalchemy.orm import scoped_session
query = Session.query_property()
custom_query = Session.query_property(query_cls=CustomQuery)
- mapper(
+ self.mapper_registry.map_imperatively(
SomeObject,
table1,
properties={"options": relationship(SomeOtherObject)},
)
- mapper(SomeOtherObject, table2)
+ self.mapper_registry.map_imperatively(SomeOtherObject, table2)
s = SomeObject(id=1, data="hello")
sso = SomeOtherObject()
from sqlalchemy import select
from sqlalchemy import String
from sqlalchemy import testing
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import Session
from sqlalchemy.testing import assert_raises
from sqlalchemy.testing import assert_raises_message
Subset = self.classes.Subset
selectable = select(column("x"), column("y"), column("z")).alias()
- mapper(Subset, selectable, primary_key=[selectable.c.x])
+ self.mapper_registry.map_imperatively(
+ Subset, selectable, primary_key=[selectable.c.x]
+ )
self.assert_compile(
fixture_session().query(Subset),
assert_raises_message(
sa.exc.ArgumentError,
"could not assemble any primary key columns",
- mapper,
+ self.mapper_registry.map_imperatively,
Subset,
selectable,
)
Subset, common = self.classes.Subset, self.tables.common
subset_select = select(common.c.id, common.c.data)
- assert_raises(sa.exc.ArgumentError, mapper, Subset, subset_select)
+ assert_raises(
+ sa.exc.ArgumentError,
+ self.mapper_registry.map_imperatively,
+ Subset,
+ subset_select,
+ )
def test_basic(self):
Subset, common = self.classes.Subset, self.tables.common
subset_select = select(common.c.id, common.c.data).alias()
- mapper(Subset, subset_select)
+ self.mapper_registry.map_imperatively(Subset, subset_select)
sess = Session(bind=testing.db)
sess.add(Subset(data=1))
sess.flush()
from sqlalchemy.orm import defer
from sqlalchemy.orm import deferred
from sqlalchemy.orm import joinedload
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import selectinload
from sqlalchemy.orm import Session
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses), order_by=Address.id
+ self.mapper_registry.map_imperatively(Address, addresses),
+ order_by=Address.id,
)
},
)
self.tables.addresses,
)
- mapper(Dingaling, dingalings)
- mapper(
+ self.mapper_registry.map_imperatively(Dingaling, dingalings)
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
"dingalings": relationship(Dingaling, order_by=Dingaling.id)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses), order_by=Address.id
+ self.mapper_registry.map_imperatively(Address, addresses),
+ order_by=Address.id,
)
},
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses), order_by=Address.id
+ self.mapper_registry.map_imperatively(Address, addresses),
+ order_by=Address.id,
)
},
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, lazy="dynamic")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
# previously this would not raise, but would emit
self.classes.Item,
)
- mapper(Keyword, keywords)
- mapper(
+ self.mapper_registry.map_imperatively(Keyword, keywords)
+ self.mapper_registry.map_imperatively(
Item,
items,
properties=dict(
self.classes.Item,
)
- mapper(Keyword, keywords)
- mapper(
+ self.mapper_registry.map_imperatively(Keyword, keywords)
+ self.mapper_registry.map_imperatively(
Item,
items,
properties=dict(
self.classes.Item,
)
- mapper(Keyword, keywords)
- mapper(
+ self.mapper_registry.map_imperatively(Keyword, keywords)
+ self.mapper_registry.map_imperatively(
Item,
items,
properties=dict(
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
lazy="selectin",
order_by=addresses.c.email_address,
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
lazy="selectin",
order_by=[addresses.c.email_address, addresses.c.id],
)
self.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.tables.item_keywords,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"orders": relationship(Order, order_by=orders.c.id) # o2m, m2o
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
) # m2m
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Item,
items,
properties={
) # m2m
},
)
- mapper(Keyword, keywords)
+ self.mapper_registry.map_imperatively(Keyword, keywords)
callables = {
"joinedload": joinedload,
}
for o, i, k, count in configs:
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Item,
items,
properties={
)
},
)
- mapper(Keyword, keywords)
+ self.mapper_registry.map_imperatively(Keyword, keywords)
try:
self._do_query_tests([], count)
self.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.tables.order_items,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
open_mapper = aliased(
Order, select(orders).where(orders.c.isopen == 1).alias()
Order, select(orders).where(orders.c.isopen == 0).alias()
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.tables.order_items,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
open_mapper = aliased(Order, orders)
closed_mapper = aliased(Order, orders)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.tables.users,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(Item, items)
- mapper(
+ self.mapper_registry.map_imperatively(Item, items)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
elif type_ == "subquery":
target = select(users).subquery()
- mapper(
+ self.mapper_registry.map_imperatively(
User,
target,
properties={"addresses": relationship(Address, backref="user")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
self.tables.addresses,
)
- mapper(Item, items)
- mapper(
+ self.mapper_registry.map_imperatively(Item, items)
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
lazy="selectin",
order_by=addresses.c.id,
),
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
address=relationship(
- mapper(Address, addresses), lazy="selectin", uselist=False
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="selectin",
+ uselist=False,
)
),
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
address=relationship(
- mapper(Address, addresses), lazy="selectin", uselist=False
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="selectin",
+ uselist=False,
)
),
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties=dict(
- user=relationship(mapper(User, users), lazy="selectin")
+ user=relationship(
+ self.mapper_registry.map_imperatively(User, users),
+ lazy="selectin",
+ )
),
)
sess = fixture_session()
self.classes.Address,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={"address": relationship(Address, lazy="selectin")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session(autoflush=False)
q = sess.query(Order).filter(Order.id.in_([4, 5])).order_by(Order.id)
self.classes.Address,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
"address": relationship(Address, lazy="selectin", uselist=True)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
q = sess.query(Order).filter(Order.id.in_([4, 5])).order_by(Order.id)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
addresses=relationship(
- mapper(Address, addresses), lazy="selectin"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="selectin",
)
),
)
.alias("max_orders")
)
- mapper(Order, orders)
- mapper(
+ self.mapper_registry.map_imperatively(Order, orders)
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
self.classes.Order,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"order": relationship(Order, uselist=False)},
)
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(Order, orders)
s = fixture_session()
assert_raises(
sa.exc.SAWarning,
self.classes.Address,
self.classes.Dingaling,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
self.tables.users,
properties={"addresses": relationship(Address)},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
self.tables.addresses,
properties={"dingaling": relationship(Dingaling)},
)
- mapper(Dingaling, self.tables.dingalings)
+ self.mapper_registry.map_imperatively(
+ Dingaling, self.tables.dingalings
+ )
sess = fixture_session(autoflush=False)
return User, Address, Dingaling, sess
self.classes.Order,
self.classes.Item,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User, self.tables.users, properties={"orders": relationship(Order)}
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
self.tables.orders,
properties={
"items": relationship(Item, secondary=self.tables.order_items)
},
)
- mapper(Item, self.tables.items)
+ self.mapper_registry.map_imperatively(Item, self.tables.items)
sess = fixture_session(autoflush=False)
return User, Order, Item, sess
def _eager_config_fixture(self, default_lazy="selectin"):
User, Address = self.classes.User, self.classes.Address
- mapper(
+ self.mapper_registry.map_imperatively(
User,
self.tables.users,
properties={"addresses": relationship(Address, lazy=default_lazy)},
)
- mapper(Address, self.tables.addresses)
+ self.mapper_registry.map_imperatively(Address, self.tables.addresses)
sess = fixture_session(autoflush=False)
return User, Address, sess
def _deferred_config_fixture(self):
User, Address = self.classes.User, self.classes.Address
- mapper(
+ self.mapper_registry.map_imperatively(
User,
self.tables.users,
properties={
"addresses": relationship(Address, lazy="selectin"),
},
)
- mapper(Address, self.tables.addresses)
+ self.mapper_registry.map_imperatively(Address, self.tables.addresses)
sess = fixture_session(autoflush=False)
return User, Address, sess
class B(fixtures.ComparableEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
properties={
)
},
)
- mapper(B, b)
+ self.mapper_registry.map_imperatively(B, b)
sess = fixture_session()
engineers = cls.tables.engineers
paperwork = cls.tables.paperwork
- mapper(
+ cls.mapper_registry.map_imperatively(
Person,
people,
polymorphic_on=people.c.type,
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Engineer,
engineers,
inherits=Person,
polymorphic_identity="engineer",
)
- mapper(Paperwork, paperwork)
+ cls.mapper_registry.map_imperatively(Paperwork, paperwork)
@classmethod
def insert_data(cls, connection):
machines = cls.tables.machines
machine_type = cls.tables.machine_type
- mapper(
+ cls.mapper_registry.map_imperatively(
Company,
companies,
properties={
"employees": relationship(Person, order_by=people.c.person_id)
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Person,
people,
polymorphic_on=people.c.type,
with_polymorphic="*",
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Engineer,
engineers,
inherits=Person,
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Machine, machines, properties={"type": relationship(MachineType)}
)
- mapper(MachineType, machine_type)
+ cls.mapper_registry.map_imperatively(MachineType, machine_type)
@classmethod
def insert_data(cls, connection):
def append(self, node):
self.children.append(node)
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={
def append(self, node):
self.children.append(node)
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={
def append(self, node):
self.children.append(node)
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={
def append(self, node):
self.children.append(node)
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={"children": relationship(Node, order_by=nodes.c.id)},
def append(self, node):
self.children.append(node)
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={"children": relationship(Node, lazy="selectin")},
from sqlalchemy.orm import joinedload
from sqlalchemy.orm import make_transient
from sqlalchemy.orm import make_transient_to_detached
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import object_session
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
c = testing.db.connect()
c.exec_driver_sql("select * from users")
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s = Session(bind=c)
s.add(User(name="first"))
s.flush()
c = testing.db.connect()
c.exec_driver_sql("select * from users")
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s = Session(bind=c)
s.add(User(name="first"))
s.flush()
# test the new autobegin behavior introduced in #5074
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s = Session(testing.db)
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s.add(User(name="u1"))
s.commit()
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
u1 = User(name="u1")
s.add(u1)
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s = Session(
testing.db,
def test_transaction(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
conn1 = testing.db.connect()
conn2 = testing.db.connect()
def test_close_all_sessions(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s1 = fixture_session()
u1 = User()
def test_session_close_all_deprecated(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s1 = fixture_session()
u1 = User()
def test_make_transient(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session(autoflush=False)
sess.add(User(name="test"))
sess.flush()
# test for [ticket:2182]
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u1 = User(name="test")
sess.add(u1)
def test_make_transient_to_detached(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u1 = User(id=1, name="test")
sess.add(u1)
def test_make_transient_to_detached_no_session_allowed(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u1 = User(id=1, name="test")
sess.add(u1)
def test_make_transient_to_detached_no_key_allowed(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u1 = User(id=1, name="test")
sess.add(u1)
User, users = self.classes.User, self.tables.users
bind = testing.db
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
conn1 = bind.connect()
conn2 = bind.connect()
def test_with_no_autoflush(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u = User()
def test_autoflush_exception_addition(self):
User, users = self.classes.User, self.tables.users
Address, addresses = self.classes.Address, self.tables.addresses
- mapper(User, users, properties={"addresses": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
s = Session(testing.db)
def test_deleted_flag(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
def test_deleted_adds_to_imap_unconditionally(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u1 = User(name="u1")
def test_autoflush_unbound(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
with fixture_session(autocommit=False, autoflush=True) as sess:
u = User()
u.name = "ed"
def test_autoflush_2(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
conn1 = testing.db.connect()
sess = Session(bind=conn1, autocommit=False, autoflush=True)
u = User()
def test_autocommit_doesnt_raise_on_pending(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
session = Session(testing.db, autocommit=True)
session.add(User(name="ed"))
)
s = fixture_session()
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(Address, cascade="all, delete")
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
user = User(name="u1")
def test_already_attached(self):
User = self.classes.User
users = self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s1 = fixture_session()
s2 = fixture_session()
def test_identity_conflict(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
with fixture_session() as s:
s.execute(users.delete())
users, User = self.tables.users, self.classes.User
addresses, Address = self.tables.addresses, self.classes.Address
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
session = fixture_session()
def test_pickled_update(self):
users, User = self.tables.users, pickleable.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess1 = fixture_session()
sess2 = fixture_session()
u1 = User(name="u1")
def test_duplicate_update(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
Session = sessionmaker()
sess = fixture_session()
sess.add(self)
Foo.__init__(self)
- mapper(Foo, users)
- mapper(Bar, users)
+ self.mapper_registry.map_imperatively(Foo, users)
+ self.mapper_registry.map_imperatively(Bar, users)
b = Bar()
assert b in sess
def test_identity_map_mutate(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
def _test_extra_dirty_state(self):
users, User = self.tables.users, self.classes.User
- m = mapper(User, users)
+ m = self.mapper_registry.map_imperatively(User, users)
s = fixture_session()
def test_deleted_auto_expunged(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
sess.add(User(name="x"))
sess.commit()
def test_explicit_expunge_pending(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u1 = User(name="x")
sess.add(u1)
def test_explicit_expunge_deleted(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
sess.add(User(name="x"))
sess.commit()
cls.classes.User,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
)
- mapper(Address, addresses)
+ cls.mapper_registry.map_imperatively(Address, addresses)
def test_deferred_expression_unflushed(self):
"""test that an expression which is dependent on object state is
self.classes.User,
)
- mapper(Address, addresses)
- mapper(User, users, properties={"addresses": relationship(Address)})
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
sess = fixture_session(autocommit=False, autoflush=True)
u = sess.query(User).get(8)
self.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
run_inserts = None
def setup_test(self):
- mapper(self.classes.User, self.tables.users)
+ self.mapper_registry.map_imperatively(
+ self.classes.User, self.tables.users
+ )
def _assert_modified(self, u1):
assert sa.orm.attributes.instance_state(u1).modified
users, User = self.tables.users, self.classes.User
s = fixture_session()
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s.add(User(name="ed"))
s.flush()
users, User = self.tables.users, pickleable.User
s = fixture_session()
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s.add(User(name="ed"))
s.flush()
)
s = fixture_session()
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
s.add(User(name="ed", addresses=[Address(email_address="ed1")]))
s.commit()
)
s = fixture_session()
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"address": relationship(Address, backref="user", uselist=False)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
s.add(User(name="ed", address=Address(email_address="ed1")))
s.commit()
def test_auto_detach_on_gc_session(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = Session(testing.db)
# test issue #4068
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
def _default_mapping_fixture(self):
User, Address = self.classes.User, self.classes.Address
users, addresses = self.tables.users, self.tables.addresses
- mapper(User, users, properties={"addresses": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
return User, Address
def test_is_modified(self):
s = fixture_session()
- mapper(User, users, properties={"uname": sa.orm.synonym("name")})
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"uname": sa.orm.synonym("name")}
+ )
u = User(uname="fred")
assert s.is_modified(u)
s.add(u)
)
@classmethod
- def setup_classes(cls):
+ def setup_mappers(cls):
class T(cls.Basic):
def __init__(self, data):
self.data = data
- mapper(T, cls.tables.t1)
+ cls.mapper_registry.map_imperatively(T, cls.tables.t1)
def teardown_test(self):
from sqlalchemy.orm.session import _sessions
sess.rollback()
-class SessionInterface(fixtures.TestBase):
+class SessionInterface(fixtures.MappedTest):
"""Bogus args to Session methods produce actionable exceptions."""
_class_methods = set(
return ok
def _map_it(self, cls):
- return mapper(
+ self.mapper_registry.dispose()
+ return self.mapper_registry.map_imperatively(
cls,
Table(
"t",
def setup_mappers(cls):
user, User = cls.tables.user, cls.classes.User
address, Address = cls.tables.address, cls.classes.Address
- mapper(
+ cls.mapper_registry.map_imperatively(
User,
user,
properties={"addresses": relationship(Address, backref="user")},
)
- mapper(Address, address)
+ cls.mapper_registry.map_imperatively(Address, address)
def test_o2m_cascade_add(self):
Address = self.classes.Address
from sqlalchemy.orm import defer
from sqlalchemy.orm import deferred
from sqlalchemy.orm import joinedload
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import selectinload
from sqlalchemy.orm import Session
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses), order_by=Address.id
+ self.mapper_registry.map_imperatively(Address, addresses),
+ order_by=Address.id,
)
},
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
lazy="subquery",
order_by=Address.id,
)
self.tables.addresses,
)
- mapper(Dingaling, dingalings)
- mapper(
+ self.mapper_registry.map_imperatively(Dingaling, dingalings)
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={
"dingalings": relationship(Dingaling, order_by=Dingaling.id)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses), order_by=Address.id
+ self.mapper_registry.map_imperatively(Address, addresses),
+ order_by=Address.id,
)
},
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses), order_by=Address.id
+ self.mapper_registry.map_imperatively(Address, addresses),
+ order_by=Address.id,
)
},
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, lazy="dynamic")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
# previously this would not raise, but would emit
self.classes.Item,
)
- mapper(Keyword, keywords)
- mapper(
+ self.mapper_registry.map_imperatively(Keyword, keywords)
+ self.mapper_registry.map_imperatively(
Item,
items,
properties=dict(
self.classes.Item,
)
- mapper(Keyword, keywords)
- mapper(
+ self.mapper_registry.map_imperatively(Keyword, keywords)
+ self.mapper_registry.map_imperatively(
Item,
items,
properties=dict(
self.classes.Item,
)
- mapper(Keyword, keywords)
- mapper(
+ self.mapper_registry.map_imperatively(Keyword, keywords)
+ self.mapper_registry.map_imperatively(
Item,
items,
properties=dict(
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
lazy="subquery",
order_by=addresses.c.email_address,
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
lazy="subquery",
order_by=[addresses.c.email_address, addresses.c.id],
)
self.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.tables.item_keywords,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"orders": relationship(Order, order_by=orders.c.id) # o2m, m2o
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
) # m2m
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Item,
items,
properties={
) # m2m
},
)
- mapper(Keyword, keywords)
+ self.mapper_registry.map_imperatively(Keyword, keywords)
callables = {"joinedload": joinedload, "subqueryload": subqueryload}
}
for o, i, k, count in configs:
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Item,
items,
properties={
)
},
)
- mapper(Keyword, keywords)
+ self.mapper_registry.map_imperatively(Keyword, keywords)
try:
self._do_query_tests([], count)
self.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.classes.User,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(addresses=relationship(Address, lazy="subquery")),
self.tables.order_items,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
open_mapper = aliased(
Order, select(orders).where(orders.c.isopen == 1).alias()
Order, select(orders).where(orders.c.isopen == 0).alias()
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.tables.order_items,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(Item, items)
+ self.mapper_registry.map_imperatively(Item, items)
open_mapper = aliased(Order, orders)
closed_mapper = aliased(Order, orders)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
self.tables.users,
)
- mapper(Address, addresses)
- mapper(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(Item, items)
- mapper(
+ self.mapper_registry.map_imperatively(Item, items)
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
elif type_ == "subquery":
target = select(users).subquery()
- mapper(
+ self.mapper_registry.map_imperatively(
User,
target,
properties={"addresses": relationship(Address, backref="user")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
self.tables.addresses,
)
- mapper(Item, items)
- mapper(
+ self.mapper_registry.map_imperatively(Item, items)
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={
)
},
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
lazy="subquery",
order_by=addresses.c.id,
),
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(
- mapper(Address, addresses),
+ self.mapper_registry.map_imperatively(Address, addresses),
lazy="subquery",
order_by=addresses.c.email_address,
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
address=relationship(
- mapper(Address, addresses), lazy="subquery", uselist=False
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="subquery",
+ uselist=False,
)
),
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties=dict(
- user=relationship(mapper(User, users), lazy="subquery")
+ user=relationship(
+ self.mapper_registry.map_imperatively(User, users),
+ lazy="subquery",
+ )
),
)
sess = fixture_session()
.alias("max_orders")
)
- mapper(Order, orders)
- mapper(
+ self.mapper_registry.map_imperatively(Order, orders)
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
self.classes.Order,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"order": relationship(Order, uselist=False)},
)
- mapper(Order, orders)
+ self.mapper_registry.map_imperatively(Order, orders)
s = fixture_session()
assert_raises(
sa.exc.SAWarning,
self.classes.Address,
self.classes.Dingaling,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
self.tables.users,
properties={"addresses": relationship(Address)},
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
self.tables.addresses,
properties={"dingaling": relationship(Dingaling)},
)
- mapper(Dingaling, self.tables.dingalings)
+ self.mapper_registry.map_imperatively(
+ Dingaling, self.tables.dingalings
+ )
sess = fixture_session(autoflush=False)
return User, Address, Dingaling, sess
self.classes.Order,
self.classes.Item,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User, self.tables.users, properties={"orders": relationship(Order)}
)
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
self.tables.orders,
properties={
"items": relationship(Item, secondary=self.tables.order_items)
},
)
- mapper(Item, self.tables.items)
+ self.mapper_registry.map_imperatively(Item, self.tables.items)
sess = fixture_session(autoflush=False)
return User, Order, Item, sess
def _eager_config_fixture(self, default_lazy="subquery"):
User, Address = self.classes.User, self.classes.Address
- mapper(
+ self.mapper_registry.map_imperatively(
User,
self.tables.users,
properties={"addresses": relationship(Address, lazy=default_lazy)},
)
- mapper(Address, self.tables.addresses)
+ self.mapper_registry.map_imperatively(Address, self.tables.addresses)
sess = fixture_session(autoflush=False)
return User, Address, sess
def _deferred_config_fixture(self):
User, Address = self.classes.User, self.classes.Address
- mapper(
+ self.mapper_registry.map_imperatively(
User,
self.tables.users,
properties={
"addresses": relationship(Address, lazy="subquery"),
},
)
- mapper(Address, self.tables.addresses)
+ self.mapper_registry.map_imperatively(Address, self.tables.addresses)
sess = fixture_session(autoflush=False)
return User, Address, sess
class B(fixtures.ComparableEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
properties={
)
},
)
- mapper(B, b)
+ self.mapper_registry.map_imperatively(B, b)
sess = fixture_session()
paperwork = cls.tables.paperwork
pages = cls.tables.pages
- mapper(
+ cls.mapper_registry.map_imperatively(
Person,
people,
polymorphic_on=people.c.type,
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Engineer,
engineers,
inherits=Person,
polymorphic_identity="engineer",
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Paperwork,
paperwork,
properties={"pages": relationship(Page, order_by=pages.c.page_id)},
)
- mapper(Page, pages)
+ cls.mapper_registry.map_imperatively(Page, pages)
@classmethod
def insert_data(cls, connection):
machines = cls.tables.machines
machine_type = cls.tables.machine_type
- mapper(
+ cls.mapper_registry.map_imperatively(
Company,
companies,
properties={
"employees": relationship(Person, order_by=people.c.person_id)
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Person,
people,
polymorphic_on=people.c.type,
with_polymorphic="*",
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Engineer,
engineers,
inherits=Person,
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
Machine, machines, properties={"type": relationship(MachineType)}
)
- mapper(MachineType, machine_type)
+ cls.mapper_registry.map_imperatively(MachineType, machine_type)
@classmethod
def insert_data(cls, connection):
def append(self, node):
self.children.append(node)
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={
def append(self, node):
self.children.append(node)
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={
def append(self, node):
self.children.append(node)
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={
def append(self, node):
self.children.append(node)
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={"children": relationship(Node, order_by=nodes.c.id)},
def append(self, node):
self.children.append(node)
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={"children": relationship(Node, lazy="subquery")},
@classmethod
def setup_mappers(cls):
- mapper(
+ cls.mapper_registry.map_imperatively(
cls.classes.Foo,
cls.tables.foo,
properties={"related": relationship(cls.classes.Related)},
polymorphic_on=cls.tables.foo.c.type,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
cls.classes.Bar,
cls.tables.bar,
polymorphic_identity="bar",
inherits=cls.classes.Foo,
)
- mapper(
+ cls.mapper_registry.map_imperatively(
cls.classes.Baz,
cls.tables.baz,
polymorphic_identity="baz",
inherits=cls.classes.Foo,
)
- mapper(cls.classes.Related, cls.tables.related)
+ cls.mapper_registry.map_imperatively(
+ cls.classes.Related, cls.tables.related
+ )
def test_caches_query_per_base_subq(self):
Foo, Bar, Baz, Related = (
class SubT2(T2):
pass
- mapper(T, t1, polymorphic_on=t1.c.type, polymorphic_identity="t1")
- mapper(
+ self.mapper_registry.map_imperatively(
+ T, t1, polymorphic_on=t1.c.type, polymorphic_identity="t1"
+ )
+ self.mapper_registry.map_imperatively(
SubT,
None,
inherits=T,
)
},
)
- mapper(T2, t2, polymorphic_on=t2.c.type, polymorphic_identity="t2")
- mapper(SubT2, None, inherits=T2, polymorphic_identity="subt2")
+ self.mapper_registry.map_imperatively(
+ T2, t2, polymorphic_on=t2.c.type, polymorphic_identity="t2"
+ )
+ self.mapper_registry.map_imperatively(
+ SubT2, None, inherits=T2, polymorphic_identity="subt2"
+ )
# testing a particular endless loop condition in eager load setup
fixture_session().query(SubT).all()
from sqlalchemy.orm import attributes
from sqlalchemy.orm import class_mapper
from sqlalchemy.orm import exc as orm_exc
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import sync
from sqlalchemy.orm import unitofwork
from sqlalchemy.testing import assert_raises_message
@classmethod
def setup_mappers(cls):
- mapper(cls.classes.A, cls.tables.t1)
- mapper(cls.classes.B, cls.tables.t2)
+ cls.mapper_registry.map_imperatively(cls.classes.A, cls.tables.t1)
+ cls.mapper_registry.map_imperatively(cls.classes.B, cls.tables.t2)
def _fixture(self):
A, B = self.classes.A, self.classes.B
from sqlalchemy import text
from sqlalchemy.future import Engine
from sqlalchemy.orm import attributes
+from sqlalchemy.orm import clear_mappers
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 session as _session
User, users = self.classes.User, self.tables.users
c = conn
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s = Session(bind=c)
s.begin()
tran = s._legacy_transaction()
def test_subtransaction_on_external_subtrans(self, conn):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
trans = conn.begin()
sess = Session(bind=conn, autocommit=False, autoflush=True)
def test_subtransaction_on_external_no_begin(self, conn):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
trans = conn.begin()
sess = Session(bind=conn, autocommit=False, autoflush=True)
u = User(name="ed")
def test_external_nested_transaction(self, conn):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
trans = conn.begin()
sess = Session(bind=conn, autocommit=False, autoflush=True)
u1 = User(name="u1")
def test_subtransaction_on_external_commit_future(self, future_conn):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
conn = future_conn
conn.begin()
def test_subtransaction_on_external_rollback_future(self, future_conn):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
conn = future_conn
conn.begin()
def test_savepoint_on_external_future(self, future_conn):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
conn = future_conn
conn.begin()
def test_nested_accounting_new_items_removed(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
session = fixture_session()
session.begin()
def test_nested_accounting_deleted_items_restored(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
session = fixture_session()
session.begin()
def test_dirty_state_transferred_deep_nesting(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
with fixture_session() as s:
u1 = User(name="u1")
def test_dirty_state_transferred_deep_nesting_future(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
with fixture_session(future=True) as s:
u1 = User(name="u1")
def test_transactions_isolated(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s1 = fixture_session(autocommit=False)
s2 = fixture_session(autocommit=False)
# TODO: mock up a failure condition here
# to ensure a rollback succeeds
- mapper(User, users)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(Address, addresses)
engine2 = engines.testing_engine()
sess = fixture_session(autocommit=True, autoflush=False, twophase=True)
@testing.requires.independent_connections
def test_invalidate(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u = User(name="u1")
sess.add(u)
def test_subtransaction_on_noautocommit(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session(autocommit=False, autoflush=True)
sess.begin(subtransactions=True)
u = User(name="u1")
def test_nested_transaction(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
sess.begin()
def test_nested_autotrans(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session(autocommit=False)
u = User(name="u1")
sess.add(u)
def test_nested_autotrans_future(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session(autocommit=False, future=True)
u = User(name="u1")
sess.add(u)
def test_nested_transaction_connection_add(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session(autocommit=True)
def test_mixed_transaction_control(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session(autocommit=True)
def test_mixed_transaction_close(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session(autocommit=False)
we're in commit()"""
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
to_flush = [User(name="ed"), User(name="jack"), User(name="wendy")]
def test_continue_flushing_guard(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
@event.listens_for(sess, "after_flush_postexec")
def test_error_on_using_inactive_session_commands(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session(autocommit=True)
sess.begin()
sess.begin(subtransactions=True)
# test #4050
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
session = Session(bind=testing.db)
rollback_error = testing.db.dialect.dbapi.InterfaceError(
def _inactive_flushed_session_fixture(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u1 = User(id=1, name="u1")
sess.add(u1)
def test_warning_on_using_inactive_session_rollback_evt(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u1 = User(id=1, name="u1")
sess.add(u1)
def test_no_autocommit_with_explicit_commit(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
session = fixture_session(autocommit=False)
session.add(User(name="ed"))
session._legacy_transaction().commit()
def test_no_autocommit_with_explicit_commit_future(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
session = fixture_session(autocommit=False, future=True)
session.add(User(name="ed"))
session._legacy_transaction().commit()
def test_report_primary_error_when_rollback_fails(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
with fixture_session() as session:
def setup_mappers(cls):
User, Address = cls.classes.User, cls.classes.Address
users, addresses = cls.tables.users, cls.tables.addresses
- mapper(
+ cls.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ cls.mapper_registry.map_imperatively(Address, addresses)
def subtransaction_recipe_one(self):
):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
with testing.db.connect() as conn:
trans = conn.begin()
sess = Session(conn, future=self.future)
def test_recipe_commit_one(self, subtransaction_recipe):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
with fixture_session(future=self.future) as sess:
with subtransaction_recipe(sess):
u = User(name="u1")
):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
with fixture_session(future=self.future) as sess:
sess.begin()
with subtransaction_recipe(sess):
def test_recipe_mixed_transaction_control(self, subtransaction_recipe):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
with fixture_session(future=self.future) as sess:
):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
with fixture_session(future=self.future) as sess:
sess.begin()
def _run_test(self, update_fn, future=False):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
with fixture_session(future=future) as s:
u1 = User(name="u1")
def test_contextmanager_nested_rollback(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
def test_contextmanager_commit(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
with sess.begin():
def test_contextmanager_rollback(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
session = fixture_session(
future=future, expire_on_commit=expire_on_commit
def test_rollback_recover(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
session = fixture_session()
"""test issue #3677"""
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
u1 = User(name="u1")
def test_key_replaced_by_update(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
u1 = User(name="u1")
u2 = User(name="u2")
def test_key_replaced_by_update_nested(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
u1 = User(name="u1")
def test_multiple_key_replaced_by_update(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
u1 = User(name="u1")
u2 = User(name="u2")
def test_key_replaced_by_oob_insert(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
u1 = User(name="u1")
self.connection.close()
- def test_something(self):
+ def test_something(self, connection):
A = self.A
a1 = A()
class A(object):
pass
- mapper(A, self.table)
+ clear_mappers()
+ self.mapper_registry.map_imperatively(A, self.table)
self.A = A
# bind an individual Session to the connection
class FutureJoinIntoAnExternalTransactionTest(
NewStyleJoinIntoAnExternalTransactionTest,
fixtures.FutureEngineMixin,
- fixtures.TestBase,
+ fixtures.MappedTest,
):
pass
class NonFutureJoinIntoAnExternalTransactionTest(
NewStyleJoinIntoAnExternalTransactionTest,
- fixtures.TestBase,
+ fixtures.MappedTest,
):
pass
class LegacyJoinIntoAnExternalTransactionTest(
JoinIntoAnExternalTransactionFixture,
- fixtures.TestBase,
+ fixtures.MappedTest,
):
def setup_session(self):
# begin a non-ORM transaction
class A(object):
pass
- mapper(A, self.table)
+ # TODO: py2 is not hitting this correctly for some reason,
+ # some mro issue
+ self.mapper_registry.map_imperatively(A, self.table)
self.A = A
# bind an individual Session to the connection
class A(object):
pass
- mapper(A, self.table)
+ self.mapper_registry.map_imperatively(A, self.table)
self.A = A
# neutron is doing this inside of a migration
from sqlalchemy.inspection import inspect
from sqlalchemy.orm import column_property
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.persistence import _sort_states
self.classes.User,
)
- am = mapper(Address, addresses)
- m = mapper(
+ am = self.mapper_registry.map_imperatively(Address, addresses)
+ m = self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
def test_basic(self):
Test, uni_t1 = self.classes.Test, self.tables.uni_t1
- mapper(Test, uni_t1)
+ self.mapper_registry.map_imperatively(Test, uni_t1)
txt = ue("\u0160\u0110\u0106\u010c\u017d")
t1 = Test(id=1, txt=txt)
self.classes.Test2,
)
- mapper(Test, uni_t1, properties={"t2s": relationship(Test2)})
- mapper(Test2, uni_t2)
+ self.mapper_registry.map_imperatively(
+ Test, uni_t1, properties={"t2s": relationship(Test2)}
+ )
+ self.mapper_registry.map_imperatively(Test2, uni_t2)
txt = ue("\u0160\u0110\u0106\u010c\u017d")
t1 = Test(txt=txt)
class B(fixtures.ComparableEntity):
pass
- mapper(A, t1, properties={"t2s": relationship(B)})
- mapper(B, t2)
+ self.mapper_registry.map_imperatively(
+ A, t1, properties={"t2s": relationship(B)}
+ )
+ self.mapper_registry.map_imperatively(B, t2)
a1 = A()
b1 = B()
class B(A):
pass
- mapper(A, t1, polymorphic_on=t1.c.type, polymorphic_identity="a")
- mapper(B, t2, inherits=A, polymorphic_identity="b")
+ self.mapper_registry.map_imperatively(
+ A, t1, polymorphic_on=t1.c.type, polymorphic_identity="a"
+ )
+ self.mapper_registry.map_imperatively(
+ B, t2, inherits=A, polymorphic_identity="b"
+ )
a1 = A(b=5)
b1 = B(e=7)
# data = b("this is some data")
data = b"m\x18" # m\xf2\r\n\x7f\x10'
- mapper(Foo, t1)
+ self.mapper_registry.map_imperatively(Foo, t1)
s = fixture_session()
def test_primary_key(self):
Entry, multipk1 = self.classes.Entry, self.tables.multipk1
- mapper(Entry, multipk1)
+ self.mapper_registry.map_imperatively(Entry, multipk1)
e = Entry(name="entry1", value="this is entry 1", multi_rev=2)
def test_manual_pk(self):
Entry, multipk2 = self.classes.Entry, self.tables.multipk2
- mapper(Entry, multipk2)
+ self.mapper_registry.map_imperatively(Entry, multipk2)
e = Entry(pk_col_1="pk1", pk_col_2="pk1_related", data="im the data")
def test_key_pks(self):
Entry, multipk3 = self.classes.Entry, self.tables.multipk3
- mapper(Entry, multipk3)
+ self.mapper_registry.map_imperatively(Entry, multipk3)
e = Entry(
primary="pk1",
self.tables.people,
)
- mapper(PersonSite, peoplesites)
- m2 = mapper(
+ self.mapper_registry.map_imperatively(PersonSite, peoplesites)
+ m2 = self.mapper_registry.map_imperatively(
Person, people, properties={"sites": relationship(PersonSite)}
)
User, users_t = cls.classes.User, cls.tables.users_t
HasBoolean, boolean_t = cls.classes.HasBoolean, cls.tables.boolean_t
PkDefault, pk_t = cls.classes.PkDefault, cls.tables.pk_t
- mapper(User, users_t)
- mapper(HasBoolean, boolean_t)
- mapper(PkDefault, pk_t)
+ cls.mapper_registry.map_imperatively(User, users_t)
+ cls.mapper_registry.map_imperatively(HasBoolean, boolean_t)
+ cls.mapper_registry.map_imperatively(PkDefault, pk_t)
def test_update(self):
User = self.classes.User
self.tables.mytable,
)
- mapper(MyOtherClass, myothertable)
- mapper(
+ self.mapper_registry.map_imperatively(MyOtherClass, myothertable)
+ self.mapper_registry.map_imperatively(
MyClass,
mytable,
properties={
self.tables.mytable,
)
- mapper(
+ self.mapper_registry.map_imperatively(
MyOtherClass,
myothertable,
properties={
)
},
)
- mapper(MyClass, mytable)
+ self.mapper_registry.map_imperatively(MyClass, mytable)
session = fixture_session()
mc = MyClass()
self.tables.mytable,
)
- mapper(
+ self.mapper_registry.map_imperatively(
MyOtherClass,
myothertable,
properties={
)
},
)
- mapper(MyClass, mytable)
+ self.mapper_registry.map_imperatively(MyClass, mytable)
sa.orm.configure_mappers()
self.tables.mytable,
)
- mapper(MyOtherClass, myothertable)
- mapper(
+ self.mapper_registry.map_imperatively(MyOtherClass, myothertable)
+ self.mapper_registry.map_imperatively(
MyClass,
mytable,
properties={
self.tables.mytable,
)
- mapper(MyOtherClass, myothertable)
- mapper(
+ self.mapper_registry.map_imperatively(MyOtherClass, myothertable)
+ self.mapper_registry.map_imperatively(
MyClass,
mytable,
properties={
self.tables.mytable,
)
- mapper(MyOtherClass, myothertable)
- mapper(
+ self.mapper_registry.map_imperatively(MyOtherClass, myothertable)
+ self.mapper_registry.map_imperatively(
MyClass,
mytable,
properties={
self.tables.mytable,
)
- mapper(MyOtherClass, myothertable)
- mapper(
+ self.mapper_registry.map_imperatively(MyOtherClass, myothertable)
+ self.mapper_registry.map_imperatively(
MyClass,
mytable,
properties={
class Book(fixtures.ComparableEntity):
pass
- mapper(Book, book)
+ self.mapper_registry.map_imperatively(Book, book)
with fixture_session() as sess:
b1 = Book(book_id="abc", title="def")
self.classes.Hoho,
)
- mapper(Hoho, default_t)
+ self.mapper_registry.map_imperatively(Hoho, default_t)
h1 = Hoho(hoho=althohoval)
h2 = Hoho(counter=12)
)
Secondary = self.classes.Secondary
- mapper(
+ self.mapper_registry.map_imperatively(
Hoho,
default_t,
eager_defaults=True,
},
)
- mapper(Secondary, self.tables.secondary_table)
+ self.mapper_registry.map_imperatively(
+ Secondary, self.tables.secondary_table
+ )
h1 = Hoho()
session = fixture_session()
# populates from the FetchValues explicitly so there is no
# "post-update"
- mapper(Hoho, default_t)
+ self.mapper_registry.map_imperatively(Hoho, default_t)
h1 = Hoho(hoho="15", counter=15)
session = fixture_session()
def test_update(self):
default_t, Hoho = self.tables.default_t, self.classes.Hoho
- mapper(Hoho, default_t)
+ self.mapper_registry.map_imperatively(Hoho, default_t)
h1 = Hoho()
session = fixture_session()
self.classes.Secondary,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Hoho,
default_t,
properties={
)
},
)
- mapper(Secondary, secondary_table)
+ self.mapper_registry.map_imperatively(Secondary, secondary_table)
h1 = Hoho()
s1 = Secondary(data="s1")
def test_refreshes(self):
Data, data = self.classes.Data, self.tables.data
- mapper(
+ self.mapper_registry.map_imperatively(
Data,
data,
properties={
def test_no_refresh_ro_column_property_no_expire_on_flush(self):
Data, data = self.classes.Data, self.tables.data
- mapper(
+ self.mapper_registry.map_imperatively(
Data,
data,
properties={
def test_no_refresh_ro_column_property_expire_on_flush(self):
Data, data = self.classes.Data, self.tables.data
- mapper(
+ self.mapper_registry.map_imperatively(
Data,
data,
properties={
def test_no_refresh_ro_deferred_no_expire_on_flush(self):
Data, data = self.classes.Data, self.tables.data
- mapper(
+ self.mapper_registry.map_imperatively(
Data,
data,
properties={
def test_no_refresh_ro_deferred_expire_on_flush(self):
Data, data = self.classes.Data, self.tables.data
- mapper(
+ self.mapper_registry.map_imperatively(
Data,
data,
properties={
def test_refreshes_post_init(self):
Data, data = self.classes.Data, self.tables.data
- m = mapper(Data, data)
+ m = self.mapper_registry.map_imperatively(Data, data)
m.add_property(
"aplusb",
column_property(data.c.a + literal_column("' '") + data.c.b),
class SubData(Data):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Data,
data,
properties={
)
},
)
- mapper(SubData, subdata, inherits=Data)
+ self.mapper_registry.map_imperatively(SubData, subdata, inherits=Data)
sess = fixture_session()
sd1 = SubData(a="hello", b="there", c="hi")
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
addresses=relationship(
- mapper(Address, addresses), lazy="select"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="select",
)
),
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
addresses=relationship(
- mapper(Address, addresses), lazy="select"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="select",
)
),
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
addresses=relationship(
- mapper(Address, addresses), lazy="select"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="select",
)
),
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
addresses=relationship(
- mapper(Address, addresses), lazy="select"
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="select",
)
),
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
address=relationship(
- mapper(Address, addresses), lazy="select", uselist=False
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="select",
+ uselist=False,
)
),
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties=dict(
address=relationship(
- mapper(Address, addresses), lazy="select", uselist=False
+ self.mapper_registry.map_imperatively(Address, addresses),
+ lazy="select",
+ uselist=False,
)
),
)
self.classes.User,
)
- m1 = mapper(User, users)
- mapper(
+ m1 = self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties=dict(
self.classes.User,
)
- m2 = mapper(Address, addresses)
- mapper(
+ m2 = self.mapper_registry.map_imperatively(Address, addresses)
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
def test_basic(self):
User, users = self.classes.User, self.tables.users
- m = mapper(User, users)
+ m = self.mapper_registry.map_imperatively(User, users)
# save two users
u = User(name="savetester")
syn_name = property(_get_name, _set_name)
- mapper(SUser, users, properties={"syn_name": sa.orm.synonym("name")})
+ self.mapper_registry.map_imperatively(
+ SUser, users, properties={"syn_name": sa.orm.synonym("name")}
+ )
u = SUser(syn_name="some name")
eq_(u.syn_name, "User:some name:User")
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
- properties={"addresses": relationship(mapper(Address, addresses))},
+ properties={
+ "addresses": relationship(
+ self.mapper_registry.map_imperatively(Address, addresses)
+ )
+ },
)
u = User(name="u1")
self.classes.User,
)
- m1 = mapper(User, users)
+ m1 = self.mapper_registry.map_imperatively(User, users)
class AddressUser(User):
pass
# define a mapper for AddressUser that inherits the User.mapper, and
# joins on the id column
- mapper(
+ self.mapper_registry.map_imperatively(
AddressUser,
addresses,
inherits=m1,
orders, Order = self.tables.orders, self.classes.Order
- mapper(
+ self.mapper_registry.map_imperatively(
Order,
orders,
properties={"description": sa.orm.deferred(orders.c.description)},
def test_dont_update_blanks(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
u = User(name="")
session = fixture_session()
users, addresses, users.c.id == addresses.c.user_id
)
- m = mapper(
+ m = self.mapper_registry.map_imperatively(
User,
usersaddresses,
properties=dict(
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
u = User(name="u1")
u.addresses.append(Address(email_address="u1@e1"))
def after_insert(self, mapper, connection, instance):
assert instance is self.current_instance
- mapper(User, users, batch=False)
+ self.mapper_registry.map_imperatively(User, users, batch=False)
evt = Events()
event.listen(User, "before_insert", evt.before_insert)
sa.orm.clear_mappers()
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
evt = Events()
event.listen(User, "before_insert", evt.before_insert)
event.listen(User, "after_insert", evt.after_insert)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties=dict(
user=relationship(
- mapper(User, users), lazy="select", uselist=False
+ self.mapper_registry.map_imperatively(User, users),
+ lazy="select",
+ uselist=False,
)
),
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties=dict(
- user=relationship(mapper(User, users), lazy="select")
+ user=relationship(
+ self.mapper_registry.map_imperatively(User, users),
+ lazy="select",
+ )
),
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties=dict(
- user=relationship(mapper(User, users), lazy="select")
+ user=relationship(
+ self.mapper_registry.map_imperatively(User, users),
+ lazy="select",
+ )
),
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties=dict(
- user=relationship(mapper(User, users), lazy="select")
+ user=relationship(
+ self.mapper_registry.map_imperatively(User, users),
+ lazy="select",
+ )
),
)
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
# try it on unsaved objects
u1 = User(name="u1")
self.classes.Item,
)
- mapper(Keyword, keywords)
+ self.mapper_registry.map_imperatively(Keyword, keywords)
- mapper(
+ self.mapper_registry.map_imperatively(
Item,
items,
properties=dict(
self.classes.Item,
)
- mapper(Keyword, keywords)
- mapper(
+ self.mapper_registry.map_imperatively(Keyword, keywords)
+ self.mapper_registry.map_imperatively(
Item,
items,
properties=dict(
self.classes.Item,
)
- mapper(Keyword, keywords)
+ self.mapper_registry.map_imperatively(Keyword, keywords)
- mapper(
+ self.mapper_registry.map_imperatively(
Item,
items,
properties=dict(
self.classes.Item,
)
- mapper(Keyword, keywords)
- mapper(
+ self.mapper_registry.map_imperatively(Keyword, keywords)
+ self.mapper_registry.map_imperatively(
Item,
items,
properties=dict(
class IKAssociation(fixtures.ComparableEntity):
pass
- mapper(Keyword, keywords)
+ self.mapper_registry.map_imperatively(Keyword, keywords)
- mapper(
+ self.mapper_registry.map_imperatively(
IKAssociation,
item_keywords,
primary_key=[item_keywords.c.item_id, item_keywords.c.keyword_id],
),
)
- mapper(
+ self.mapper_registry.map_imperatively(
Item,
items,
properties=dict(
self.classes.User,
)
- mapper(User, users)
- mapper(
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties=dict(
self.classes.Item,
)
- mapper(Keyword, keywords)
- mapper(
+ self.mapper_registry.map_imperatively(Keyword, keywords)
+ self.mapper_registry.map_imperatively(
Item,
items,
properties=dict(
class T(fixtures.ComparableEntity):
pass
- mapper(T, t1_t)
+ self.mapper_registry.map_imperatively(T, t1_t)
sess = fixture_session()
t1 = T(value=True, name="t1")
self.classes.T5,
)
- mapper(
+ self.mapper_registry.map_imperatively(
T5,
t5,
properties={"t6s": relationship(T6, cascade="all, delete-orphan")},
)
- mapper(T6, t6)
+ self.mapper_registry.map_imperatively(T6, t6)
sess = fixture_session()
self.classes.T7,
)
- mapper(
+ self.mapper_registry.map_imperatively(
T5,
t5,
properties={
"t7s": relationship(T7, secondary=t5t7, cascade="all")
},
)
- mapper(T7, t7)
+ self.mapper_registry.map_imperatively(T7, t7)
sess = fixture_session()
self.classes.T5,
)
- mapper(T6, t6, properties={"t5": relationship(T5)})
- mapper(T5, t5)
+ self.mapper_registry.map_imperatively(
+ T6, t6, properties={"t5": relationship(T5)}
+ )
+ self.mapper_registry.map_imperatively(T5, t5)
sess = fixture_session()
self.tables.child,
)
- mapper(P, parent)
- mapper(C, child, inherits=P)
+ self.mapper_registry.map_imperatively(P, parent)
+ self.mapper_registry.map_imperatively(C, child, inherits=P)
sess = fixture_session()
c1 = C(pid=1, cid=1, pdata="c1", cdata="c1")
@classmethod
def setup_mappers(cls):
- mapper(cls.classes.T1, cls.tables.t1)
+ cls.mapper_registry.map_imperatively(cls.classes.T1, cls.tables.t1)
def test_key_switch(self):
T1 = self.classes.T1
@classmethod
def setup_mappers(cls):
- mapper(cls.classes.T1, cls.tables.t1)
- mapper(cls.classes.T2, cls.tables.t2)
- mapper(cls.classes.T3, cls.tables.t3)
+ cls.mapper_registry.map_imperatively(cls.classes.T1, cls.tables.t1)
+ cls.mapper_registry.map_imperatively(cls.classes.T2, cls.tables.t2)
+ cls.mapper_registry.map_imperatively(cls.classes.T3, cls.tables.t3)
def test_exception_persistent_flush_py3k(self):
s = fixture_session()
from sqlalchemy.orm import clear_mappers
from sqlalchemy.orm import declarative_base
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 unitofwork
self.classes.User,
)
- mapper(User, users, properties={"addresses": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
a1, a2 = Address(email_address="a1"), Address(email_address="a2")
self.classes.User,
)
- mapper(User, users, properties={"addresses": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
a1, a2 = Address(email_address="a1"), Address(email_address="a2")
u1 = User(name="u1", addresses=[a1, a2])
self.classes.User,
)
- mapper(User, users, properties={"addresses": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
a1, a2 = Address(email_address="a1"), Address(email_address="a2")
u1 = User(name="u1", addresses=[a1, a2])
self.classes.User,
)
- mapper(User, users)
- mapper(Address, addresses, properties={"user": relationship(User)})
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
+ Address, addresses, properties={"user": relationship(User)}
+ )
sess = fixture_session()
u1 = User(name="u1")
self.classes.User,
)
- mapper(User, users)
- mapper(Address, addresses, properties={"user": relationship(User)})
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
+ Address, addresses, properties={"user": relationship(User)}
+ )
sess = fixture_session()
u1 = User(name="u1")
self.classes.User,
)
- mapper(User, users)
- mapper(Address, addresses, properties={"user": relationship(User)})
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
+ Address, addresses, properties={"user": relationship(User)}
+ )
sess = fixture_session()
u1 = User(name="u1")
self.classes.User,
)
- mapper(User, users)
- mapper(Address, addresses, properties={"parent": relationship(User)})
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
+ Address, addresses, properties={"parent": relationship(User)}
+ )
parent = User(name="p1")
c1, c2 = (
self.classes.User,
)
- mapper(User, users)
- mapper(Address, addresses, properties={"parent": relationship(User)})
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
+ Address, addresses, properties={"parent": relationship(User)}
+ )
parent = User(name="p1")
c1, c2 = (
self.classes.User,
)
- mapper(User, users)
- mapper(Address, addresses, properties={"parent": relationship(User)})
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
+ Address, addresses, properties={"parent": relationship(User)}
+ )
parent = User(name="p1")
c1, c2 = (
self.classes.User,
)
- mapper(User, users)
- mapper(Address, addresses, properties={"user": relationship(User)})
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
+ Address, addresses, properties={"user": relationship(User)}
+ )
sess = fixture_session()
u1 = User(name="u1")
self.classes.User,
)
- mapper(User, users)
- mapper(Address, addresses, properties={"user": relationship(User)})
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
+ Address, addresses, properties={"user": relationship(User)}
+ )
sess = fixture_session()
u1 = User(name="u1")
self.classes.User,
)
- mapper(User, users)
- mapper(Address, addresses, properties={"parent": relationship(User)})
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
+ Address, addresses, properties={"parent": relationship(User)}
+ )
sess = fixture_session()
Node, nodes = self.classes.Node, self.tables.nodes
- mapper(Node, nodes, properties={"children": relationship(Node)})
+ self.mapper_registry.map_imperatively(
+ Node, nodes, properties={"children": relationship(Node)}
+ )
sess = fixture_session()
self.classes.Item,
)
- mapper(
+ self.mapper_registry.map_imperatively(
Item,
items,
properties={
"keywords": relationship(Keyword, secondary=item_keywords)
},
)
- mapper(Keyword, keywords)
+ self.mapper_registry.map_imperatively(Keyword, keywords)
sess = fixture_session()
k1 = Keyword(name="k1")
self.classes.User,
)
- mapper(User, users)
- mapper(
+ self.mapper_registry.map_imperatively(User, users)
+ self.mapper_registry.map_imperatively(
Address,
addresses,
properties={"user": relationship(User, passive_updates=True)},
self.classes.User,
)
- mapper(User, users, properties={"addresses": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
with fixture_session(autoflush=False) as sess:
u1 = User(name="ed")
def test_one_to_many_save(self):
Node, nodes = self.classes.Node, self.tables.nodes
- mapper(Node, nodes, properties={"children": relationship(Node)})
+ self.mapper_registry.map_imperatively(
+ Node, nodes, properties={"children": relationship(Node)}
+ )
sess = fixture_session()
n2, n3 = Node(data="n2"), Node(data="n3")
def test_one_to_many_delete_all(self):
Node, nodes = self.classes.Node, self.tables.nodes
- mapper(Node, nodes, properties={"children": relationship(Node)})
+ self.mapper_registry.map_imperatively(
+ Node, nodes, properties={"children": relationship(Node)}
+ )
sess = fixture_session()
n2, n3 = Node(data="n2", children=[]), Node(data="n3", children=[])
def test_one_to_many_delete_parent(self):
Node, nodes = self.classes.Node, self.tables.nodes
- mapper(Node, nodes, properties={"children": relationship(Node)})
+ self.mapper_registry.map_imperatively(
+ Node, nodes, properties={"children": relationship(Node)}
+ )
sess = fixture_session()
n2, n3 = Node(data="n2", children=[]), Node(data="n3", children=[])
def test_many_to_one_save(self):
Node, nodes = self.classes.Node, self.tables.nodes
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={"parent": relationship(Node, remote_side=nodes.c.id)},
def test_many_to_one_delete_all(self):
Node, nodes = self.classes.Node, self.tables.nodes
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={"parent": relationship(Node, remote_side=nodes.c.id)},
def test_many_to_one_set_null_unloaded(self):
Node, nodes = self.classes.Node, self.tables.nodes
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={"parent": relationship(Node, remote_side=nodes.c.id)},
def test_cycle_rowswitch(self):
Node, nodes = self.classes.Node, self.tables.nodes
- mapper(Node, nodes, properties={"children": relationship(Node)})
+ self.mapper_registry.map_imperatively(
+ Node, nodes, properties={"children": relationship(Node)}
+ )
sess = fixture_session()
n2, n3 = Node(data="n2", children=[]), Node(data="n3", children=[])
def test_bidirectional_mutations_one(self):
Node, nodes = self.classes.Node, self.tables.nodes
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={
def test_bidirectional_multilevel_save(self):
Node, nodes = self.classes.Node, self.tables.nodes
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={
def test_singlecycle_flush_size(self):
Node, nodes = self.classes.Node, self.tables.nodes
- mapper(Node, nodes, properties={"children": relationship(Node)})
+ self.mapper_registry.map_imperatively(
+ Node, nodes, properties={"children": relationship(Node)}
+ )
with fixture_session() as sess:
n1 = Node(data="ed")
sess.add(n1)
def test_delete_unloaded_m2o(self):
Node, nodes = self.classes.Node, self.tables.nodes
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={"parent": relationship(Node, remote_side=nodes.c.id)},
class FooBar(fixtures.ComparableEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={
"foobars": relationship(FooBar),
},
)
- mapper(FooBar, foobars)
+ self.mapper_registry.map_imperatively(FooBar, foobars)
sess = fixture_session()
n1 = Node(data="n1")
class Node(fixtures.ComparableEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
nodes,
properties={
class Child(fixtures.BasicEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
parent,
properties={
)
},
)
- mapper(Child, child)
+ self.mapper_registry.map_imperatively(Child, child)
return Parent, Child
def test_switch_on_update(self):
class C(fixtures.BasicEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
properties={"bs": relationship(B, cascade="all, delete-orphan")},
)
- mapper(B, b, properties={"c": relationship(C)})
- mapper(C, c)
+ self.mapper_registry.map_imperatively(
+ B, b, properties={"c": relationship(C)}
+ )
+ self.mapper_registry.map_imperatively(C, c)
return A, B, C
def test_set_none_replaces_m2o(self):
class Child(fixtures.BasicEntity):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Parent,
parent,
properties={
},
confirm_deleted_rows=confirm_deleted_rows,
)
- mapper(Child, child)
+ self.mapper_registry.map_imperatively(Child, child)
return Parent, Child
@testing.requires.sane_rowcount
class T(fixtures.ComparableEntity):
pass
- mapper(T, t)
+ self.mapper_registry.map_imperatively(T, t)
sess = fixture_session()
sess.add_all(
[
self.classes.User,
)
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
return fixture_session(expire_on_commit=False)
def test_before_update_m2o(self):
def setup_mappers(cls):
Thing = cls.classes.Thing
- mapper(Thing, cls.tables.test, eager_defaults=True)
+ cls.mapper_registry.map_imperatively(
+ Thing, cls.tables.test, eager_defaults=True
+ )
def test_no_attr_events_flush(self):
Thing = self.classes.Thing
def setup_mappers(cls):
Thing = cls.classes.Thing
- mapper(Thing, cls.tables.test, eager_defaults=True)
+ cls.mapper_registry.map_imperatively(
+ Thing, cls.tables.test, eager_defaults=True
+ )
Thing2 = cls.classes.Thing2
- mapper(Thing2, cls.tables.test2, eager_defaults=True)
+ cls.mapper_registry.map_imperatively(
+ Thing2, cls.tables.test2, eager_defaults=True
+ )
def test_insert_defaults_present(self):
Thing = self.classes.Thing
def setup_mappers(cls):
Thing = cls.classes.Thing
- mapper(Thing, cls.tables.test)
+ cls.mapper_registry.map_imperatively(Thing, cls.tables.test)
def test_update_against_none(self):
Thing = self.classes.Thing
Thing = cls.classes.Thing
AltNameThing = cls.classes.AltNameThing
- mapper(Thing, cls.tables.test)
+ cls.mapper_registry.map_imperatively(Thing, cls.tables.test)
- mapper(AltNameThing, cls.tables.test_w_renames, column_prefix="_foo_")
+ cls.mapper_registry.map_imperatively(
+ AltNameThing, cls.tables.test_w_renames, column_prefix="_foo_"
+ )
if testing.requires.json_type.enabled:
- mapper(cls.classes.JSONThing, cls.tables.test_has_json)
+ cls.mapper_registry.map_imperatively(
+ cls.classes.JSONThing, cls.tables.test_has_json
+ )
def _assert_col(self, name, value):
Thing, AltNameThing = self.classes.Thing, self.classes.AltNameThing
def test_ensure_cache(self):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
cache = {}
eq_(len(inspect(User)._compiled_cache), 0)
from sqlalchemy import update
from sqlalchemy.orm import backref
from sqlalchemy.orm import joinedload
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
from sqlalchemy.orm import sessionmaker
Address = cls.classes.Address
addresses = cls.tables.addresses
- mapper(
+ cls.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses": relationship(Address),
},
)
- mapper(Address, addresses)
+ cls.mapper_registry.map_imperatively(Address, addresses)
def test_illegal_eval(self):
User = self.classes.User
class Foo(object):
pass
- mapper(Foo, self.tables.users, properties={"uname": synonym("name")})
+ self.mapper_registry.map_imperatively(
+ Foo, self.tables.users, properties={"uname": synonym("name")}
+ )
s = fixture_session()
jill = s.query(Foo).get(3)
class Foo(object):
pass
- mapper(Foo, self.tables.users, properties={"uname": synonym("name")})
+ self.mapper_registry.map_imperatively(
+ Foo, self.tables.users, properties={"uname": synonym("name")}
+ )
s = fixture_session()
jill = s.query(Foo).get(3)
class Foo(object):
pass
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
self.tables.users,
properties={"uname": synonym("name"), "ufoo": synonym("uname")},
cls.tables.users,
)
- mapper(User, users)
- mapper(
+ cls.mapper_registry.map_imperatively(User, users)
+ cls.mapper_registry.map_imperatively(
Document,
documents,
properties={
cls.tables.users,
)
- mapper(User, users)
- mapper(
+ cls.mapper_registry.map_imperatively(User, users)
+ cls.mapper_registry.map_imperatively(
Document,
documents,
properties={"user": relationship(User, backref="documents")},
@classmethod
def setup_mappers(cls):
data = cls.tables.data
- mapper(cls.classes.Data, data, properties={"cnt": data.c.counter})
+ cls.mapper_registry.map_imperatively(
+ cls.classes.Data, data, properties={"cnt": data.c.counter}
+ )
@testing.provide_metadata
def test_update_attr_names(self):
User = cls.classes.User
users = cls.tables.users
- mapper(
+ cls.mapper_registry.map_imperatively(
User,
users,
properties={
from sqlalchemy.ext.hybrid import hybrid_method
from sqlalchemy.ext.hybrid import hybrid_property
from sqlalchemy.orm import aliased
-from sqlalchemy.orm import mapper
+from sqlalchemy.orm import clear_mappers
from sqlalchemy.orm import Session
from sqlalchemy.orm import synonym
from sqlalchemy.orm import util as orm_util
from .inheritance import _poly_fixtures
-class AliasedClassTest(fixtures.TestBase, AssertsCompiledSQL):
+class AliasedClassTest(fixtures.MappedTest, AssertsCompiledSQL):
__dialect__ = "default"
def _fixture(self, cls, properties={}):
Column("x", Integer),
Column("y", Integer),
)
- mapper(cls, table, properties=properties)
+ clear_mappers()
+ self.mapper_registry.map_imperatively(
+ cls, table, properties=properties
+ )
return table
def test_simple(self):
def test_identity_key_1(self, ormutil):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
key = ormutil.identity_key(User, [1])
eq_(key, (User, (1,), None))
def test_identity_key_scalar(self, ormutil):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
key = ormutil.identity_key(User, 1)
eq_(key, (User, (1,), None))
def test_identity_key_2(self, ormutil):
users, User = self.tables.users, self.classes.User
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
s = fixture_session()
u = User(name="u1")
s.add(u)
def test_identity_key_3(self, ormutil):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
row = {users.c.id: 1, users.c.name: "Frank"}
key = ormutil.identity_key(User, row=row)
def test_identity_key_token(self):
User, users = self.classes.User, self.tables.users
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
key = orm_util.identity_key(User, [1], identity_token="token")
eq_(key, (User, (1,), "token"))
from sqlalchemy import exc
from sqlalchemy.orm import collections
-from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from sqlalchemy.orm import validates
from sqlalchemy.testing import assert_raises
ne_(name, "fred")
return name + " modified"
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
sess = fixture_session()
u1 = User(name="ed")
eq_(u1.name, "ed modified")
assert "@" in ad.email_address
return ad
- mapper(User, users, properties={"addresses": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
sess = fixture_session()
u1 = User(name="edward")
a0 = Address(email_address="noemail")
def simple_function(self, key, value):
return key, value
- u_m = mapper(
+ u_m = self.mapper_registry.map_imperatively(
User, users, properties={"addresses": relationship(Address)}
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
eq_(
dict((k, v[0].__name__) for k, v in list(u_m.validators.items())),
canary(key, item, remove)
return item
- mapper(User, users, properties={"addresses": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
u1 = User()
u1.name = "ed"
item = Address(email_address=item)
return item
- mapper(User, users, properties={"addresses": relationship(Address)})
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(
+ User, users, properties={"addresses": relationship(Address)}
+ )
+ self.mapper_registry.map_imperatively(Address, addresses)
u1 = User()
u1.addresses.append("e1")
item = Address(email_address=item)
return item
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={
)
},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
u1 = User()
u1.addresses["e1"] = "e1"
class User(fixtures.ComparableEntity):
sv = validates("name")(SomeValidator())
- mapper(User, users)
+ self.mapper_registry.map_imperatively(User, users)
u1 = User(name="ed")
eq_(u1.name, "ed modified")
exc.InvalidRequestError,
"A validation function for mapped attribute "
"'name' on mapper Mapper|Foo|users already exists",
- mapper,
+ self.mapper_registry.map_imperatively,
Foo,
users,
)
exc.InvalidRequestError,
"A validation function for mapped attribute "
"'name' on mapper Mapper|Bar|users already exists",
- mapper,
+ self.mapper_registry.map_imperatively,
Bar,
users,
)
canary(key, item)
return item
- mapper(
+ self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
)
- mapper(Address, addresses)
+ self.mapper_registry.map_imperatively(Address, addresses)
u1 = User()
u2 = User()
from sqlalchemy import util
from sqlalchemy.orm import configure_mappers
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
def _fixture(self):
Foo, version_table = self.classes.Foo, self.tables.version_table
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
version_table,
version_id_col=version_table.c.version_id,
def _fixture(self):
Foo, version_table = self.classes.Foo, self.tables.version_table
- mapper(Foo, version_table, version_id_col=version_table.c.version_id)
+ self.mapper_registry.map_imperatively(
+ Foo, version_table, version_id_col=version_table.c.version_id
+ )
s1 = fixture_session()
return s1
Foo = self.classes.Foo
version_table = self.tables.version_table
- mapper(Foo, version_table)
+ self.mapper_registry.map_imperatively(Foo, version_table)
s1 = fixture_session()
f1s1 = Foo(value="f1 value", version_id=1)
s1.add(f1s1)
Foo, version_table = self.classes.Foo, self.tables.version_table
s1 = fixture_session(autocommit=False)
- mapper(Foo, version_table)
+ self.mapper_registry.map_imperatively(Foo, version_table)
f1s1 = Foo(value="foo", version_id=0)
s1.add(f1s1)
s1.commit()
Node = self.classes.Node
node = self.tables.node
- mapper(
+ self.mapper_registry.map_imperatively(
Node,
node,
properties={
A, B = self.classes("A", "B")
a, b = self.tables("a", "b")
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
properties={"bs": relationship(B, backref="a")},
version_id_col=a.c.version_id,
)
- mapper(B, b)
+ self.mapper_registry.map_imperatively(B, b)
self._run_test()
A, B = self.classes("A", "B")
a, b = self.tables("a", "b")
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
properties={"bs": relationship(B, backref="a")},
version_id_col=a.c.version_id,
version_id_generator=lambda num: (num or 0) + 1,
)
- mapper(B, b)
+ self.mapper_registry.map_imperatively(B, b)
self._run_test()
A, B = self.classes("A", "B")
a, b = self.tables("a", "b")
- mapper(
+ self.mapper_registry.map_imperatively(
A,
a,
properties={"bs": relationship(B, backref="a")},
version_id_col=a.c.version_id,
version_id_generator=False,
)
- mapper(B, b)
+ self.mapper_registry.map_imperatively(B, b)
self._run_test(False)
def _fixture(self):
Foo, version_table = self.classes.Foo, self.tables.version_table
- mapper(Foo, version_table, version_id_col=version_table.c.version_id)
+ self.mapper_registry.map_imperatively(
+ Foo, version_table, version_id_col=version_table.c.version_id
+ )
s1 = fixture_session()
return s1
def setup_mappers(cls):
p, c, C, P = cls.tables.p, cls.tables.c, cls.classes.C, cls.classes.P
- mapper(
+ cls.mapper_registry.map_imperatively(
P,
p,
version_id_col=p.c.version_id,
)
},
)
- mapper(C, c, version_id_col=c.c.version_id)
+ cls.mapper_registry.map_imperatively(
+ C, c, version_id_col=c.c.version_id
+ )
def test_row_switch(self):
P = self.classes.P
def setup_mappers(cls):
p, c, C, P = cls.tables.p, cls.tables.c, cls.classes.C, cls.classes.P
- mapper(
+ cls.mapper_registry.map_imperatively(
P,
p,
version_id_col=p.c.version_id,
)
},
)
- mapper(
+ cls.mapper_registry.map_imperatively(
C,
c,
version_id_col=c.c.version_id,
self.classes.Sub,
)
- mapper(Base, base, version_id_col=base.c.version_id)
- mapper(Sub, sub, inherits=Base)
+ self.mapper_registry.map_imperatively(
+ Base, base, version_id_col=base.c.version_id
+ )
+ self.mapper_registry.map_imperatively(Sub, sub, inherits=Base)
s = fixture_session()
s1 = Sub(data="b", sub_data="s")
self.classes.Sub,
)
- mapper(Base, base, version_id_col=base.c.version_id)
- mapper(Sub, sub, inherits=Base)
+ self.mapper_registry.map_imperatively(
+ Base, base, version_id_col=base.c.version_id
+ )
+ self.mapper_registry.map_imperatively(Sub, sub, inherits=Base)
session = fixture_session()
b1 = Base(data="b1")
self.classes.Sub,
)
- mapper(Base, base, version_id_col=base.c.version_id)
- mapper(Sub, sub, inherits=Base)
+ self.mapper_registry.map_imperatively(
+ Base, base, version_id_col=base.c.version_id
+ )
+ self.mapper_registry.map_imperatively(Sub, sub, inherits=Base)
session = fixture_session()
s1 = Sub(data="s1", sub_data="s1")
self.classes.Sub,
)
- mapper(Base, base)
- mapper(Sub, sub, inherits=Base, version_id_col=sub.c.version_id)
+ self.mapper_registry.map_imperatively(Base, base)
+ self.mapper_registry.map_imperatively(
+ Sub, sub, inherits=Base, version_id_col=sub.c.version_id
+ )
session = fixture_session()
s1 = Sub(data="s1", sub_data="s1")
self.classes.Sub,
)
- mapper(Base, base, version_id_col=base.c.version_id)
+ self.mapper_registry.map_imperatively(
+ Base, base, version_id_col=base.c.version_id
+ )
assert_raises_message(
exc.SAWarning,
"automatically populate the inherited versioning column. "
"version_id_col should only be specified on "
"the base-most mapper that includes versioning.",
- mapper,
+ self.mapper_registry.map_imperatively,
Sub,
sub,
inherits=Base,
def _fixture(self, expire_on_commit=True, eager_defaults=False):
Foo, version_table = self.classes.Foo, self.tables.version_table
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
version_table,
version_id_col=version_table.c.version_id,
@classmethod
def setup_mappers(cls):
- mapper(
+ cls.mapper_registry.map_imperatively(
cls.classes.A,
cls.tables.a,
version_id_col=cls.tables.a.c.vid,
@classmethod
def setup_mappers(cls):
- mapper(
+ cls.mapper_registry.map_imperatively(
cls.classes.A,
cls.tables.a,
version_id_col=cls.tables.a.c.vid,
version_id_generator=False,
)
- mapper(cls.classes.B, cls.tables.b, inherits=cls.classes.A)
+ cls.mapper_registry.map_imperatively(
+ cls.classes.B, cls.tables.b, inherits=cls.classes.A
+ )
def test_no_increment(self):
sess = fixture_session()
.alias("current_table")
)
- mapper(Foo, current, version_id_col=version_table.c.version_id)
+ self.mapper_registry.map_imperatively(
+ Foo, current, version_id_col=version_table.c.version_id
+ )
s1 = fixture_session()
return s1
.alias("current_table")
)
- mapper(
+ self.mapper_registry.map_imperatively(
Foo,
current,
version_id_col=version_table.c.version_id,
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
