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"))