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