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)
