def test_o2m_relationship_cascade(self):
Base = automap_base(metadata=self.metadata)
Base.prepare()
configure_mappers()
b_rel = Base.classes.a.b_collection
assert not b_rel.property.cascade.delete
assert not b_rel.property.cascade.delete_orphan
assert not b_rel.property.passive_deletes
assert b_rel.property.cascade.save_update
c_rel = Base.classes.a.c_collection
assert c_rel.property.cascade.delete
assert c_rel.property.cascade.delete_orphan
assert not c_rel.property.passive_deletes
assert c_rel.property.cascade.save_update
d_rel = Base.classes.a.d_collection
assert d_rel.property.cascade.delete
assert d_rel.property.cascade.delete_orphan
assert d_rel.property.passive_deletes
assert d_rel.property.cascade.save_update
e_rel = Base.classes.a.e_collection
assert not e_rel.property.cascade.delete
assert not e_rel.property.cascade.delete_orphan
assert e_rel.property.passive_deletes
assert e_rel.property.cascade.save_update
def _automap(self, e):
Base = automap_base()
Base.prepare(e, reflect=True)
time.sleep(0.01)
configure_mappers()
def test_entity_path_w_aliased(self):
User, Address = self.classes("User", "Address")
configure_mappers()
@assert_cycles()
def go():
u1 = aliased(User)
inspect(u1)._path_registry[User.addresses.property]
go()
def test_use_get_reverseorder(self):
mapper(self.classes.A, self.tables.a)
m_b = mapper(
self.classes.B,
self.tables.b_differentorder,
properties={"a": relationship(self.classes.A)},
)
configure_mappers()
is_true(m_b.relationships.a.strategy.use_get)
def test_join_via_query_to_entity(self):
User, Address = self.classes("User", "Address")
configure_mappers()
s = Session()
@assert_cycles()
def go():
s.query(User).join(Address)
go()
def test_join_via_query_relationship(self):
User, Address = self.classes("User", "Address")
configure_mappers()
s = Session()
@assert_cycles()
def go():
s.query(User).join(User.addresses)
go()
def test_query(self):
User, Address = self.classes("User", "Address")
configure_mappers()
s = Session()
@assert_cycles()
def go():
return s.query(User).all()
go()
def test_clause_expansion(self):
self._fixture(False)
Edge = self.classes.Edge
from sqlalchemy_1_3.orm import configure_mappers
configure_mappers()
self.assert_compile(
select([Edge]).order_by(Edge.start),
"SELECT edge.id, edge.x1, edge.y1, edge.x2, edge.y2 FROM edge "
"ORDER BY edge.x1, edge.y1",
)
def test_core_select(self):
User, Address = self.classes("User", "Address")
configure_mappers()
s = Session()
stmt = s.query(User).join(User.addresses).statement
@assert_cycles()
def go():
s.execute(stmt)
go()
def test_query_alias(self):
User, Address = self.classes("User", "Address")
configure_mappers()
s = Session()
u1 = aliased(User)
@assert_cycles()
def go():
s.query(u1).all()
go()
def setup_mappers(cls):
global Session
Session = scoped_session(sessionmaker())
mapper(
User,
users,
properties={
"addresses": relationship(
Address, backref="user", order_by=addresses.c.id
)
},
)
mapper(Address, addresses)
configure_mappers()
def test_orm_objects_from_query(self):
User, Address = self.classes("User", "Address")
configure_mappers()
s = Session()
def generate():
objects = s.query(User).filter(User.id == 7).all()
gc_collect()
return objects
@assert_cycles()
def go():
generate()
go()
def test_dont_use_get_pj_is_different(self):
mapper(self.classes.A, self.tables.a)
m_b = mapper(
self.classes.B,
self.tables.b_sameorder,
properties={
"a":
relationship(
self.classes.A,
primaryjoin=and_(
self.tables.a.c.id1 == self.tables.b_sameorder.c.a_id1,
self.tables.a.c.id2 == 12,
),
)
},
)
configure_mappers()
is_false(m_b.relationships.a.strategy.use_get)
def setup_mappers(cls):
mapper(
cls.classes.A,
cls.tables.a,
properties={"b": relationship(cls.classes.B)},
)
bm = mapper(
cls.classes.B,
cls.tables.b,
properties={
"parent":
relationship(cls.classes.B, remote_side=cls.tables.b.c.b_id),
"zc":
relationship(cls.classes.C),
},
)
mapper(cls.classes.C, cls.tables.c)
bmp = bm._props
configure_mappers()
# Bug is order-dependent, must sort the "zc" property to the end
bmp.sort()
def test_overlapping_backref_relationship(self):
A, B, b_table, a_table, Dest, dest_table = (
self.classes.A,
self.classes.B,
self.tables.b_table,
self.tables.a_table,
self.classes.Dest,
self.tables.dest_table,
)
# test issue #3630, no error or warning is generated
mapper(A, a_table)
mapper(B, b_table, inherits=A, concrete=True)
mapper(
Dest,
dest_table,
properties={
"a": relationship(A, backref="dest"),
"a1": relationship(B, backref="dest"),
},
)
configure_mappers()
def setup_mappers(cls):
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(
B,
b,
properties={
"cs": relationship(C),
"ds": relationship(D),
"es": relationship(E),
"fs": relationship(F),
},
)
mapper(C, c)
mapper(D, d)
mapper(E, e)
mapper(F, f)
mapper(G, g)
configure_mappers()
def test_overlapping_forwards_relationship(self):
A, B, b_table, a_table, Dest, dest_table = (
self.classes.A,
self.classes.B,
self.tables.b_table,
self.tables.a_table,
self.classes.Dest,
self.tables.dest_table,
)
# this is the opposite mapping as that of #3630, never generated
# an error / warning
mapper(A,
a_table,
properties={"dest": relationship(Dest, backref="a")})
mapper(
B,
b_table,
inherits=A,
concrete=True,
properties={"dest": relationship(Dest, backref="a1")},
)
mapper(Dest, dest_table)
configure_mappers()
def test_with_polymorphic(self):
metadata = MetaData(testing.db)
order = Table(
"orders",
metadata,
Column("id", Integer, primary_key=True),
Column(
"employee_id",
Integer,
ForeignKey("employees.id"),
nullable=False,
),
Column("type", Unicode(16)),
)
employee = Table(
"employees",
metadata,
Column("id", Integer, primary_key=True),
Column("name", Unicode(16), unique=True, nullable=False),
)
product = Table("products", metadata,
Column("id", Integer, primary_key=True))
orderproduct = Table(
"orderproducts",
metadata,
Column("id", Integer, primary_key=True),
Column("order_id",
Integer,
ForeignKey("orders.id"),
nullable=False),
Column(
"product_id",
Integer,
ForeignKey("products.id"),
nullable=False,
),
)
class Order(object):
pass
class Employee(object):
pass
class Product(object):
pass
class OrderProduct(object):
pass
order_join = order.select().alias("pjoin")
mapper(
Order,
order,
with_polymorphic=("*", order_join),
polymorphic_on=order_join.c.type,
polymorphic_identity="order",
properties={
"orderproducts":
relationship(OrderProduct, lazy="select", backref="order")
},
)
mapper(
Product,
product,
properties={
"orderproducts":
relationship(OrderProduct, lazy="select", backref="product")
},
)
mapper(
Employee,
employee,
properties={
"orders": relationship(Order,
lazy="select",
backref="employee")
},
)
mapper(OrderProduct, orderproduct)
# this requires that the compilation of order_mapper's "surrogate
# mapper" occur after the initial setup of MapperProperty objects on
# the mapper.
configure_mappers()
def _setup_stock_mapping(cls):
(
Node,
composite_pk_table,
users,
Keyword,
items,
Dingaling,
order_items,
item_keywords,
Item,
User,
dingalings,
Address,
keywords,
CompositePk,
nodes,
Order,
orders,
addresses,
) = (
cls.classes.Node,
cls.tables.composite_pk_table,
cls.tables.users,
cls.classes.Keyword,
cls.tables.items,
cls.classes.Dingaling,
cls.tables.order_items,
cls.tables.item_keywords,
cls.classes.Item,
cls.classes.User,
cls.tables.dingalings,
cls.classes.Address,
cls.tables.keywords,
cls.classes.CompositePk,
cls.tables.nodes,
cls.classes.Order,
cls.tables.orders,
cls.tables.addresses,
)
# use OrderedDict on this one to support some tests that
# assert the order of attributes (e.g. orm/test_inspect)
mapper(
User,
users,
properties=util.OrderedDict([
(
"addresses",
relationship(Address,
backref="user",
order_by=addresses.c.id),
),
(
"orders",
relationship(Order, backref="user", order_by=orders.c.id),
), # o2m, m2o
]),
)
mapper(
Address,
addresses,
properties={
# o2o
"dingaling":
relationship(Dingaling, uselist=False, backref="address")
},
)
mapper(Dingaling, dingalings)
mapper(
Order,
orders,
properties={
# m2m
"items":
relationship(Item, secondary=order_items, order_by=items.c.id),
"address":
relationship(Address), # m2o
},
)
mapper(
Item,
items,
properties={
"keywords": relationship(Keyword,
secondary=item_keywords) # m2m
},
)
mapper(Keyword, keywords)
mapper(
Node,
nodes,
properties={
"children":
relationship(Node,
backref=backref("parent",
remote_side=[nodes.c.id]))
},
)
mapper(CompositePk, composite_pk_table)
configure_mappers()
def define_tables(cls, metadata):
global Table1, Table1B, Table2, Table3, Data
table1 = Table(
"table1",
metadata,
Column("id",
Integer,
primary_key=True,
test_needs_autoincrement=True),
Column("related_id",
Integer,
ForeignKey("table1.id"),
nullable=True),
Column("type", String(30)),
Column("name", String(30)),
)
table2 = Table(
"table2",
metadata,
Column("id", Integer, ForeignKey("table1.id"), primary_key=True),
)
table3 = Table(
"table3",
metadata,
Column("id", Integer, ForeignKey("table1.id"), primary_key=True),
)
data = Table(
"data",
metadata,
Column("id",
Integer,
primary_key=True,
test_needs_autoincrement=True),
Column("node_id", Integer, ForeignKey("table1.id")),
Column("data", String(30)),
)
# join = polymorphic_union(
# {
# 'table3' : table1.join(table3),
# 'table2' : table1.join(table2),
# 'table1' : table1.select(table1.c.type.in_(['table1', 'table1b'])),
# }, None, 'pjoin')
join = table1.outerjoin(table2).outerjoin(table3).alias("pjoin")
# join = None
class Table1(object):
def __init__(self, name, data=None):
self.name = name
if data is not None:
self.data = data
def __repr__(self):
return "%s(%s, %s, %s)" % (
self.__class__.__name__,
self.id,
repr(str(self.name)),
repr(self.data),
)
class Table1B(Table1):
pass
class Table2(Table1):
pass
class Table3(Table1):
pass
class Data(object):
def __init__(self, data):
self.data = data
def __repr__(self):
return "%s(%s, %s)" % (
self.__class__.__name__,
self.id,
repr(str(self.data)),
)
try:
# this is how the mapping used to work. ensure that this raises an
# error now
table1_mapper = mapper(
Table1,
table1,
select_table=join,
polymorphic_on=table1.c.type,
polymorphic_identity="table1",
properties={
"nxt":
relationship(
Table1,
backref=backref("prev",
foreignkey=join.c.id,
uselist=False),
uselist=False,
primaryjoin=join.c.id == join.c.related_id,
),
"data":
relationship(mapper(Data, data)),
},
)
configure_mappers()
assert False
except Exception:
assert True
clear_mappers()
# currently, the "eager" relationships degrade to lazy relationships
# due to the polymorphic load.
# the "nxt" relationship used to have a "lazy='joined'" on it, but the
# EagerLoader raises the "self-referential"
# exception now. since eager loading would never work for that
# relationship anyway, its better that the user
# 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,
table1,
# select_table=join,
polymorphic_on=table1.c.type,
polymorphic_identity="table1",
properties={
"nxt":
relationship(
Table1,
backref=backref("prev",
remote_side=table1.c.id,
uselist=False),
uselist=False,
primaryjoin=table1.c.id == table1.c.related_id,
),
"data":
relationship(mapper(Data, data),
lazy="joined",
order_by=data.c.id),
},
)
mapper(Table1B, inherits=table1_mapper, polymorphic_identity="table1b")
mapper(
Table2,
table2,
inherits=table1_mapper,
polymorphic_identity="table2",
)
mapper(
Table3,
table3,
inherits=table1_mapper,
polymorphic_identity="table3",
)
configure_mappers()
assert table1_mapper.primary_key == (
table1.c.id, ), table1_mapper.primary_key