Integer, String, create_engine
from sqlalchemy.orm import sessionmaker, mapper, relationship, backref,\
- eagerload_all
+ joinedload_all
from sqlalchemy.orm.collections import attribute_mapped_collection
"selecting tree on root, using eager loading to join four levels deep.")
session.expunge_all()
node = session.query(TreeNode).\
- options(eagerload_all("children", "children",
+ options(joinedload_all("children", "children",
"children", "children")).\
filter(TreeNode.name=="rootnode").\
first()
})
mapper(Item, items)
mapper(OrderItem, orderitems, properties={
- 'item': relationship(Item, lazy=False)
+ 'item': relationship(Item, lazy='joined')
})
session = create_session()
mapper(Order, orders, properties={
- 'itemassociations':relationship(OrderItem, cascade="all, delete-orphan", lazy=False)
+ 'itemassociations':relationship(OrderItem, cascade="all, delete-orphan", lazy='joined')
})
mapper(Item, items)
mapper(OrderItem, orderitems, properties={
- 'item':relationship(Item, lazy=False)
+ 'item':relationship(Item, lazy='joined')
})
session = create_session()
import environment
from model import Person, Address, cache_address_bits
-from meta import Session, FromCache, RelationCache
-from sqlalchemy.orm import eagerload
+from meta import Session, FromCache, RelationshipCache
+from sqlalchemy.orm import joinedload
def load_name_range(start, end, invalidate=False):
"""Load Person objects on a range of names.
The `Person.addresses` collections are also cached. Its basically
another level of tuning here, as that particular cache option
- can be transparently replaced with eagerload(Person.addresses).
+ can be transparently replaced with joinedload(Person.addresses).
The effect is that each Person and his/her Address collection
is cached either together or separately, affecting the kind of
SQL that emits for unloaded Person objects as well as the distribution
# have the "addresses" collection cached separately
# each lazyload of Person.addresses loads from cache.
- q = q.options(RelationCache("default", "by_person", Person.addresses))
+ q = q.options(RelationshipCache("default", "by_person", Person.addresses))
# alternatively, eagerly load the "addresses" collection, so that they'd
# be cached together. This issues a bigger SQL statement and caches
# a single, larger value in the cache per person rather than two
# separate ones.
- #q = q.options(eagerload(Person.addresses))
+ #q = q.options(joinedload(Person.addresses))
# if requested, invalidate the cache on current criterion.
if invalidate:
import environment
from model import Person, Address, cache_address_bits
from meta import Session
-from sqlalchemy.orm import eagerload
+from sqlalchemy.orm import joinedload
import os
-for p in Session.query(Person).options(eagerload(Person.addresses), cache_address_bits):
+for p in Session.query(Person).options(joinedload(Person.addresses), cache_address_bits):
print p.format_full()
# setup mappers. Document will eagerly load a list of _Node objects.
mapper(Document, documents, properties={
- '_root':relationship(_Node, lazy=False, cascade="all")
+ '_root':relationship(_Node, lazy='joined', cascade="all")
})
mapper(_Node, elements, properties={
'children':relationship(_Node, cascade="all"),
# eagerly load attributes
- 'attributes':relationship(_Attribute, lazy=False, cascade="all, delete-orphan"),
+ 'attributes':relationship(_Attribute, lazy='joined', cascade="all, delete-orphan"),
})
mapper(_Attribute, attributes)
# they will be ordered in primary key/insert order, so that we can reconstruct
# an ElementTree structure from the list.
mapper(Document, documents, properties={
- '_nodes':relationship(_Node, lazy=False, cascade="all, delete-orphan")
+ '_nodes':relationship(_Node, lazy='joined', cascade="all, delete-orphan")
})
# the _Node objects change the way they load so that a list of _Nodes will organize
# ordering to rows which will suffice.
mapper(_Node, elements, properties={
'children':relationship(_Node, lazy=None), # doesnt load; used only for the save relationship
- 'attributes':relationship(_Attribute, lazy=False, cascade="all, delete-orphan"), # eagerly load attributes
+ 'attributes':relationship(_Attribute, lazy='joined', cascade="all, delete-orphan"), # eagerly load attributes
})
mapper(_Attribute, attributes)
mapper(Manager, managers, inherits=person_mapper, polymorphic_identity='manager')
mapper(Company, companies, properties={
- 'employees': relationship(Person, lazy=False, backref='company', cascade="all, delete-orphan")
+ 'employees': relationship(Person, lazy='joined', backref='company', cascade="all, delete-orphan")
})
session = create_session()
self.name = name
mapper(Parent, parents_table, properties={
- '_children': relationship(Child, lazy=False,
+ '_children': relationship(Child, lazy='joined',
collection_class=collection_class)})
mapper(Child, children_table)
self.name = name
mapper(Parent, parents_table, properties={
- '_children': relationship(Child, lazy=False,
+ '_children': relationship(Child, lazy='joined',
collection_class=list)})
mapper(Child, children_table)
setattr(self, attr, kw[attr])
mapper(Parent, parents_table, properties={
- 'child': relationship(Child, lazy=False,
+ 'child': relationship(Child, lazy='joined',
backref='parent', uselist=False)})
mapper(Child, children_table)
Parent, Child = self.Parent, self.Child
mapper(Parent, self.table, properties={
- '_children': relationship(Child, lazy=True,
+ '_children': relationship(Child, lazy='select',
collection_class=list)})
p = Parent('p')
Parent, Child = self.Parent, self.Child
mapper(Parent, self.table, properties={
- '_children': relationship(Child, lazy=False,
+ '_children': relationship(Child, lazy='joined',
collection_class=list)})
p = Parent('p')
Parent, Child = self.Parent, self.Child
mapper(Parent, self.table, properties={
- '_children': relationship(Child, lazy=True, uselist=False)})
+ '_children': relationship(Child, lazy='select', uselist=False)})
p = Parent('p')
Parent, Child = self.Parent, self.Child
mapper(Parent, self.table, properties={
- '_children': relationship(Child, lazy=False, uselist=False)})
+ '_children': relationship(Child, lazy='joined', uselist=False)})
p = Parent('p')
return '<Bullet "%s" pos %s>' % (self.text, self.position)
mapper(Slide, slides_table, properties={
- 'bullets': relationship(Bullet, lazy=False,
+ 'bullets': relationship(Bullet, lazy='joined',
collection_class=test_collection_class,
backref='slide',
order_by=[bullets_table.c.position])
foos = mapper(Foo, foo)
bars = mapper(Bar, bar, inherits=foos)
- bars.add_property('lazy', relationship(foos, bar_foo, lazy=True))
- bars.add_property('eager', relationship(foos, bar_foo, lazy=False))
+ bars.add_property('lazy', relationship(foos, bar_foo, lazy='select'))
+ bars.add_property('eager', relationship(foos, bar_foo, lazy='joined'))
foo.insert().execute(data='foo1')
bar.insert().execute(id=1, data='bar1')
class Admin(User):pass
role_mapper = mapper(Role, roles)
user_mapper = mapper(User, users, properties = {
- 'roles' : relationship(Role, secondary=user_roles, lazy=False)
+ 'roles' : relationship(Role, secondary=user_roles, lazy='joined')
}
)
admin_mapper = mapper(Admin, admins, inherits=user_mapper)
role_mapper = mapper(Role, roles)
user_mapper = mapper(User, users, properties = {
- 'roles' : relationship(Role, secondary=user_roles, lazy=False)
+ 'roles' : relationship(Role, secondary=user_roles, lazy='joined')
}
)
location_name_mapper = mapper(LocationName, location_name_table)
location_mapper = mapper(Location, location_table, properties = {
- 'issue': relationship(Issue, backref=backref('locations', lazy=False, cascade="all, delete-orphan")),
+ 'issue': relationship(Issue, backref=backref('locations', lazy='joined', cascade="all, delete-orphan")),
'_name': relationship(LocationName),
})
mapper(Group, groups, inherits=Principal, properties={
'users': relationship(User, secondary=user_group_map,
- lazy=True, backref="groups")
+ lazy='select', backref="groups")
})
g = Group(name="group1")
pass
mapper(Bar, bar, inherits=Foo, properties={
- 'foos': relationship(Foo, secondary=foo_bar, lazy=False)
+ 'foos': relationship(Foo, secondary=foo_bar, lazy='joined')
})
sess = create_session()
return "Bar id %d, data %s" % (self.id, self.data)
mapper(Bar, bar, inherits=Foo, properties={
- 'foos' :relationship(Foo, secondary=bar_foo, lazy=True)
+ 'foos' :relationship(Foo, secondary=bar_foo, lazy='select')
})
sess = create_session()
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=False),
- 'foos':relationship(Foo, secondary=blub_foo, lazy=False),
+ 'bars':relationship(Bar, secondary=blub_bar, lazy='joined'),
+ 'foos':relationship(Foo, secondary=blub_foo, lazy='joined'),
})
sess = create_session()
# currently, the "eager" relationships degrade to lazy relationships
# due to the polymorphic load.
- # the "nxt" relationship used to have a "lazy=False" on it, but the EagerLoader raises the "self-referential"
+ # 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.
'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=False, order_by=data.c.id)
+ 'data':relationship(mapper(Data, data), lazy='joined', order_by=data.c.id)
},
order_by=table1.c.id
)
if usedata:
mapper(Manager, managers, inherits=Person, inherit_condition=people.c.person_id==managers.c.person_id, polymorphic_identity='manager',
properties={
- 'colleague':relationship(Person, primaryjoin=managers.c.manager_id==people.c.person_id, lazy=True, uselist=False),
+ 'colleague':relationship(Person, primaryjoin=managers.c.manager_id==people.c.person_id, lazy='select', uselist=False),
'data':relationship(Data, uselist=False)
}
)
else:
mapper(Manager, managers, inherits=Person, inherit_condition=people.c.person_id==managers.c.person_id, polymorphic_identity='manager',
properties={
- 'colleague':relationship(Person, primaryjoin=managers.c.manager_id==people.c.person_id, lazy=True, uselist=False)
+ 'colleague':relationship(Person, primaryjoin=managers.c.manager_id==people.c.person_id, lazy='select', uselist=False)
}
)
person_mapper = mapper(Person, people, polymorphic_on=people.c.type, polymorphic_identity='person')
engineer_mapper = mapper(Engineer, engineers, inherits=person_mapper, polymorphic_identity='engineer')
manager_mapper = mapper(Manager, managers, inherits=person_mapper, polymorphic_identity='manager')
- car_mapper = mapper(Car, cars, properties= {'manager':relationship(manager_mapper, lazy=False)})
+ car_mapper = mapper(Car, cars, properties= {'manager':relationship(manager_mapper, lazy='joined')})
sess = create_session()
car1 = Car()
# to parent.mapped_table
mapper(Manager, managers, inherits=Person, inherit_condition=people.c.person_id==managers.c.person_id,
properties={
- 'colleague':relationship(Manager, primaryjoin=managers.c.colleague_id==managers.c.person_id, lazy=True, uselist=False)
+ 'colleague':relationship(Manager, primaryjoin=managers.c.colleague_id==managers.c.person_id, lazy='select', uselist=False)
}
)
self.label = label
mapper(Person, people, polymorphic_on=people.c._type,polymorphic_identity='person', properties={
- 'tags': relationship(Tag, secondary=peopleTags,backref='people', lazy=False)
+ 'tags': relationship(Tag, secondary=peopleTags,backref='people', lazy='joined')
})
mapper(Employee, employees, inherits=Person,polymorphic_identity='employee')
mapper(Tag, tags)
master=relationship(Assembly,
foreign_keys=[specification_table.c.master_id],
primaryjoin=specification_table.c.master_id==products_table.c.product_id,
- lazy=True, backref=backref('specification'),
+ lazy='select', backref=backref('specification'),
uselist=False),
slave=relationship(Product,
foreign_keys=[specification_table.c.slave_id],
primaryjoin=specification_table.c.slave_id==products_table.c.product_id,
- lazy=True, uselist=False),
+ lazy='select', uselist=False),
quantity=specification_table.c.quantity,
)
)
slave=relationship(Product,
foreign_keys=[specification_table.c.slave_id],
primaryjoin=specification_table.c.slave_id==products_table.c.product_id,
- lazy=True, uselist=False),
+ lazy='select', uselist=False),
)
)
specification_mapper = mapper(SpecLine, specification_table,
properties=dict(
- master=relationship(Assembly, lazy=False, uselist=False,
+ master=relationship(Assembly, lazy='joined', uselist=False,
foreign_keys=[specification_table.c.master_id],
primaryjoin=specification_table.c.master_id==products_table.c.product_id,
backref=backref('specification', cascade="all, delete-orphan"),
),
- slave=relationship(Product, lazy=False, uselist=False,
+ slave=relationship(Product, lazy='joined', uselist=False,
foreign_keys=[specification_table.c.slave_id],
primaryjoin=specification_table.c.slave_id==products_table.c.product_id,
),
properties=dict(
name=documents_table.c.name,
data=deferred(documents_table.c.data),
- product=relationship(Product, lazy=True, backref=backref('documents', cascade="all, delete-orphan")),
+ product=relationship(Product, lazy='select', backref=backref('documents', cascade="all, delete-orphan")),
),
)
raster_document_mapper = mapper(RasterDocument, inherits=document_mapper,
properties=dict(
name=documents_table.c.name,
data=deferred(documents_table.c.data),
- product=relationship(Product, lazy=True, backref=backref('documents', cascade="all, delete-orphan")),
+ product=relationship(Product, lazy='select', backref=backref('documents', cascade="all, delete-orphan")),
),
)
raster_document_mapper = mapper(RasterDocument, inherits=document_mapper,
specification_mapper = mapper(SpecLine, specification_table,
properties=dict(
- master=relationship(Assembly, lazy=False, uselist=False,
+ master=relationship(Assembly, lazy='joined', uselist=False,
foreign_keys=[specification_table.c.master_id],
primaryjoin=specification_table.c.master_id==products_table.c.product_id,
backref=backref('specification'),
),
- slave=relationship(Product, lazy=False, uselist=False,
+ slave=relationship(Product, lazy='joined', uselist=False,
foreign_keys=[specification_table.c.slave_id],
primaryjoin=specification_table.c.slave_id==products_table.c.product_id,
),
product_mapper = mapper(Product, products_table,
polymorphic_on=products_table.c.product_type,
polymorphic_identity='product', properties={
- 'documents' : relationship(Document, lazy=True,
+ 'documents' : relationship(Document, lazy='select',
backref='product', cascade='all, delete-orphan'),
})
mapper(Keyword, keywords)
mapper(KeywordAssociation, item_keywords, properties={
- 'keyword':relationship(Keyword, lazy=False)},
+ 'keyword':relationship(Keyword, lazy='joined')},
primary_key=[item_keywords.c.item_id, item_keywords.c.keyword_id],
order_by=[item_keywords.c.data])
mapper(Right, right)
mapper(Middle, middle, properties=dict(
left=relationship(Left,
- lazy=False,
- backref=backref('middle',lazy=False)),
+ lazy='joined',
+ backref=backref('middle',lazy='joined')),
right=relationship(Right,
- lazy=False,
- backref=backref('middle', lazy=False)))),
+ lazy='joined',
+ backref=backref('middle', lazy='joined')))),
@testing.fails_on('maxdb', 'FIXME: unknown')
@testing.resolve_artifact_names
mapper(Employee, employees)
mapper(Department, departments, properties=dict(
employees=relationship(Employee,
- lazy=False,
+ lazy='joined',
backref='department')))
d1 = Department(name='One')
commentMapper = mapper(Comment, comments)
baseMapper = mapper(Base, base, properties=dict(
- comments=relationship(Comment, lazy=False,
+ comments=relationship(Comment, lazy='joined',
cascade='all, delete-orphan')))
mapper(Derived, derived, inherits=baseMapper)
p_m = mapper(Part, parts)
mapper(InheritedPart, inherited_part, properties=dict(
- part=relationship(Part, lazy=False)))
+ part=relationship(Part, lazy='joined')))
d_m = mapper(Design, design, properties=dict(
inheritedParts=relationship(InheritedPart,
mapper(DesignType, design_types)
d_m.add_property(
- "type", relationship(DesignType, lazy=False, backref="designs"))
+ "type", relationship(DesignType, lazy='joined', backref="designs"))
p_m.add_property(
"design", relationship(
- Design, lazy=False,
+ Design, lazy='joined',
backref=backref("parts", cascade="all, delete-orphan")))
mapper(Address, addresses)
mapper(Company, companies, properties={
- 'addresses' : relationship(Address, lazy=False)})
+ 'addresses' : relationship(Address, lazy='joined')})
mapper(Invoice, invoices, properties={
- 'company': relationship(Company, lazy=False)})
+ 'company': relationship(Company, lazy='joined')})
a1 = Address(address='a1 address')
a2 = Address(address='a2 address')
mapper(Phone, phone_numbers)
mapper(Address, addresses, properties={
- 'phones': relationship(Phone, lazy=False, backref='address',
+ 'phones': relationship(Phone, lazy='joined', backref='address',
order_by=phone_numbers.c.phone_id)})
mapper(Company, companies, properties={
- 'addresses': relationship(Address, lazy=False, backref='company',
+ 'addresses': relationship(Address, lazy='joined', backref='company',
order_by=addresses.c.address_id)})
mapper(Item, items)
mapper(Invoice, invoices, properties={
- 'items': relationship(Item, lazy=False, backref='invoice',
+ 'items': relationship(Item, lazy='joined', backref='invoice',
order_by=items.c.item_id),
- 'company': relationship(Company, lazy=False, backref='invoices')})
+ 'company': relationship(Company, lazy='joined', backref='invoices')})
c1 = Company(company_name='company 1', addresses=[
Address(address='a1 address',
jjj = sa.join(task, jj, task.c.id == jj.c.task_id)
mapper(Joined, jjj, properties=dict(
- type=relationship(Task_Type, lazy=False)))
+ type=relationship(Task_Type, lazy='joined')))
session = create_session()
mapper(Entry, entries, properties=dict(
account=relationship(Account,
uselist=False,
- backref=backref('entries', lazy=True,
+ backref=backref('entries', lazy='select',
order_by=entries.c.entry_id)),
transaction=relationship(Transaction,
uselist=False,
- backref=backref('entries', lazy=False,
+ backref=backref('entries', lazy='joined',
order_by=entries.c.entry_id))))
@testing.fails_on('maxdb', 'FIXME: unknown')
extra = relationship(Extra, cascade="all, delete")
))
mapper(User, users, properties = dict(
- pref = relationship(Pref, lazy=False, cascade="all, delete-orphan", single_parent=True ),
+ pref = relationship(Pref, lazy='joined', cascade="all, delete-orphan", single_parent=True ),
foo = relationship(Foo) # straight m2o
))
mapper(Foo, foo)
polymorphic_on=order_join.c.type,
polymorphic_identity='order',
properties={
- 'orderproducts': relationship(OrderProduct, lazy=True, backref='order')}
+ 'orderproducts': relationship(OrderProduct, lazy='select', backref='order')}
)
mapper(Product, product,
properties={
- 'orderproducts': relationship(OrderProduct, lazy=True, backref='product')}
+ 'orderproducts': relationship(OrderProduct, lazy='select', backref='product')}
)
mapper(Employee, employee,
properties={
- 'orders': relationship(Order, lazy=True, backref='employee')})
+ 'orders': relationship(Order, lazy='select', backref='employee')})
mapper(OrderProduct, orderproduct)
polymorphic_on=order_join.c.type,
polymorphic_identity='order',
properties={
- 'orderproducts': relationship(OrderProduct, lazy=True, backref='product')}
+ 'orderproducts': relationship(OrderProduct, lazy='select', backref='product')}
)
mapper(Product, product,
properties={
- 'orderproducts': relationship(OrderProduct, lazy=True, backref='product')}
+ 'orderproducts': relationship(OrderProduct, lazy='select', backref='product')}
)
mapper(OrderProduct, orderproduct)
'parent':relationship(C1,
primaryjoin=t1.c.parent_c1 == t1.c.c1,
remote_side=t1.c.c1,
- lazy=True,
+ lazy='select',
uselist=False)})
a = C1('head c1')
a.c1s.append(C1('another c1'))
'children': relationship(
Node,
primaryjoin=node.c.id==node.c.parent_id,
- lazy=True,
+ lazy='select',
cascade="all",
backref=backref("parent", remote_side=node.c.id)
),
Node,
primaryjoin=node.c.prev_sibling_id==node.c.id,
remote_side=node.c.id,
- lazy=True,
+ lazy='select',
uselist=False),
'next_sibling': relationship(
Node,
primaryjoin=node.c.next_sibling_id==node.c.id,
remote_side=node.c.id,
- lazy=True,
+ lazy='select',
uselist=False,
post_update=True)})
@testing.resolve_artifact_names
def test_basic(self):
mapper(User, users, properties={
- 'addresses':relationship(mapper(Address, addresses), lazy=False, order_by=Address.id)
+ 'addresses':relationship(mapper(Address, addresses), lazy='joined', order_by=Address.id)
})
sess = create_session()
q = sess.query(User)
"""An eagerly loaded child object is not marked as an orphan"""
mapper(User, users, properties={
- 'addresses':relationship(Address, cascade="all,delete-orphan", lazy=False)
+ 'addresses':relationship(Address, cascade="all,delete-orphan", lazy='joined')
})
mapper(Address, addresses)
def test_orderby(self):
mapper(User, users, properties = {
'addresses':relationship(mapper(Address, addresses),
- lazy=False, order_by=addresses.c.email_address),
+ lazy='joined', order_by=addresses.c.email_address),
})
q = create_session().query(User)
eq_([
def test_orderby_multi(self):
mapper(User, users, properties = {
'addresses':relationship(mapper(Address, addresses),
- lazy=False,
+ lazy='joined',
order_by=[addresses.c.email_address, addresses.c.id]),
})
q = create_session().query(User)
mapper(Address, addresses)
mapper(User, users, properties = dict(
- addresses = relationship(Address, lazy=False, order_by=addresses.c.id),
+ addresses = relationship(Address, lazy='joined', order_by=addresses.c.id),
))
q = create_session().query(User)
def test_orderby_desc(self):
mapper(Address, addresses)
mapper(User, users, properties = dict(
- addresses = relationship(Address, lazy=False,
+ addresses = relationship(Address, lazy='joined',
order_by=[sa.desc(addresses.c.email_address)]),
))
sess = create_session()
def test_deferred_fk_col(self):
mapper(Address, addresses, properties={
'user_id':deferred(addresses.c.user_id),
- 'user':relationship(User, lazy=False)
+ 'user':relationship(User, lazy='joined')
})
mapper(User, users)
'user_id':deferred(addresses.c.user_id),
})
mapper(User, users, properties={
- 'addresses':relationship(Address, lazy=False)})
+ 'addresses':relationship(Address, lazy='joined')})
for q in [
sess.query(User).filter(User.id==7),
sa.orm.clear_mappers()
mapper(User, users, properties={
- 'addresses':relationship(Address, lazy=False)})
+ 'addresses':relationship(Address, lazy='joined')})
mapper(Address, addresses, properties={
'user_id':deferred(addresses.c.user_id),
- 'dingalings':relationship(Dingaling, lazy=False)})
+ 'dingalings':relationship(Dingaling, lazy='joined')})
mapper(Dingaling, dingalings, properties={
'address_id':deferred(dingalings.c.address_id)})
sess.expunge_all()
mapper(Keyword, keywords)
mapper(Item, items, properties = dict(
keywords = relationship(Keyword, secondary=item_keywords,
- lazy=False, order_by=keywords.c.id)))
+ lazy='joined', order_by=keywords.c.id)))
q = create_session().query(Item).order_by(Item.id)
def go():
def test_eager_option(self):
mapper(Keyword, keywords)
mapper(Item, items, properties = dict(
- keywords = relationship(Keyword, secondary=item_keywords, lazy=True,
+ keywords = relationship(Keyword, secondary=item_keywords, lazy='select',
order_by=keywords.c.id)))
q = create_session().query(Item)
mapper(Address, addresses)
mapper(User, users, properties = dict(
- addresses = relationship(Address, lazy=False,
- backref=sa.orm.backref('user', lazy=False),
+ addresses = relationship(Address, lazy='joined',
+ backref=sa.orm.backref('user', lazy='joined'),
order_by=Address.id)
))
- is_(sa.orm.class_mapper(User).get_property('addresses').lazy, False)
- is_(sa.orm.class_mapper(Address).get_property('user').lazy, False)
+ eq_(sa.orm.class_mapper(User).get_property('addresses').lazy, 'joined')
+ eq_(sa.orm.class_mapper(Address).get_property('user').lazy, 'joined')
sess = create_session()
eq_(self.static.user_address_result, sess.query(User).order_by(User.id).all())
closed_mapper = mapper(Order, closedorders, non_primary=True)
mapper(User, users, properties = dict(
- addresses = relationship(Address, lazy=False, order_by=addresses.c.id),
+ addresses = relationship(Address, lazy='joined', order_by=addresses.c.id),
open_orders = relationship(
open_mapper,
primaryjoin=sa.and_(openorders.c.isopen == 1,
users.c.id==openorders.c.user_id),
- lazy=False, order_by=openorders.c.id),
+ lazy='joined', order_by=openorders.c.id),
closed_orders = relationship(
closed_mapper,
primaryjoin=sa.and_(closedorders.c.isopen == 0,
users.c.id==closedorders.c.user_id),
- lazy=False, order_by=closedorders.c.id)))
+ lazy='joined', order_by=closedorders.c.id)))
q = create_session().query(User).order_by(User.id)
mapper(Address, addresses)
mapper(Order, orders, properties={
- 'items': relationship(Item, secondary=order_items, lazy=False,
+ 'items': relationship(Item, secondary=order_items, lazy='joined',
order_by=items.c.id)})
mapper(Item, items)
mapper(User, users, properties=dict(
- addresses=relationship(Address, lazy=False, order_by=addresses.c.id),
+ addresses=relationship(Address, lazy='joined', order_by=addresses.c.id),
open_orders=relationship(
Order,
primaryjoin=sa.and_(orders.c.isopen == 1,
users.c.id==orders.c.user_id),
- lazy=False, order_by=orders.c.id),
+ lazy='joined', order_by=orders.c.id),
closed_orders=relationship(
Order,
primaryjoin=sa.and_(orders.c.isopen == 0,
users.c.id==orders.c.user_id),
- lazy=False, order_by=orders.c.id)))
+ lazy='joined', order_by=orders.c.id)))
q = create_session().query(User).order_by(User.id)
def go():
part of their eager load."""
mapper(User, users, properties={
- 'addresses':relationship(Address, lazy=False),
- 'orders':relationship(Order, lazy=False)
+ 'addresses':relationship(Address, lazy='joined'),
+ 'orders':relationship(Order, lazy='joined')
})
mapper(Address, addresses)
mapper(Order, orders)
mapper(Item, items)
mapper(Order, orders, properties={
- 'items':relationship(Item, secondary=order_items, lazy=False,
+ 'items':relationship(Item, secondary=order_items, lazy='joined',
order_by=items.c.id)
})
mapper(User, users, properties={
- 'addresses':relationship(mapper(Address, addresses), lazy=False, order_by=addresses.c.id),
- 'orders':relationship(Order, lazy=True, order_by=orders.c.id)
+ 'addresses':relationship(mapper(Address, addresses), lazy='joined', order_by=addresses.c.id),
+ 'orders':relationship(Order, lazy='select', order_by=orders.c.id)
})
sess = create_session()
s = sa.union_all(u2.select(use_labels=True), u2.select(use_labels=True), u2.select(use_labels=True)).alias('u')
mapper(User, users, properties={
- 'addresses':relationship(mapper(Address, addresses), lazy=False, order_by=addresses.c.id),
+ 'addresses':relationship(mapper(Address, addresses), lazy='joined', order_by=addresses.c.id),
})
sess = create_session()
def test_limit_2(self):
mapper(Keyword, keywords)
mapper(Item, items, properties = dict(
- keywords = relationship(Keyword, secondary=item_keywords, lazy=False, order_by=[keywords.c.id]),
+ keywords = relationship(Keyword, secondary=item_keywords, lazy='joined', order_by=[keywords.c.id]),
))
sess = create_session()
mapper(Item, items)
mapper(Order, orders, properties = dict(
- items = relationship(Item, secondary=order_items, lazy=False)
+ items = relationship(Item, secondary=order_items, lazy='joined')
))
mapper(Address, addresses)
mapper(User, users, properties = dict(
- addresses = relationship(Address, lazy=False, order_by=addresses.c.id),
- orders = relationship(Order, lazy=False, order_by=orders.c.id),
+ addresses = relationship(Address, lazy='joined', order_by=addresses.c.id),
+ orders = relationship(Order, lazy='joined', order_by=orders.c.id),
))
sess = create_session()
sel = sa.select([users, addresses.c.email_address],
users.c.id==addresses.c.user_id).alias('useralias')
mapper(User, sel, properties={
- 'orders':relationship(Order, primaryjoin=sel.c.id==orders.c.user_id, lazy=False)
+ 'orders':relationship(Order, primaryjoin=sel.c.id==orders.c.user_id, lazy='joined')
})
mapper(Order, orders)
def test_one_to_many_scalar(self):
mapper(User, users, properties = dict(
address = relationship(mapper(Address, addresses),
- lazy=False, uselist=False)
+ lazy='joined', uselist=False)
))
q = create_session().query(User)
@testing.resolve_artifact_names
def test_many_to_one(self):
mapper(Address, addresses, properties = dict(
- user = relationship(mapper(User, users), lazy=False)
+ user = relationship(mapper(User, users), lazy='joined')
))
sess = create_session()
q = sess.query(Address)
addresses.c.email_address != None
),
- lazy=False)
+ lazy='joined')
))
sess = create_session()
contains a many-to-many relationship to a third object."""
mapper(User, users, properties={
- 'orders':relationship(Order, lazy=False, order_by=orders.c.id)
+ 'orders':relationship(Order, lazy='joined', order_by=orders.c.id)
})
mapper(Item, items)
mapper(Order, orders, properties = dict(
- items = relationship(Item, secondary=order_items, lazy=False, order_by=items.c.id)
+ items = relationship(Item, secondary=order_items, lazy='joined', order_by=items.c.id)
))
q = create_session().query(User)
mapper(Order, orders)
mapper(User, users, properties={
- 'orders':relationship(Order, backref='user', lazy=False,
+ 'orders':relationship(Order, backref='user', lazy='joined',
order_by=orders.c.id),
'max_order':relationship(
mapper(Order, max_orders, non_primary=True),
- lazy=False, uselist=False)
+ lazy='joined', uselist=False)
})
q = create_session().query(User)
@testing.resolve_artifact_names
def test_wide(self):
- mapper(Order, orders, properties={'items':relationship(Item, secondary=order_items, lazy=False,
+ mapper(Order, orders, properties={'items':relationship(Item, secondary=order_items, lazy='joined',
order_by=items.c.id)})
mapper(Item, items)
mapper(User, users, properties = dict(
s = sa.select([orders], orders.c.isopen==1).alias('openorders')
mapper(Order, s, properties={
- 'user':relationship(User, lazy=False)
+ 'user':relationship(User, lazy='joined')
})
mapper(User, users)
mapper(Item, items)
mapper(User, users, properties = dict(
addresses = relationship(mapper(Address, addresses),
- lazy=False, order_by=addresses.c.id)
+ lazy='joined', order_by=addresses.c.id)
))
q = create_session().query(User)
l = q.filter(addresses.c.email_address == 'ed@lala.com').filter(
@testing.resolve_artifact_names
def test_inner_join(self):
mapper(User, users, properties = dict(
- addresses = relationship(mapper(Address, addresses), lazy=False, innerjoin=True, order_by=addresses.c.id)
+ addresses = relationship(mapper(Address, addresses), lazy='joined', innerjoin=True, order_by=addresses.c.id)
))
sess = create_session()
eq_(
@testing.resolve_artifact_names
def test_mapper_configured(self):
mapper(User, users, properties={
- 'addresses':relationship(Address, lazy=False),
+ 'addresses':relationship(Address, lazy='joined'),
'orders':relationship(Order)
})
mapper(Address, addresses)
mapper(Order, orders, properties={
- 'items':relationship(Item, secondary=order_items, lazy=False, order_by=items.c.id)
+ 'items':relationship(Item, secondary=order_items, lazy='joined', order_by=items.c.id)
})
mapper(Item, items)
class B(_base.ComparableEntity):pass
mapper(A, a, properties={
- 'bs':relationship(B, secondary=m2m, lazy=False, order_by=m2m.c.id)
+ 'bs':relationship(B, secondary=m2m, lazy='joined', order_by=m2m.c.id)
})
mapper(B, b)
mapper(Node, nodes, properties={
'children':relationship(Node,
- lazy=False,
+ lazy='joined',
join_depth=3, order_by=nodes.c.id)
})
sess = create_session()
self.children.append(node)
mapper(Node, nodes, properties={
- 'children':relationship(Node, lazy=False, join_depth=1,
+ 'children':relationship(Node, lazy='joined', join_depth=1,
order_by=nodes.c.id)
})
sess = create_session()
self.children.append(node)
mapper(Node, nodes, properties={
- 'children':relationship(Node, lazy=False, join_depth=3,
+ 'children':relationship(Node, lazy='joined', join_depth=3,
order_by=nodes.c.id),
'data':deferred(nodes.c.data)
})
self.children.append(node)
mapper(Node, nodes, properties={
- 'children':relationship(Node, lazy=True, order_by=nodes.c.id)
+ 'children':relationship(Node, lazy='select', order_by=nodes.c.id)
}, order_by=nodes.c.id)
sess = create_session()
n1 = Node(data='n1')
self.children.append(node)
mapper(Node, nodes, properties={
- 'children':relationship(Node, lazy=False)
+ 'children':relationship(Node, lazy='joined')
})
sess = create_session()
n1 = Node(data='n1')
'children': relationship(Widget, secondary=widget_rel,
primaryjoin=widget_rel.c.parent_id==widget.c.id,
secondaryjoin=widget_rel.c.child_id==widget.c.id,
- lazy=False, join_depth=1,
+ lazy='joined', join_depth=1,
)
})
mapper(T, t1, polymorphic_on=t1.c.type, polymorphic_identity='t1')
mapper(SubT, None, inherits=T, polymorphic_identity='subt1', properties={
- 't2s':relationship(SubT2, lazy=False, backref=sa.orm.backref('subt', lazy=False))
+ 't2s':relationship(SubT2, lazy='joined', backref=sa.orm.backref('subt', lazy='joined'))
})
mapper(T2, t2, polymorphic_on=t2.c.type, polymorphic_identity='t2')
mapper(SubT2, None, inherits=T2, polymorphic_identity='subt2')
mapper(User, users_table, properties={
- 'tags': relationship(Tag, backref='user', lazy=False),
+ 'tags': relationship(Tag, backref='user', lazy='joined'),
'query_score': sa.orm.column_property(user_score),
})
@testing.resolve_artifact_names
def test_expired_eager(self):
mapper(User, users, properties={
- 'addresses':relationship(Address, backref='user', lazy=False),
+ 'addresses':relationship(Address, backref='user', lazy='joined'),
})
mapper(Address, addresses)
@testing.resolve_artifact_names
def test_relationship_changes_preserved(self):
mapper(User, users, properties={
- 'addresses':relationship(Address, backref='user', lazy=False),
+ 'addresses':relationship(Address, backref='user', lazy='joined'),
})
mapper(Address, addresses)
sess = create_session()
# fires off to load "addresses", but needs foreign key or primary key
# attributes in order to lazy load; hits those attributes, such as
# below it hits "u.id". "u.id" triggers full unexpire operation,
- # joinedloads addresses since lazy=False. this is all wihtin lazy load
+ # joinedloads addresses since lazy='joined'. this is all wihtin lazy load
# which fires unconditionally; so an unnecessary joinedload (or
# lazyload) was issued. would prefer not to complicate lazyloading to
# "figure out" that the operation should be aborted right now.
mapper(User, users, properties={
- 'addresses':relationship(Address, backref='user', lazy=False),
+ 'addresses':relationship(Address, backref='user', lazy='joined'),
})
mapper(Address, addresses)
sess = create_session()
@testing.resolve_artifact_names
def test_partial_expire_eager(self):
mapper(User, users, properties={
- 'addresses':relationship(Address, backref='user', lazy=False),
+ 'addresses':relationship(Address, backref='user', lazy='joined'),
})
mapper(Address, addresses)
@testing.resolve_artifact_names
def test_joinedload_query_refreshes(self):
mapper(User, users, properties={
- 'addresses':relationship(Address, backref='user', lazy=False),
+ 'addresses':relationship(Address, backref='user', lazy='joined'),
})
mapper(Address, addresses)
@testing.resolve_artifact_names
def test_expire_all(self):
mapper(User, users, properties={
- 'addresses':relationship(Address, backref='user', lazy=False),
+ 'addresses':relationship(Address, backref='user', lazy='joined'),
})
mapper(Address, addresses)
def test_state_noload_to_lazy(self):
"""Behavioral test to verify the current activity of loader callables."""
- mapper(User, users, properties={'addresses':relationship(Address, lazy=None)})
+ mapper(User, users, properties={'addresses':relationship(Address, lazy='noload')})
mapper(Address, addresses)
sess = create_session()
"""test that a refresh/expire operation loads rows properly and sends correct "isnew" state to eager loaders"""
mapper(User, users, properties={
- 'addresses':relationship(mapper(Address, addresses), lazy=False)
+ 'addresses':relationship(mapper(Address, addresses), lazy='joined')
})
s = create_session()
s = create_session()
mapper(Address, addresses)
- mapper(User, users, properties = dict(addresses=relationship(Address,cascade="all, delete-orphan",lazy=False)) )
+ mapper(User, users, properties = dict(addresses=relationship(Address,cascade="all, delete-orphan",lazy='joined')) )
u = User()
u.name='Justin'
@testing.resolve_artifact_names
def test_basic(self):
mapper(User, users, properties={
- 'addresses':relationship(mapper(Address, addresses), lazy=True)
+ 'addresses':relationship(mapper(Address, addresses), lazy='select')
})
sess = create_session()
q = sess.query(User)
"""test the error raised when parent object is not bound."""
mapper(User, users, properties={
- 'addresses':relationship(mapper(Address, addresses), lazy=True)
+ 'addresses':relationship(mapper(Address, addresses), lazy='select')
})
sess = create_session()
q = sess.query(User)
@testing.resolve_artifact_names
def test_orderby(self):
mapper(User, users, properties = {
- 'addresses':relationship(mapper(Address, addresses), lazy=True, order_by=addresses.c.email_address),
+ 'addresses':relationship(mapper(Address, addresses), lazy='select', order_by=addresses.c.email_address),
})
q = create_session().query(User)
assert [
mapper(Address, addresses)
mapper(User, users, properties = dict(
- addresses = relationship(Address, lazy=True),
+ addresses = relationship(Address, lazy='select'),
))
q = create_session().query(User)
l = q.filter(users.c.id==addresses.c.user_id).order_by(addresses.c.email_address).all()
mapper(Address, addresses)
mapper(User, users, properties = dict(
- addresses = relationship(Address, lazy=True, order_by=[sa.desc(addresses.c.email_address)]),
+ addresses = relationship(Address, lazy='select', order_by=[sa.desc(addresses.c.email_address)]),
))
sess = create_session()
assert [
"""test that a lazily loaded child object is not marked as an orphan"""
mapper(User, users, properties={
- 'addresses':relationship(Address, cascade="all,delete-orphan", lazy=True)
+ 'addresses':relationship(Address, cascade="all,delete-orphan", lazy='select')
})
mapper(Address, addresses)
mapper(Item, items)
mapper(Order, orders, properties={
- 'items':relationship(Item, secondary=order_items, lazy=True)
+ 'items':relationship(Item, secondary=order_items, lazy='select')
})
mapper(User, users, properties={
- 'addresses':relationship(mapper(Address, addresses), lazy=True),
- 'orders':relationship(Order, lazy=True)
+ 'addresses':relationship(mapper(Address, addresses), lazy='select'),
+ 'orders':relationship(Order, lazy='select')
})
sess = create_session()
def test_distinct(self):
mapper(Item, items)
mapper(Order, orders, properties={
- 'items':relationship(Item, secondary=order_items, lazy=True)
+ 'items':relationship(Item, secondary=order_items, lazy='select')
})
mapper(User, users, properties={
- 'addresses':relationship(mapper(Address, addresses), lazy=True),
- 'orders':relationship(Order, lazy=True)
+ 'addresses':relationship(mapper(Address, addresses), lazy='select'),
+ 'orders':relationship(Order, lazy='select')
})
sess = create_session()
@testing.resolve_artifact_names
def test_one_to_many_scalar(self):
mapper(User, users, properties = dict(
- address = relationship(mapper(Address, addresses), lazy=True, uselist=False)
+ address = relationship(mapper(Address, addresses), lazy='select', uselist=False)
))
q = create_session().query(User)
l = q.filter(users.c.id == 7).all()
closed_mapper = mapper(Order, closedorders, non_primary=True)
mapper(User, users, properties = dict(
addresses = relationship(Address, lazy = True),
- open_orders = relationship(open_mapper, primaryjoin = sa.and_(openorders.c.isopen == 1, users.c.id==openorders.c.user_id), lazy=True),
- closed_orders = relationship(closed_mapper, primaryjoin = sa.and_(closedorders.c.isopen == 0, users.c.id==closedorders.c.user_id), lazy=True)
+ open_orders = relationship(open_mapper, primaryjoin = sa.and_(openorders.c.isopen == 1, users.c.id==openorders.c.user_id), lazy='select'),
+ closed_orders = relationship(closed_mapper, primaryjoin = sa.and_(closedorders.c.isopen == 0, users.c.id==closedorders.c.user_id), lazy='select')
))
q = create_session().query(User)
mapper(Keyword, keywords)
mapper(Item, items, properties = dict(
- keywords = relationship(Keyword, secondary=item_keywords, lazy=True),
+ keywords = relationship(Keyword, secondary=item_keywords, lazy='select'),
))
q = create_session().query(Item)
addresses.c.user_id==users.c.id
):
mapper(Address, addresses, properties = dict(
- user = relationship(mapper(User, users), lazy=True, primaryjoin=pj)
+ user = relationship(mapper(User, users), lazy='select', primaryjoin=pj)
))
sess = create_session()
@testing.resolve_artifact_names
def test_many_to_one(self):
mapper(Address, addresses, properties = dict(
- user = relationship(mapper(User, users), lazy=True)
+ user = relationship(mapper(User, users), lazy='select')
))
sess = create_session()
q = sess.query(Address)
Place.mapper, secondary=place_place, primaryjoin=place.c.place_id==place_place.c.pl1_id,
secondaryjoin=place.c.place_id==place_place.c.pl2_id,
order_by=place_place.c.pl2_id,
- lazy=True,
+ lazy='select',
))
sess = create_session()
two different association tables. aliases are required."""
Place.mapper = mapper(Place, place, properties = {
- 'thingies':relationship(mapper(PlaceThingy, place_thingy), lazy=False)
+ 'thingies':relationship(mapper(PlaceThingy, place_thingy), lazy='joined')
})
Transition.mapper = mapper(Transition, transition, properties = dict(
- inputs = relationship(Place.mapper, place_output, lazy=False),
- outputs = relationship(Place.mapper, place_input, lazy=False),
+ inputs = relationship(Place.mapper, place_output, lazy='joined'),
+ outputs = relationship(Place.mapper, place_input, lazy='joined'),
)
)
"""tests a many-to-many backrefs"""
Place.mapper = mapper(Place, place)
Transition.mapper = mapper(Transition, transition, properties = dict(
- inputs = relationship(Place.mapper, place_output, lazy=True, backref='inputs'),
- outputs = relationship(Place.mapper, place_input, lazy=True, backref='outputs'),
+ inputs = relationship(Place.mapper, place_output, lazy='select', backref='inputs'),
+ outputs = relationship(Place.mapper, place_input, lazy='select', backref='outputs'),
)
)
mapper(Student, student)
mapper(Course, course, properties = {
- 'students': relationship(Student, enroll, lazy=True,
+ 'students': relationship(Student, enroll, lazy='select',
backref='courses')})
sess = create_session()
mapper(A, a, properties={
'tbs': relationship(B, primaryjoin=sa.and_(b.c.a1 == a.c.a1,
b.c.b2 == True),
- lazy=False)})
+ lazy='joined')})
mapper(C, c, properties={
- 'a1s': relationship(A, secondary=c2a1, lazy=False),
- 'a2s': relationship(A, secondary=c2a2, lazy=False)})
+ 'a1s': relationship(A, secondary=c2a1, lazy='joined'),
+ 'a2s': relationship(A, secondary=c2a2, lazy='joined')})
assert create_session().query(C).with_labels().statement is not None
def test_many_to_many_count(self):
mapper(Keyword, keywords)
mapper(Item, items, properties=dict(
- keywords = relationship(Keyword, item_keywords, lazy=True)))
+ keywords = relationship(Keyword, item_keywords, lazy='select')))
session = create_session()
q = (session.query(Item).
uname = extendedproperty(_get_name, _set_name)
mapper(User, users, properties=dict(
- addresses = relationship(mapper(Address, addresses), lazy=True),
+ addresses = relationship(mapper(Address, addresses), lazy='select'),
uname = synonym('name'),
adlist = synonym('addresses'),
adname = synonym('addresses')
mapper(Address, addresses)
mapper(User, users, properties = {
- 'addresses':relationship(Address, lazy=True),
+ 'addresses':relationship(Address, lazy='select'),
'name':synonym('_name', map_column=True)
})
@testing.resolve_artifact_names
def test_synonym_options(self):
mapper(User, users, properties=dict(
- addresses = relationship(mapper(Address, addresses), lazy=True,
+ addresses = relationship(mapper(Address, addresses), lazy='select',
order_by=addresses.c.id),
adlist = synonym('addresses')))
@testing.resolve_artifact_names
def test_eager_options_with_limit(self):
mapper(User, users, properties=dict(
- addresses=relationship(mapper(Address, addresses), lazy=True)))
+ addresses=relationship(mapper(Address, addresses), lazy='select')))
sess = create_session()
u = (sess.query(User).
@testing.resolve_artifact_names
def test_lazy_options_with_limit(self):
mapper(User, users, properties=dict(
- addresses = relationship(mapper(Address, addresses), lazy=False)))
+ addresses = relationship(mapper(Address, addresses), lazy='joined')))
sess = create_session()
u = (sess.query(User).
def test_eager_degrade(self):
"""An eager relationship automatically degrades to a lazy relationship if eager columns are not available"""
mapper(User, users, properties=dict(
- addresses = relationship(mapper(Address, addresses), lazy=False)))
+ addresses = relationship(mapper(Address, addresses), lazy='joined')))
sess = create_session()
# first test straight eager load, 1 statement
mapper(Item, items, properties=dict(
keywords=relationship(Keyword, secondary=item_keywords,
- lazy=False,
+ lazy='joined',
order_by=item_keywords.c.keyword_id)))
mapper(Order, orders, properties=dict(
- items=relationship(Item, secondary=order_items, lazy=False,
+ items=relationship(Item, secondary=order_items, lazy='joined',
order_by=order_items.c.item_id)))
mapper(User, users, properties=dict(
- addresses=relationship(Address, lazy=False,
+ addresses=relationship(Address, lazy='joined',
order_by=addresses.c.id),
- orders=relationship(Order, lazy=False,
+ orders=relationship(Order, lazy='joined',
order_by=orders.c.id)))
sess = create_session()
def test_lazy_options(self):
"""An eager relationship can be upgraded to a lazy relationship."""
mapper(User, users, properties=dict(
- addresses = relationship(mapper(Address, addresses), lazy=False)
+ addresses = relationship(mapper(Address, addresses), lazy='joined')
))
sess = create_session()
def test_basic(self):
"""A basic one-to-many lazy load"""
m = mapper(User, users, properties=dict(
- addresses = relationship(mapper(Address, addresses), lazy=None)
+ addresses = relationship(mapper(Address, addresses), lazy='noload')
))
q = create_session().query(m)
l = [None]
@testing.resolve_artifact_names
def test_options(self):
m = mapper(User, users, properties=dict(
- addresses = relationship(mapper(Address, addresses), lazy=None)
+ addresses = relationship(mapper(Address, addresses), lazy='noload')
))
q = create_session().query(m).options(sa.orm.lazyload('addresses'))
l = [None]
"""test aliasing of joins with a custom join condition"""
mapper(Address, addresses)
mapper(Order, orders, properties={
- 'items':relationship(Item, secondary=order_items, lazy=True, order_by=items.c.id),
+ 'items':relationship(Item, secondary=order_items, lazy='select', order_by=items.c.id),
})
mapper(Item, items)
mapper(User, users, properties = dict(
- addresses = relationship(Address, lazy=True),
- open_orders = relationship(Order, primaryjoin = and_(orders.c.isopen == 1, users.c.id==orders.c.user_id), lazy=True),
- closed_orders = relationship(Order, primaryjoin = and_(orders.c.isopen == 0, users.c.id==orders.c.user_id), lazy=True)
+ addresses = relationship(Address, lazy='select'),
+ open_orders = relationship(Order, primaryjoin = and_(orders.c.isopen == 1, users.c.id==orders.c.user_id), lazy='select'),
+ closed_orders = relationship(Order, primaryjoin = and_(orders.c.isopen == 0, users.c.id==orders.c.user_id), lazy='select')
))
q = create_session().query(User)
self.children.append(node)
mapper(Node, nodes, properties={
- 'children':relationship(Node, lazy=True, join_depth=3,
+ 'children':relationship(Node, lazy='select', join_depth=3,
backref=backref('parent', remote_side=[nodes.c.id])
)
})
pass
mapper(Node, nodes, properties={
- 'children':relationship(Node, lazy=True, secondary=node_to_nodes,
+ 'children':relationship(Node, lazy='select', secondary=node_to_nodes,
primaryjoin=nodes.c.id==node_to_nodes.c.left_node_id,
secondaryjoin=nodes.c.id==node_to_nodes.c.right_node_id,
)
def setup_mappers(cls):
mapper(User, users)
mapper(Document, documents, properties={
- 'user': relationship(User, lazy=False, backref=backref('documents', lazy=True))
+ 'user': relationship(User, lazy='joined', backref=backref('documents', lazy='select'))
})
@testing.resolve_artifact_names
primaryjoin=sa.and_(pages.c.jobno==pageversions.c.jobno,
pages.c.pagename==pageversions.c.pagename),
order_by=pageversions.c.version,
- backref=backref('page',lazy=False)
+ backref=backref('page',lazy='joined')
)})
mapper(PageComment, pagecomments, properties={
'page': relationship(
order_by=sa.asc(container_select.c.type),
properties=dict(
lineItems=relationship(LineItem,
- lazy=True,
+ lazy='select',
cascade='all, delete-orphan',
order_by=sa.asc(items.c.id),
primaryjoin=sa.and_(
'addresses':relationship(mapper(Address, addresses),
lazy='subquery',
order_by=addresses.c.id),
- 'orders':relationship(Order, lazy=True, order_by=orders.c.id)
+ 'orders':relationship(Order, lazy='select', order_by=orders.c.id)
})
sess = create_session()
def test_backref(self):
am = mapper(Address, addresses)
m = mapper(User, users, properties=dict(
- addresses = relationship(am, backref='user', lazy=False)))
+ addresses = relationship(am, backref='user', lazy='joined')))
session = create_session(autocommit=False)
"""Basic save of one to many."""
m = mapper(User, users, properties=dict(
- addresses = relationship(mapper(Address, addresses), lazy=True)
+ addresses = relationship(mapper(Address, addresses), lazy='select')
))
u = User(name= 'one2manytester')
a = Address(email_address='one2many@test.org')
"""Modifying the child items of an object."""
m = mapper(User, users, properties=dict(
- addresses = relationship(mapper(Address, addresses), lazy=True)))
+ addresses = relationship(mapper(Address, addresses), lazy='select')))
u1 = User(name='user1')
u1.addresses = []
"""
m = mapper(User, users, properties=dict(
- addresses = relationship(mapper(Address, addresses), lazy=True)))
+ addresses = relationship(mapper(Address, addresses), lazy='select')))
u1 = User(name='user1')
u2 = User(name='user2')
@testing.resolve_artifact_names
def test_child_move_2(self):
m = mapper(User, users, properties=dict(
- addresses = relationship(mapper(Address, addresses), lazy=True)))
+ addresses = relationship(mapper(Address, addresses), lazy='select')))
u1 = User(name='user1')
u2 = User(name='user2')
def test_o2m_delete_parent(self):
m = mapper(User, users, properties=dict(
address = relationship(mapper(Address, addresses),
- lazy=True,
+ lazy='select',
uselist=False)))
u = User(name='one2onetester')
def test_one_to_one(self):
m = mapper(User, users, properties=dict(
address = relationship(mapper(Address, addresses),
- lazy=True,
+ lazy='select',
uselist=False)))
u = User(name='one2onetester')
def test_bidirectional(self):
m1 = mapper(User, users)
m2 = mapper(Address, addresses, properties=dict(
- user = relationship(m1, lazy=False, backref='addresses')))
+ user = relationship(m1, lazy='joined', backref='addresses')))
u = User(name='test')
def test_m2o_one_to_one(self):
# TODO: put assertion in here !!!
m = mapper(Address, addresses, properties=dict(
- user = relationship(mapper(User, users), lazy=True, uselist=False)))
+ user = relationship(mapper(User, users), lazy='select', uselist=False)))
session = create_session()
@testing.resolve_artifact_names
def test_many_to_one_1(self):
m = mapper(Address, addresses, properties=dict(
- user = relationship(mapper(User, users), lazy=True)))
+ user = relationship(mapper(User, users), lazy='select')))
a1 = Address(email_address='emailaddress1')
u1 = User(name='user1')
@testing.resolve_artifact_names
def test_many_to_one_2(self):
m = mapper(Address, addresses, properties=dict(
- user = relationship(mapper(User, users), lazy=True)))
+ user = relationship(mapper(User, users), lazy='select')))
a1 = Address(email_address='emailaddress1')
a2 = Address(email_address='emailaddress2')
@testing.resolve_artifact_names
def test_many_to_one_3(self):
m = mapper(Address, addresses, properties=dict(
- user = relationship(mapper(User, users), lazy=True)))
+ user = relationship(mapper(User, users), lazy='select')))
a1 = Address(email_address='emailaddress1')
u1 = User(name='user1')
@testing.resolve_artifact_names
def test_bidirectional_no_load(self):
mapper(User, users, properties={
- 'addresses':relationship(Address, backref='user', lazy=None)})
+ 'addresses':relationship(Address, backref='user', lazy='noload')})
mapper(Address, addresses)
# try it on unsaved objects
m = mapper(Item, items, properties=dict(
keywords=relationship(Keyword,
item_keywords,
- lazy=False,
+ lazy='joined',
order_by=keywords.c.name)))
data = [Item,
"""
mapper(Keyword, keywords)
mapper(Item, items, properties=dict(
- keywords = relationship(Keyword, item_keywords, lazy=False),
+ keywords = relationship(Keyword, item_keywords, lazy='joined'),
))
i = Item(description='i1')
mapper(Item, items, properties=dict(
keywords=relationship(Keyword,
secondary=item_keywords,
- lazy=False,
+ lazy='joined',
order_by=keywords.c.name)))
k1 = Keyword(name='keyword 1')
primary_key=[item_keywords.c.item_id, item_keywords.c.keyword_id],
properties=dict(
keyword=relationship(mapper(Keyword, keywords, non_primary=True),
- lazy=False,
+ lazy='joined',
uselist=False,
order_by=keywords.c.name # note here is a valid place where order_by can be used
))) # on a scalar relationship(); to determine eager ordering of
# the parent object within its collection.
mapper(Item, items, properties=dict(
- keywords=relationship(IKAssociation, lazy=False)))
+ keywords=relationship(IKAssociation, lazy='joined')))
session = create_session()
def test_m2o_nonmatch(self):
mapper(User, users)
mapper(Address, addresses, properties=dict(
- user = relationship(User, lazy=True, uselist=False)))
+ user = relationship(User, lazy='select', uselist=False)))
session = create_session()
mapper(Keyword, keywords)
mapper(Item, items, properties=dict(
- keywords = relationship(Keyword, secondary=assoc, lazy=False),))
+ keywords = relationship(Keyword, secondary=assoc, lazy='joined'),))
i = Item()
k1 = Keyword()
class Item(object):pass
class SubItem(object):pass
-mapper(Item, items, properties={'subs':relationship(SubItem, lazy=False)})
+mapper(Item, items, properties={'subs':relationship(SubItem, lazy='joined')})
mapper(SubItem, subitems)
def load():
getattr(self, 'address', None))
mapper(Person, Person_table, properties={
- 'emails': relationship(Email, backref='owner', lazy=False)
+ 'emails': relationship(Email, backref='owner', lazy='joined')
})
mapper(Email, Email_table)
compile_mappers()
@profiled('mapper')
def setup_mappers():
mapper(Item, items, properties={
- 'subitems': relationship(SubItem, backref='item', lazy=True)
+ 'subitems': relationship(SubItem, backref='item', lazy='select')
})
mapper(SubItem, subitems)
mapper(Customer, customers, properties={
- 'purchases': relationship(Purchase, lazy=True, backref='customer')
+ 'purchases': relationship(Purchase, lazy='select', backref='customer')
})
mapper(Purchase, purchases, properties={
- 'items': relationship(Item, lazy=True, secondary=purchaseitems)
+ 'items': relationship(Item, lazy='select', secondary=purchaseitems)
})
@profiled('inserts')
# ways. this will also attach a 'blogs' property to the user mapper.
mapper(Blog, tables.blogs, properties={
'id':tables.blogs.c.blog_id,
- 'owner':relationship(user.User, lazy=False,
+ 'owner':relationship(user.User, lazy='joined',
backref=backref('blogs', cascade="all, delete-orphan")),
})
primary_key=[tables.topic_xref.c.post_id,
tables.topic_xref.c.topic_id],
properties={
- 'topic':relationship(Topic, lazy=False),
+ 'topic':relationship(Topic, lazy='joined'),
})
# Post mapper, these are posts within a blog.
mapper(Post, posts_with_ccount, properties={
'id':posts_with_ccount.c.post_id,
'body':deferred(tables.posts.c.body),
- 'user':relationship(user.User, lazy=True,
+ 'user':relationship(user.User, lazy='select',
backref=backref('posts', cascade="all, delete-orphan")),
- 'blog':relationship(Blog, lazy=True,
+ 'blog':relationship(Blog, lazy='select',
backref=backref('posts', cascade="all, delete-orphan")),
- 'topics':relationship(TopicAssociation, lazy=False,
+ 'topics':relationship(TopicAssociation, lazy='joined',
cascade="all, delete-orphan",
backref='post')
}, order_by=[desc(posts_with_ccount.c.datetime)])
# list of child comments.
mapper(Comment, tables.comments, properties={
'id':tables.comments.c.comment_id,
- 'post':relationship(Post, lazy=True,
+ 'post':relationship(Post, lazy='select',
backref=backref('comments',
cascade="all, delete-orphan")),
- 'user':relationship(user.User, lazy=False,
+ 'user':relationship(user.User, lazy='joined',
backref=backref('comments',
cascade="all, delete-orphan")),
'parent':relationship(Comment,
primaryjoin=(tables.comments.c.parent_comment_id ==
tables.comments.c.comment_id),
foreign_keys=[tables.comments.c.comment_id],
- lazy=True, uselist=False),
+ lazy='select', uselist=False),
'replies':relationship(Comment,
primaryjoin=(tables.comments.c.parent_comment_id ==
tables.comments.c.comment_id),
- lazy=True, uselist=True, cascade="all"),
+ lazy='select', uselist=True, cascade="all"),
})
# we define one special find-by for the comments of a post, which is going to
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
