def test_replace(self): self._setup(ordering_list("position")) s1 = Slide("Slide #1") s1.bullets = [Bullet("1"), Bullet("2"), Bullet("3")] self.assert_(len(s1.bullets) == 3) self.assert_(s1.bullets[2].position == 2) session = create_session() session.add(s1) session.flush() new_bullet = Bullet("new 2") self.assert_(new_bullet.position is None) # mark existing bullet as db-deleted before replacement. # session.delete(s1.bullets[1]) s1.bullets[1] = new_bullet self.assert_(new_bullet.position == 1) self.assert_(len(s1.bullets) == 3) id_ = s1.id session.flush() session.expunge_all() srt = session.query(Slide).get(id_) self.assert_(srt.bullets) self.assert_(len(srt.bullets) == 3) self.assert_(srt.bullets[1].text == "new 2") self.assert_(srt.bullets[2].text == "3")
def test_basic(self): class Foo(object): def __init__(self, data=None): self.data = data def __repr__(self): return "Foo id %d, data %s" % (self.id, self.data) mapper(Foo, foo) class Bar(Foo): def __repr__(self): return "Bar id %d, data %s" % (self.id, self.data) mapper( Bar, bar, inherits=Foo, properties={ "foos": relationship(Foo, secondary=bar_foo, lazy="select") }, ) sess = create_session() b = Bar("bar #1") sess.add(b) b.foos.append(Foo("foo #1")) b.foos.append(Foo("foo #2")) sess.flush() compare = [repr(b)] + sorted([repr(o) for o in b.foos]) sess.expunge_all() result = sess.query(Bar).all() print(repr(result[0]) + repr(result[0].foos)) found = [repr(result[0])] + sorted([repr(o) for o in result[0].foos]) eq_(found, compare)
def test_one(self): product_mapper = mapper( Product, products_table, polymorphic_on=products_table.c.product_type, polymorphic_identity="product", ) mapper(Detail, inherits=product_mapper, polymorphic_identity="detail") mapper(Assembly, inherits=product_mapper, polymorphic_identity="assembly") mapper( SpecLine, specification_table, properties=dict( leader=relationship( Assembly, foreign_keys=[specification_table.c.leader_id], primaryjoin=specification_table.c.leader_id == products_table.c.product_id, lazy="select", backref=backref("specification"), uselist=False, ), follower=relationship( Product, foreign_keys=[specification_table.c.follower_id], primaryjoin=specification_table.c.follower_id == products_table.c.product_id, lazy="select", uselist=False, ), quantity=specification_table.c.quantity, ), ) session = create_session() a1 = Assembly(name="a1") p1 = Product(name="p1") a1.specification.append(SpecLine(follower=p1)) d1 = Detail(name="d1") a1.specification.append(SpecLine(follower=d1)) session.add(a1) orig = repr(a1) session.flush() session.expunge_all() a1 = session.query(Product).filter_by(name="a1").one() new = repr(a1) print(orig) print(new) assert (orig == new == "<Assembly a1> specification=[<SpecLine 1.0 " "<Product p1>>, <SpecLine 1.0 <Detail d1>>] documents=None")
def test_basic(self): class User(Base, fixtures.ComparableEntity): __tablename__ = "users" __autoload_with__ = testing.db addresses = relationship("Address", backref="user") class Address(Base, fixtures.ComparableEntity): __tablename__ = "addresses" __autoload_with__ = testing.db u1 = User(name="u1", addresses=[Address(email="one"), Address(email="two")]) sess = create_session() sess.add(u1) sess.flush() sess.expunge_all() eq_( sess.query(User).all(), [ User( name="u1", addresses=[Address(email="one"), Address(email="two")], ) ], ) a1 = sess.query(Address).filter(Address.email == "two").one() eq_(a1, Address(email="two")) eq_(a1.user, User(name="u1"))
def test_four(self): """this tests the RasterDocument being attached to the Assembly, but *not* the Document. this means only a "sub-class" task, i.e. corresponding to an inheriting mapper but not the base mapper, is created.""" product_mapper = mapper( Product, products_table, polymorphic_on=products_table.c.product_type, polymorphic_identity="product", ) mapper(Detail, inherits=product_mapper, polymorphic_identity="detail") mapper(Assembly, inherits=product_mapper, polymorphic_identity="assembly") document_mapper = mapper( Document, documents_table, polymorphic_on=documents_table.c.document_type, polymorphic_identity="document", properties=dict( name=documents_table.c.name, data=deferred(documents_table.c.data), product=relationship( Product, lazy="select", backref=backref("documents", cascade="all, delete-orphan"), ), ), ) mapper( RasterDocument, inherits=document_mapper, polymorphic_identity="raster_document", ) session = create_session() a1 = Assembly(name="a1") a1.documents.append(RasterDocument("doc2")) session.add(a1) orig = repr(a1) session.flush() session.expunge_all() a1 = session.query(Product).filter_by(name="a1").one() new = repr(a1) print(orig) print(new) assert (orig == new == "<Assembly a1> specification=None documents=" "[<RasterDocument doc2>]") del a1.documents[0] session.flush() session.expunge_all() a1 = session.query(Product).filter_by(name="a1").one() assert len(session.query(Document).all()) == 0
def test_rekey_wbase(self): class User(Base, fixtures.ComparableEntity): __tablename__ = "users" __autoload_with__ = testing.db nom = Column("name", String(50), key="nom") addresses = relationship("Address", backref="user") class Address(Base, fixtures.ComparableEntity): __tablename__ = "addresses" __autoload_with__ = testing.db u1 = User(nom="u1", addresses=[Address(email="one"), Address(email="two")]) sess = create_session() sess.add(u1) sess.flush() sess.expunge_all() eq_( sess.query(User).all(), [ User( nom="u1", addresses=[Address(email="one"), Address(email="two")], ) ], ) a1 = sess.query(Address).filter(Address.email == "two").one() eq_(a1, Address(email="two")) eq_(a1.user, User(nom="u1")) assert_raises(TypeError, User, name="u3")
def test_append_no_reorder(self): self._setup( ordering_list("position", count_from=1, reorder_on_append=False) ) s1 = Slide("Slide #1") self.assert_(not s1.bullets) self.assert_(len(s1.bullets) == 0) s1.bullets.append(Bullet("s1/b1")) self.assert_(s1.bullets) self.assert_(len(s1.bullets) == 1) self.assert_(s1.bullets[0].position == 1) s1.bullets.append(Bullet("s1/b2")) self.assert_(len(s1.bullets) == 2) self.assert_(s1.bullets[0].position == 1) self.assert_(s1.bullets[1].position == 2) bul = Bullet("s1/b100") bul.position = 100 s1.bullets.append(bul) self.assert_(s1.bullets[0].position == 1) self.assert_(s1.bullets[1].position == 2) self.assert_(s1.bullets[2].position == 100) s1.bullets.append(Bullet("s1/b4")) self.assert_(s1.bullets[0].position == 1) self.assert_(s1.bullets[1].position == 2) self.assert_(s1.bullets[2].position == 100) self.assert_(s1.bullets[3].position == 4) s1.bullets._reorder() self.assert_(s1.bullets[0].position == 1) self.assert_(s1.bullets[1].position == 2) self.assert_(s1.bullets[2].position == 3) self.assert_(s1.bullets[3].position == 4) session = create_session() session.add(s1) session.flush() id_ = s1.id session.expunge_all() del s1 srt = session.query(Slide).get(id_) self.assert_(srt.bullets) self.assert_(len(srt.bullets) == 4) titles = ["s1/b1", "s1/b2", "s1/b100", "s1/b4"] found = [b.text for b in srt.bullets] self.assert_(titles == found)
def test_basic(self): class Foo(object): def __init__(self, data=None): self.data = data mapper(Foo, foo) class Bar(Foo): pass mapper( Bar, bar, inherits=Foo, properties={ "foos": relationship(Foo, secondary=foo_bar, lazy="joined") }, ) sess = create_session() b = Bar("barfoo") sess.add(b) sess.flush() f1 = Foo("subfoo1") f2 = Foo("subfoo2") b.foos.append(f1) b.foos.append(f2) sess.flush() sess.expunge_all() result = sess.query(Bar).all() print(result[0]) print(result[0].foos) self.assert_unordered_result( result, Bar, { "id": b.id, "data": "barfoo", "foos": ( Foo, [ { "id": f1.id, "data": "subfoo1" }, { "id": f2.id, "data": "subfoo2" }, ], ), }, )
def test_relationship(self): pjoin = polymorphic_union( { "manager": managers_table, "engineer": engineers_table }, "type", "pjoin", ) mapper( Company, companies, properties={"employees": relationship(Employee)}, ) employee_mapper = mapper(Employee, pjoin, polymorphic_on=pjoin.c.type) mapper( Manager, managers_table, inherits=employee_mapper, concrete=True, polymorphic_identity="manager", ) mapper( Engineer, engineers_table, inherits=employee_mapper, concrete=True, polymorphic_identity="engineer", ) session = create_session() c = Company() c.employees.append(Manager("Tom", "knows how to manage things")) c.employees.append(Engineer("Kurt", "knows how to hack")) session.add(c) session.flush() session.expunge_all() def go(): c2 = session.get(Company, c.id) assert set([repr(x) for x in c2.employees]) == set([ "Engineer Kurt knows how to hack", "Manager Tom knows how to manage things", ]) self.assert_sql_count(testing.db, go, 2) session.expunge_all() def go(): c2 = session.get(Company, c.id, options=[joinedload(Company.employees)]) assert set([repr(x) for x in c2.employees]) == set([ "Engineer Kurt knows how to hack", "Manager Tom knows how to manage things", ]) self.assert_sql_count(testing.db, go, 1)
def test_advanced(self): class Foo(object): def __init__(self, data=None): self.data = data def __repr__(self): return "Foo id %d, data %s" % (self.id, self.data) mapper(Foo, foo) class Bar(Foo): def __repr__(self): return "Bar id %d, data %s" % (self.id, self.data) mapper(Bar, bar, inherits=Foo) class Blub(Bar): def __repr__(self): return "Blub id %d, data %s, bars %s, foos %s" % ( self.id, self.data, repr([b for b in self.bars]), repr([f for f in self.foos]), ) mapper( Blub, blub, inherits=Bar, properties={ "bars": relationship(Bar, secondary=blub_bar, lazy="joined"), "foos": relationship(Foo, secondary=blub_foo, lazy="joined"), }, ) sess = create_session() f1 = Foo("foo #1") b1 = Bar("bar #1") b2 = Bar("bar #2") bl1 = Blub("blub #1") for o in (f1, b1, b2, bl1): sess.add(o) bl1.foos.append(f1) bl1.bars.append(b2) sess.flush() compare = repr(bl1) blubid = bl1.id sess.expunge_all() result = sess.query(Blub).all() print(result) self.assert_(repr(result[0]) == compare) sess.expunge_all() x = sess.query(Blub).filter_by(id=blubid).one() print(x) self.assert_(repr(x) == compare)
def test_roundtrip(self): parent, child, direction = self.parent, self.child, self.direction A, B, C = self.classes("A", "B", "C") parent_class = {"a": A, "b": B, "c": C}[parent] child_class = {"a": A, "b": B, "c": C}[child] 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.commit() sess.close() # assert result via direct get() of parent object result = sess.get(parent_class, 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.get(parent_class, 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_slice(self): self._setup(ordering_list("position")) b = [ Bullet("1"), Bullet("2"), Bullet("3"), Bullet("4"), Bullet("5"), Bullet("6"), ] s1 = Slide("Slide #1") # 1, 2, 3 s1.bullets[0:3] = b[0:3] for i in 0, 1, 2: self.assert_(s1.bullets[i].position == i) self.assert_(s1.bullets[i] == b[i]) # 1, 4, 5, 6, 3 s1.bullets[1:2] = b[3:6] for li, bi in (0, 0), (1, 3), (2, 4), (3, 5), (4, 2): self.assert_(s1.bullets[li].position == li) self.assert_(s1.bullets[li] == b[bi]) # 1, 6, 3 del s1.bullets[1:3] for li, bi in (0, 0), (1, 5), (2, 2): self.assert_(s1.bullets[li].position == li) self.assert_(s1.bullets[li] == b[bi]) session = create_session() session.add(s1) session.flush() id_ = s1.id session.expunge_all() del s1 srt = session.query(Slide).get(id_) self.assert_(srt.bullets) self.assert_(len(srt.bullets) == 3) texts = ["1", "6", "3"] for i, text in enumerate(texts): self.assert_(srt.bullets[i].position == i) self.assert_(srt.bullets[i].text == text)
def test_insert(self): self._setup(ordering_list("position")) s1 = Slide("Slide #1") s1.bullets.append(Bullet("1")) s1.bullets.append(Bullet("2")) s1.bullets.append(Bullet("3")) s1.bullets.append(Bullet("4")) self.assert_(s1.bullets[0].position == 0) self.assert_(s1.bullets[1].position == 1) self.assert_(s1.bullets[2].position == 2) self.assert_(s1.bullets[3].position == 3) s1.bullets.insert(2, Bullet("insert_at_2")) self.assert_(s1.bullets[0].position == 0) self.assert_(s1.bullets[1].position == 1) self.assert_(s1.bullets[2].position == 2) self.assert_(s1.bullets[3].position == 3) self.assert_(s1.bullets[4].position == 4) self.assert_(s1.bullets[1].text == "2") self.assert_(s1.bullets[2].text == "insert_at_2") self.assert_(s1.bullets[3].text == "3") s1.bullets.insert(999, Bullet("999")) self.assert_(len(s1.bullets) == 6) self.assert_(s1.bullets[5].position == 5) session = create_session() session.add(s1) session.flush() id_ = s1.id session.expunge_all() del s1 srt = session.query(Slide).get(id_) self.assert_(srt.bullets) self.assert_(len(srt.bullets) == 6) texts = ["1", "2", "insert_at_2", "3", "4", "999"] found = [b.text for b in srt.bullets] self.assert_(texts == found)
def test_keys(self): pjoin = polymorphic_union( { "refugee": refugees_table, "office": offices_table }, "type", "pjoin", ) class Location(object): pass class Refugee(Location): pass class Office(Location): pass location_mapper = mapper( Location, pjoin, polymorphic_on=pjoin.c.type, polymorphic_identity="location", ) mapper( Office, offices_table, inherits=location_mapper, concrete=True, polymorphic_identity="office", ) mapper( Refugee, refugees_table, inherits=location_mapper, concrete=True, polymorphic_identity="refugee", ) sess = create_session() eq_(sess.get(Refugee, 1).name, "refugee1") eq_(sess.get(Refugee, 2).name, "refugee2") eq_(sess.get(Office, 1).name, "office1") eq_(sess.get(Office, 2).name, "office2")
def test_lazy_load(self): lazy_relationship = self.lazy_relationship with_polymorphic = self.with_polymorphic if self.redefine_colprop: person_attribute_name = "person_name" else: person_attribute_name = "name" session = create_session() dilbert = (session.query(Engineer).filter_by( **{ person_attribute_name: "dilbert" }).one()) employees = session.query(Person).order_by(Person.person_id).all() company = session.query(Company).first() eq_(session.get(Person, dilbert.person_id), dilbert) session.expunge_all() eq_( session.query(Person).filter( Person.person_id == dilbert.person_id).one(), dilbert, ) session.expunge_all() def go(): cc = session.get(Company, company.company_id) eq_(cc.employees, employees) if not lazy_relationship: if with_polymorphic != "none": self.assert_sql_count(testing.db, go, 1) else: self.assert_sql_count(testing.db, go, 2) else: if with_polymorphic != "none": self.assert_sql_count(testing.db, go, 2) else: self.assert_sql_count(testing.db, go, 3)
def test_basic(self): class Principal(object): def __init__(self, **kwargs): for key, value in kwargs.items(): setattr(self, key, value) class User(Principal): pass class Group(Principal): pass mapper(Principal, principals) mapper(User, users, inherits=Principal) mapper( Group, groups, inherits=Principal, properties={ "users": relationship( User, secondary=user_group_map, lazy="select", backref="groups", ) }, ) g = Group(name="group1") g.users.append( User( name="user1", password="******", email="*****@*****.**", login_id="lg1", )) sess = create_session() sess.add(g) sess.flush()
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.get(Bar, b.id).id == b.id
def test_basic(self): pjoin = polymorphic_union( { "manager": managers_table, "engineer": engineers_table }, "type", "pjoin", ) employee_mapper = mapper(Employee, pjoin, polymorphic_on=pjoin.c.type) mapper( Manager, managers_table, inherits=employee_mapper, concrete=True, polymorphic_identity="manager", ) mapper( Engineer, engineers_table, inherits=employee_mapper, concrete=True, polymorphic_identity="engineer", ) session = create_session() session.add(Manager("Tom", "knows how to manage things")) session.add(Engineer("Kurt", "knows how to hack")) session.flush() session.expunge_all() assert set([repr(x) for x in session.query(Employee)]) == set([ "Engineer Kurt knows how to hack", "Manager Tom knows how to manage things", ]) assert set([repr(x) for x in session.query(Manager) ]) == set(["Manager Tom knows how to manage things"]) assert set([repr(x) for x in session.query(Engineer) ]) == set(["Engineer Kurt knows how to hack"]) manager = session.query(Manager).one() session.expire(manager, ["manager_data"]) eq_(manager.manager_data, "knows how to manage things")
def test_supplied_fk(self): class IMHandle(Base, fixtures.ComparableEntity): __tablename__ = "imhandles" __autoload_with__ = testing.db user_id = Column("user_id", Integer, ForeignKey("users.id")) class User(Base, fixtures.ComparableEntity): __tablename__ = "users" __autoload_with__ = testing.db handles = relationship("IMHandle", backref="user") u1 = User( name="u1", handles=[ IMHandle(network="blabber", handle="foo"), IMHandle(network="lol", handle="zomg"), ], ) sess = create_session() sess.add(u1) sess.flush() sess.expunge_all() eq_( sess.query(User).all(), [ User( name="u1", handles=[ IMHandle(network="blabber", handle="foo"), IMHandle(network="lol", handle="zomg"), ], ) ], ) a1 = sess.query(IMHandle).filter(IMHandle.handle == "zomg").one() eq_(a1, IMHandle(network="lol", handle="zomg")) eq_(a1.user, User(name="u1"))
def test_two(self): product_mapper = mapper( Product, products_table, polymorphic_on=products_table.c.product_type, polymorphic_identity="product", ) mapper(Detail, inherits=product_mapper, polymorphic_identity="detail") mapper( SpecLine, specification_table, properties=dict(follower=relationship( Product, foreign_keys=[specification_table.c.follower_id], primaryjoin=specification_table.c.follower_id == products_table.c.product_id, lazy="select", uselist=False, )), ) session = create_session() s = SpecLine(follower=Product(name="p1")) s2 = SpecLine(follower=Detail(name="d1")) session.add(s) session.add(s2) orig = repr([s, s2]) session.flush() session.expunge_all() new = repr(session.query(SpecLine).all()) print(orig) print(new) assert (orig == new == "[<SpecLine 1.0 <Product p1>>, " "<SpecLine 1.0 <Detail d1>>]")
def test_five(self): """tests the late compilation of mappers""" mapper( SpecLine, specification_table, properties=dict( leader=relationship( Assembly, lazy="joined", uselist=False, foreign_keys=[specification_table.c.leader_id], primaryjoin=specification_table.c.leader_id == products_table.c.product_id, backref=backref("specification"), ), follower=relationship( Product, lazy="joined", uselist=False, foreign_keys=[specification_table.c.follower_id], primaryjoin=specification_table.c.follower_id == products_table.c.product_id, ), quantity=specification_table.c.quantity, ), ) mapper( Product, products_table, polymorphic_on=products_table.c.product_type, polymorphic_identity="product", properties={ "documents": relationship( Document, lazy="select", backref="product", cascade="all, delete-orphan", ) }, ) mapper(Detail, inherits=Product, polymorphic_identity="detail") mapper( Document, documents_table, polymorphic_on=documents_table.c.document_type, polymorphic_identity="document", properties=dict( name=documents_table.c.name, data=deferred(documents_table.c.data), ), ) mapper( RasterDocument, inherits=Document, polymorphic_identity="raster_document", ) mapper(Assembly, inherits=Product, polymorphic_identity="assembly") session = create_session() a1 = Assembly(name="a1") a1.specification.append(SpecLine(follower=Detail(name="d1"))) a1.documents.append(Document("doc1")) a1.documents.append(RasterDocument("doc2")) session.add(a1) orig = repr(a1) session.flush() session.expunge_all() a1 = session.query(Product).filter_by(name="a1").one() new = repr(a1) print(orig) print(new) assert (orig == new == "<Assembly a1> specification=" "[<SpecLine 1.0 <Detail d1>>] documents=[<Document doc1>, " "<RasterDocument doc2>]")
def test_multi_level_no_base(self): pjoin = polymorphic_union( { "manager": managers_table, "engineer": engineers_table, "hacker": hackers_table, }, "type", "pjoin", ) pjoin2 = polymorphic_union( { "engineer": engineers_table, "hacker": hackers_table }, "type", "pjoin2", ) employee_mapper = mapper(Employee, pjoin, polymorphic_on=pjoin.c.type) mapper( Manager, managers_table, inherits=employee_mapper, concrete=True, polymorphic_identity="manager", ) engineer_mapper = mapper( Engineer, engineers_table, with_polymorphic=("*", pjoin2), polymorphic_on=pjoin2.c.type, inherits=employee_mapper, concrete=True, polymorphic_identity="engineer", ) mapper( Hacker, hackers_table, inherits=engineer_mapper, concrete=True, polymorphic_identity="hacker", ) session = create_session() tom = Manager("Tom", "knows how to manage things") assert_raises_message( AttributeError, "does not implement attribute .?'type' at the instance level.", setattr, tom, "type", "sometype", ) jerry = Engineer("Jerry", "knows how to program") hacker = Hacker("Kurt", "Badass", "knows how to hack") assert_raises_message( AttributeError, "does not implement attribute .?'type' at the instance level.", setattr, hacker, "type", "sometype", ) session.add_all((tom, jerry, hacker)) session.flush() # ensure "readonly" on save logic didn't pollute the # expired_attributes collection assert ("nickname" not in attributes.instance_state(jerry).expired_attributes) assert ("name" not in attributes.instance_state(jerry).expired_attributes) assert ("name" not in attributes.instance_state(hacker).expired_attributes) assert ("nickname" not in attributes.instance_state(hacker).expired_attributes) def go(): eq_(jerry.name, "Jerry") eq_(hacker.nickname, "Badass") self.assert_sql_count(testing.db, go, 0) session.expunge_all() assert (repr( session.query(Employee).filter(Employee.name == "Tom").one()) == "Manager Tom knows how to manage things") assert (repr( session.query(Manager).filter(Manager.name == "Tom").one()) == "Manager Tom knows how to manage things") assert set([repr(x) for x in session.query(Employee).all()]) == set([ "Engineer Jerry knows how to program", "Manager Tom knows how to manage things", "Hacker Kurt 'Badass' knows how to hack", ]) assert set([repr(x) for x in session.query(Manager).all() ]) == set(["Manager Tom knows how to manage things"]) assert set([repr(x) for x in session.query(Engineer).all()]) == set([ "Engineer Jerry knows how to program", "Hacker Kurt 'Badass' knows how to hack", ]) assert set([repr(x) for x in session.query(Hacker).all() ]) == set(["Hacker Kurt 'Badass' knows how to hack"])
def test_multi_level_no_base_w_hybrid(self): pjoin = polymorphic_union( { "manager": managers_table, "engineer": engineers_table, "hacker": hackers_table, }, "type", "pjoin", ) test_calls = mock.Mock() class ManagerWHybrid(Employee): def __init__(self, name, manager_data): self.name = name self.manager_data = manager_data @hybrid_property def engineer_info(self): test_calls.engineer_info_instance() return self.manager_data @engineer_info.expression def engineer_info(cls): test_calls.engineer_info_class() return cls.manager_data employee_mapper = mapper(Employee, pjoin, polymorphic_on=pjoin.c.type) mapper( ManagerWHybrid, managers_table, inherits=employee_mapper, concrete=True, polymorphic_identity="manager", ) mapper( Engineer, engineers_table, inherits=employee_mapper, concrete=True, polymorphic_identity="engineer", ) session = create_session() tom = ManagerWHybrid("Tom", "mgrdata") # mapping did not impact the engineer_info # hybrid in any way eq_(test_calls.mock_calls, []) eq_(tom.engineer_info, "mgrdata") eq_(test_calls.mock_calls, [mock.call.engineer_info_instance()]) session.add(tom) session.commit() session.close() tom = (session.query(ManagerWHybrid).filter( ManagerWHybrid.engineer_info == "mgrdata").one()) eq_( test_calls.mock_calls, [ mock.call.engineer_info_instance(), mock.call.engineer_info_class(), ], ) eq_(tom.engineer_info, "mgrdata")
def test_multi_level_with_base(self): pjoin = polymorphic_union( { "employee": employees_table, "manager": managers_table, "engineer": engineers_table, "hacker": hackers_table, }, "type", "pjoin", ) pjoin2 = polymorphic_union( { "engineer": engineers_table, "hacker": hackers_table }, "type", "pjoin2", ) employee_mapper = mapper( Employee, employees_table, with_polymorphic=("*", pjoin), polymorphic_on=pjoin.c.type, ) mapper( Manager, managers_table, inherits=employee_mapper, concrete=True, polymorphic_identity="manager", ) engineer_mapper = mapper( Engineer, engineers_table, with_polymorphic=("*", pjoin2), polymorphic_on=pjoin2.c.type, inherits=employee_mapper, concrete=True, polymorphic_identity="engineer", ) mapper( Hacker, hackers_table, inherits=engineer_mapper, concrete=True, polymorphic_identity="hacker", ) session = create_session() tom = Manager("Tom", "knows how to manage things") jerry = Engineer("Jerry", "knows how to program") hacker = Hacker("Kurt", "Badass", "knows how to hack") session.add_all((tom, jerry, hacker)) session.flush() def go(): eq_(jerry.name, "Jerry") eq_(hacker.nickname, "Badass") self.assert_sql_count(testing.db, go, 0) session.expunge_all() # check that we aren't getting a cartesian product in the raw # SQL. this requires that Engineer's polymorphic discriminator # is not rendered in the statement which is only against # Employee's "pjoin" assert (len(session.connection().execute( session.query(Employee).with_labels().statement).fetchall()) == 3) assert set([repr(x) for x in session.query(Employee)]) == set([ "Engineer Jerry knows how to program", "Manager Tom knows how to manage things", "Hacker Kurt 'Badass' knows how to hack", ]) assert set([repr(x) for x in session.query(Manager) ]) == set(["Manager Tom knows how to manage things"]) assert set([repr(x) for x in session.query(Engineer)]) == set([ "Engineer Jerry knows how to program", "Hacker Kurt 'Badass' knows how to hack", ]) assert set([repr(x) for x in session.query(Hacker) ]) == set(["Hacker Kurt 'Badass' knows how to hack"])
def test_abc_poly_roundtrip(self, fetchtype): class A(fixtures.ComparableEntity): pass class B(A): pass class C(B): pass if fetchtype == "union": abc = a.outerjoin(b).outerjoin(c) bc = a.join(b).outerjoin(c) else: abc = bc = None mapper( A, a, with_polymorphic=("*", abc), polymorphic_on=a.c.type, polymorphic_identity="a", ) mapper( B, b, with_polymorphic=("*", bc), inherits=A, polymorphic_identity="b", ) mapper(C, c, inherits=B, polymorphic_identity="c") a1 = A(adata="a1") b1 = B(bdata="b1", adata="b1") b2 = B(bdata="b2", adata="b2") b3 = B(bdata="b3", adata="b3") c1 = C(cdata="c1", bdata="c1", adata="c1") c2 = C(cdata="c2", bdata="c2", adata="c2") c3 = C(cdata="c2", bdata="c2", adata="c2") sess = create_session() for x in (a1, b1, b2, b3, c1, c2, c3): sess.add(x) sess.flush() sess.expunge_all() # for obj in sess.query(A).all(): # print obj eq_( [ A(adata="a1"), B(bdata="b1", adata="b1"), B(bdata="b2", adata="b2"), B(bdata="b3", adata="b3"), C(cdata="c1", bdata="c1", adata="c1"), C(cdata="c2", bdata="c2", adata="c2"), C(cdata="c2", bdata="c2", adata="c2"), ], sess.query(A).order_by(A.id).all(), ) eq_( [ B(bdata="b1", adata="b1"), B(bdata="b2", adata="b2"), B(bdata="b3", adata="b3"), C(cdata="c1", bdata="c1", adata="c1"), C(cdata="c2", bdata="c2", adata="c2"), C(cdata="c2", bdata="c2", adata="c2"), ], sess.query(B).order_by(A.id).all(), ) eq_( [ C(cdata="c1", bdata="c1", adata="c1"), C(cdata="c2", bdata="c2", adata="c2"), C(cdata="c2", bdata="c2", adata="c2"), ], sess.query(C).order_by(A.id).all(), )
def test_without_default_polymorphic(self): pjoin = polymorphic_union( { "employee": employees_table, "manager": managers_table, "engineer": engineers_table, "hacker": hackers_table, }, "type", "pjoin", ) pjoin2 = polymorphic_union( { "engineer": engineers_table, "hacker": hackers_table }, "type", "pjoin2", ) employee_mapper = mapper(Employee, employees_table, polymorphic_identity="employee") mapper( Manager, managers_table, inherits=employee_mapper, concrete=True, polymorphic_identity="manager", ) engineer_mapper = mapper( Engineer, engineers_table, inherits=employee_mapper, concrete=True, polymorphic_identity="engineer", ) mapper( Hacker, hackers_table, inherits=engineer_mapper, concrete=True, polymorphic_identity="hacker", ) session = create_session() jdoe = Employee("Jdoe") tom = Manager("Tom", "knows how to manage things") jerry = Engineer("Jerry", "knows how to program") hacker = Hacker("Kurt", "Badass", "knows how to hack") session.add_all((jdoe, tom, jerry, hacker)) session.flush() eq_( len(session.connection().execute( session.query(Employee).with_polymorphic( "*", pjoin, pjoin.c.type).with_labels().statement).fetchall()), 4, ) eq_(session.get(Employee, jdoe.employee_id), jdoe) eq_(session.get(Engineer, jerry.employee_id), jerry) eq_( set([ repr(x) for x in session.query(Employee).with_polymorphic( "*", pjoin, pjoin.c.type) ]), set([ "Employee Jdoe", "Engineer Jerry knows how to program", "Manager Tom knows how to manage things", "Hacker Kurt 'Badass' knows how to hack", ]), ) eq_( set([repr(x) for x in session.query(Manager)]), set(["Manager Tom knows how to manage things"]), ) eq_( set([ repr(x) for x in session.query(Engineer).with_polymorphic( "*", pjoin2, pjoin2.c.type) ]), set([ "Engineer Jerry knows how to program", "Hacker Kurt 'Badass' knows how to hack", ]), ) eq_( set([repr(x) for x in session.query(Hacker)]), set(["Hacker Kurt 'Badass' knows how to hack"]), ) # test adaption of the column by wrapping the query in a # subquery with testing.expect_deprecated( r"The Query.from_self\(\) function/method"): eq_( len(session.connection().execute( session.query(Engineer).with_polymorphic( "*", pjoin2, pjoin2.c.type).from_self().statement).fetchall()), 2, ) with testing.expect_deprecated( r"The Query.from_self\(\) function/method"): eq_( set([ repr(x) for x in session.query(Engineer).with_polymorphic( "*", pjoin2, pjoin2.c.type).from_self() ]), set([ "Engineer Jerry knows how to program", "Hacker Kurt 'Badass' knows how to hack", ]), )
def _testlist(self, classes): sess = create_session() # create objects in a linked list count = 1 obj = None for c in classes: if isinstance(c, type): newobj = c("item %d" % count) count += 1 else: newobj = c if obj is not None: obj.nxt = newobj else: t = newobj obj = newobj # save to DB sess.add(t) sess.flush() # string version of the saved list assertlist = [] node = t while node: assertlist.append(node) n = node.nxt if n is not None: assert n.prev is node node = n original = repr(assertlist) # clear and query forwards sess.expunge_all() node = ( sess.query(Table1) .order_by(Table1.id) .filter(Table1.id == t.id) .first() ) assertlist = [] while node: assertlist.append(node) n = node.nxt if n is not None: assert n.prev is node node = n forwards = repr(assertlist) # clear and query backwards sess.expunge_all() node = ( sess.query(Table1) .order_by(Table1.id) .filter(Table1.id == obj.id) .first() ) assertlist = [] while node: assertlist.insert(0, node) n = node.prev if n is not None: assert n.nxt is node node = n backwards = repr(assertlist) # everything should match ! assert original == forwards == backwards
def test_insert_order(self): """test that classes of multiple types mix up mapper inserts so that insert order of individual tables is maintained""" person_join = polymorphic_union( { "engineer": people.join(engineers), "manager": people.join(managers), "person": people.select().where(people.c.type == "person").subquery(), }, None, "pjoin", ) person_mapper = mapper( Person, people, with_polymorphic=("*", person_join), polymorphic_on=person_join.c.type, polymorphic_identity="person", ) mapper( Engineer, engineers, inherits=person_mapper, polymorphic_identity="engineer", ) mapper( Manager, managers, inherits=person_mapper, polymorphic_identity="manager", ) mapper( Company, companies, properties={ "employees": relationship(Person, backref="company", order_by=person_join.c.person_id) }, ) session = create_session() c = Company(name="company1") c.employees.append( Manager( status="AAB", manager_name="manager1", name="pointy haired boss", )) c.employees.append( Engineer( status="BBA", engineer_name="engineer1", primary_language="java", name="dilbert", )) c.employees.append(Person(status="HHH", name="joesmith")) c.employees.append( Engineer( status="CGG", engineer_name="engineer2", primary_language="python", name="wally", )) c.employees.append( Manager(status="ABA", manager_name="manager2", name="jsmith")) session.add(c) session.flush() session.expunge_all() eq_(session.get(Company, c.company_id), c)