def test_insp_relationship_prop(self):
User = self.classes.User
Address = self.classes.Address
prop = inspect(User.addresses)
is_(prop, User.addresses)
is_(prop.parent, class_mapper(User))
is_(prop._parentmapper, class_mapper(User))
is_(prop.mapper, class_mapper(Address))
def test_rel_accessors(self):
User = self.classes.User
Address = self.classes.Address
prop = inspect(User.addresses)
is_(prop.property.parent, class_mapper(User))
is_(prop.property.mapper, class_mapper(Address))
is_(prop.parent, class_mapper(User))
is_(prop.mapper, class_mapper(Address))
assert not hasattr(prop, "columns")
assert hasattr(prop, "expression")
def test_insp_aliased_column_prop(self):
User = self.classes.User
ua = aliased(User)
prop = inspect(ua.name)
is_(prop, ua.name)
is_(prop.property.parent.mapper, class_mapper(User))
assert not hasattr(prop.property, "mapper")
is_(prop.parent.entity, ua)
is_(prop.parent.class_, User)
is_(prop._parentmapper, class_mapper(User))
assert not hasattr(prop, "mapper")
is_(prop._parententity, inspect(ua))
def test_insp_aliased_relationship_prop(self):
User = self.classes.User
Address = self.classes.Address
ua = aliased(User)
prop = inspect(ua.addresses)
is_(prop, ua.addresses)
is_(prop.property.parent.mapper, class_mapper(User))
is_(prop.property.mapper, class_mapper(Address))
is_(prop.parent.entity, ua)
is_(prop.parent.class_, User)
is_(prop._parentmapper, class_mapper(User))
is_(prop.mapper, class_mapper(Address))
is_(prop._parententity, inspect(ua))
def _fixture(self):
A, B = self.classes.A, self.classes.B
session = create_session()
uowcommit = self._get_test_uow(session)
a_mapper = class_mapper(A)
b_mapper = class_mapper(B)
self.a1 = a1 = A()
self.b1 = b1 = B()
uowcommit = self._get_test_uow(session)
return (
uowcommit,
attributes.instance_state(a1),
attributes.instance_state(b1),
a_mapper,
b_mapper,
)
def test_insp_column_prop(self):
User = self.classes.User
prop = inspect(User.name)
is_(prop, User.name)
is_(prop.parent, class_mapper(User))
assert not hasattr(prop, "mapper")
def _polymorphic_join_target(self, cls):
from sqlalchemy_1_3.orm import class_mapper
sel = class_mapper(Person)._with_polymorphic_selectable.element
comp_sel = sel.compile(dialect=default.DefaultDialect())
return (comp_sel.process(sel, asfrom=True).replace("\n", "") +
" AS anon_1 ON companies.company_id = anon_1.company_id")
def _polymorphic_join_target(self, cls):
from sqlalchemy_1_3.orm import class_mapper
from sqlalchemy_1_3.sql.expression import FromGrouping
sel = FromGrouping(
class_mapper(Person)._with_polymorphic_selectable.alias(flat=True))
comp_sel = sel.compile(dialect=default.DefaultDialect())
return (comp_sel.process(sel, asfrom=True).replace("\n", "") +
" ON companies.company_id = people_1.company_id")
def test_get(self):
class Foo(object):
def __init__(self, data=None):
self.data = data
class Bar(Foo):
pass
mapper(Foo, foo)
mapper(Bar, bar, inherits=Foo)
print(foo.join(bar).primary_key)
print(class_mapper(Bar).primary_key)
b = Bar("somedata")
sess = create_session()
sess.add(b)
sess.flush()
sess.expunge_all()
# test that "bar.bid" does not need to be referenced in a get
# (ticket 185)
assert sess.query(Bar).get(b.id).id == b.id
def test_roundtrip(self):
parent_table = {"a": ta, "b": tb, "c": tc}[parent]
child_table = {"a": ta, "b": tb, "c": tc}[child]
remote_side = None
if direction == MANYTOONE:
foreign_keys = [parent_table.c.child_id]
elif direction == ONETOMANY:
foreign_keys = [child_table.c.parent_id]
atob = ta.c.id == tb.c.id
btoc = tc.c.id == tb.c.id
if direction == ONETOMANY:
relationshipjoin = parent_table.c.id == child_table.c.parent_id
elif direction == MANYTOONE:
relationshipjoin = parent_table.c.child_id == child_table.c.id
if parent is child:
remote_side = [child_table.c.id]
abcjoin = polymorphic_union(
{
"a":
ta.select(
tb.c.id == None, # noqa
from_obj=[ta.outerjoin(tb, onclause=atob)],
),
"b":
ta.join(tb, onclause=atob).outerjoin(
tc, onclause=btoc).select(
tc.c.id == None).reduce_columns(), # noqa
"c":
tc.join(tb, onclause=btoc).join(ta, onclause=atob),
},
"type",
"abcjoin",
)
bcjoin = polymorphic_union(
{
"b":
ta.join(tb, onclause=atob).outerjoin(
tc, onclause=btoc).select(
tc.c.id == None).reduce_columns(), # noqa
"c":
tc.join(tb, onclause=btoc).join(ta, onclause=atob),
},
"type",
"bcjoin",
)
class A(object):
def __init__(self, name):
self.a_data = name
class B(A):
pass
class C(B):
pass
mapper(
A,
ta,
polymorphic_on=abcjoin.c.type,
with_polymorphic=("*", abcjoin),
polymorphic_identity="a",
)
mapper(
B,
tb,
polymorphic_on=bcjoin.c.type,
with_polymorphic=("*", bcjoin),
polymorphic_identity="b",
inherits=A,
inherit_condition=atob,
)
mapper(
C,
tc,
polymorphic_identity="c",
inherits=B,
inherit_condition=btoc,
)
parent_mapper = class_mapper({ta: A, tb: B, tc: C}[parent_table])
child_mapper = class_mapper({ta: A, tb: B, tc: C}[child_table])
parent_class = parent_mapper.class_
child_class = child_mapper.class_
parent_mapper.add_property(
"collection",
relationship(
child_mapper,
primaryjoin=relationshipjoin,
foreign_keys=foreign_keys,
order_by=child_mapper.c.id,
remote_side=remote_side,
uselist=True,
),
)
sess = create_session()
parent_obj = parent_class("parent1")
child_obj = child_class("child1")
somea = A("somea")
someb = B("someb")
somec = C("somec")
# print "APPENDING", parent.__class__.__name__ , "TO",
# child.__class__.__name__
sess.add(parent_obj)
parent_obj.collection.append(child_obj)
if direction == ONETOMANY:
child2 = child_class("child2")
parent_obj.collection.append(child2)
sess.add(child2)
elif direction == MANYTOONE:
parent2 = parent_class("parent2")
parent2.collection.append(child_obj)
sess.add(parent2)
sess.add(somea)
sess.add(someb)
sess.add(somec)
sess.flush()
sess.expunge_all()
# assert result via direct get() of parent object
result = sess.query(parent_class).get(parent_obj.id)
assert result.id == parent_obj.id
assert result.collection[0].id == child_obj.id
if direction == ONETOMANY:
assert result.collection[1].id == child2.id
elif direction == MANYTOONE:
result2 = sess.query(parent_class).get(parent2.id)
assert result2.id == parent2.id
assert result2.collection[0].id == child_obj.id
sess.expunge_all()
# assert result via polymorphic load of parent object
result = sess.query(A).filter_by(id=parent_obj.id).one()
assert result.id == parent_obj.id
assert result.collection[0].id == child_obj.id
if direction == ONETOMANY:
assert result.collection[1].id == child2.id
elif direction == MANYTOONE:
result2 = sess.query(A).filter_by(id=parent2.id).one()
assert result2.id == parent2.id
assert result2.collection[0].id == child_obj.id
def test_mapper(self):
user_mapper = class_mapper(User)
assert (
serializer.loads(serializer.dumps(user_mapper, -1), None, None)
is user_mapper
)
def test_merge_w_relationship(self):
A, C, B, c_table, b_table, a_table, Dest, dest_table = (
self.classes.A,
self.classes.C,
self.classes.B,
self.tables.c_table,
self.tables.b_table,
self.tables.a_table,
self.classes.Dest,
self.tables.dest_table,
)
ajoin = polymorphic_union({
"a": a_table,
"b": b_table,
"c": c_table
}, "type", "ajoin")
mapper(
A,
a_table,
with_polymorphic=("*", ajoin),
polymorphic_on=ajoin.c.type,
polymorphic_identity="a",
properties={
"some_dest": relationship(Dest, back_populates="many_a")
},
)
mapper(
B,
b_table,
inherits=A,
concrete=True,
polymorphic_identity="b",
properties={
"some_dest": relationship(Dest, back_populates="many_a")
},
)
mapper(
C,
c_table,
inherits=A,
concrete=True,
polymorphic_identity="c",
properties={
"some_dest": relationship(Dest, back_populates="many_a")
},
)
mapper(
Dest,
dest_table,
properties={
"many_a":
relationship(A,
back_populates="some_dest",
order_by=ajoin.c.id)
},
)
assert C.some_dest.property.parent is class_mapper(C)
assert B.some_dest.property.parent is class_mapper(B)
assert A.some_dest.property.parent is class_mapper(A)
sess = sessionmaker()()
dest1 = Dest(name="d1")
dest2 = Dest(name="d2")
a1 = A(some_dest=dest2, aname="a1")
b1 = B(some_dest=dest1, bname="b1")
c1 = C(some_dest=dest2, cname="c1")
sess.add_all([dest1, dest2, c1, a1, b1])
sess.commit()
sess2 = sessionmaker()()
merged_c1 = sess2.merge(c1)
eq_(merged_c1.some_dest.name, "d2")
eq_(merged_c1.some_dest_id, c1.some_dest_id)
def test_class_mapper(self):
User = self.classes.User
assert inspect(User) is class_mapper(User)
def test_property(self):
User = self.classes.User
insp = inspect(User)
is_(insp.attrs.id, class_mapper(User).get_property("id"))
