def setup_loader(self, instance, options=None):
if not mapper.has_mapper(instance):
return None
else:
prop = mapper.object_mapper(instance).props[self.key]
if prop is not self.parent_property:
return prop._get_strategy(LazyLoader).setup_loader(instance)
def lazyload():
self.logger.debug("lazy load attribute %s on instance %s" % (self.key, mapperutil.instance_str(instance)))
params = {}
allparams = True
# if the instance wasnt loaded from the database, then it cannot lazy load
# child items. one reason for this is that a bi-directional relationship
# will not update properly, since bi-directional uses lazy loading functions
# in both directions, and this instance will not be present in the lazily-loaded
# results of the other objects since its not in the database
if not mapper.has_identity(instance):
return None
#print "setting up loader, lazywhere", str(self.lazywhere), "binds", self.lazybinds
for col, bind in self.lazybinds.iteritems():
params[bind.key] = self.parent.get_attr_by_column(instance, col)
if params[bind.key] is None:
allparams = False
break
if not allparams:
return None
session = sessionlib.object_session(instance)
if session is None:
try:
session = mapper.object_mapper(instance).get_session()
except exceptions.InvalidRequestError:
raise exceptions.InvalidRequestError("Parent instance %s is not bound to a Session, and no contextual session is established; lazy load operation of attribute '%s' cannot proceed" % (instance.__class__, self.key))
# if we have a simple straight-primary key load, use mapper.get()
# to possibly save a DB round trip
if self.use_get:
ident = []
for primary_key in self.select_mapper.pks_by_table[self.select_mapper.mapped_table]:
bind = self.lazyreverse[primary_key]
ident.append(params[bind.key])
return session.query(self.mapper).get(ident)
elif self.order_by is not False:
order_by = self.order_by
elif self.secondary is not None and self.secondary.default_order_by() is not None:
order_by = self.secondary.default_order_by()
else:
order_by = False
result = session.query(self.mapper, with_options=options).select_whereclause(self.lazywhere, order_by=order_by, params=params)
if self.uselist:
return result
else:
if len(result):
return result[0]
else:
return None
return lazyload
def setup_loader(self, instance, options=None):
if not mapper.has_mapper(instance):
return None
else:
prop = mapper.object_mapper(instance).props[self.key]
if prop is not self.parent_property:
return prop._get_strategy(DeferredColumnLoader).setup_loader(instance)
def lazyload():
if self._should_log_debug:
self.logger.debug("deferred load %s group %s" % (mapperutil.attribute_str(instance, self.key), str(self.group)))
if not mapper.has_identity(instance):
return None
try:
pk = self.parent.pks_by_table[self.columns[0].table]
except KeyError:
pk = self.columns[0].table.primary_key
clause = sql.and_()
for primary_key in pk:
attr = self.parent.get_attr_by_column(instance, primary_key)
if not attr:
return None
clause.clauses.append(primary_key == attr)
session = sessionlib.object_session(instance)
if session is None:
raise exceptions.InvalidRequestError("Parent instance %s is not bound to a Session; deferred load operation of attribute '%s' cannot proceed" % (instance.__class__, self.key))
localparent = mapper.object_mapper(instance)
if self.group is not None:
groupcols = [p for p in localparent.props.values() if isinstance(p.strategy, DeferredColumnLoader) and p.group==self.group]
result = session.execute(localparent, sql.select([g.columns[0] for g in groupcols], clause, use_labels=True), None)
try:
row = result.fetchone()
for prop in groupcols:
if prop is self:
continue
# set a scalar object instance directly on the object,
# bypassing SmartProperty event handlers.
sessionlib.attribute_manager.init_instance_attribute(instance, prop.key, uselist=False)
instance.__dict__[prop.key] = row[prop.columns[0]]
return row[self.columns[0]]
finally:
result.close()
else:
return session.scalar(localparent, sql.select([self.columns[0]], clause, use_labels=True),None)
return lazyload
def class_level_loader(self, instance, options=None, path=None):
if not mapper.has_mapper(instance):
return None
localparent = mapper.object_mapper(instance)
# adjust for the PropertyLoader associated with the instance
# not being our own PropertyLoader. This can occur when entity_name
# mappers are used to map different versions of the same PropertyLoader
# to the class.
prop = localparent.get_property(self.key)
if prop is not self.parent_property:
return prop._get_strategy(LazyLoader).setup_loader(instance)
return LoadLazyAttribute(instance, self.key, options, path)
def class_level_loader(self, instance, options=None, path=None):
if not mapper.has_mapper(instance):
return None
localparent = mapper.object_mapper(instance)
# adjust for the PropertyLoader associated with the instance
# not being our own PropertyLoader. This can occur when entity_name
# mappers are used to map different versions of the same PropertyLoader
# to the class.
prop = localparent.get_property(self.key)
if prop is not self.parent_property:
return prop._get_strategy(LazyLoader).setup_loader(instance)
return LoadLazyAttribute(instance, self.key, options, path)
def class_level_loader(self, instance, props=None):
if not mapper.has_mapper(instance):
return None
localparent = mapper.object_mapper(instance)
# adjust for the ColumnProperty associated with the instance
# not being our own ColumnProperty. This can occur when entity_name
# mappers are used to map different versions of the same ColumnProperty
# to the class.
prop = localparent.get_property(self.key)
if prop is not self.parent_property:
return prop._get_strategy(DeferredColumnLoader).setup_loader(instance)
return LoadDeferredColumns(instance, self.key, props)
def class_level_loader(self, instance, props=None):
if not mapper.has_mapper(instance):
return None
localparent = mapper.object_mapper(instance)
# adjust for the ColumnProperty associated with the instance
# not being our own ColumnProperty. This can occur when entity_name
# mappers are used to map different versions of the same ColumnProperty
# to the class.
prop = localparent.get_property(self.key)
if prop is not self.parent_property:
return prop._get_strategy(DeferredColumnLoader).setup_loader(instance)
return LoadDeferredColumns(instance, self.key, props)
def setup_loader(self, instance, options=None):
if not mapper.has_mapper(instance):
return None
else:
prop = mapper.object_mapper(instance).props[self.key]
if prop is not self.parent_property:
return prop._get_strategy(DeferredColumnLoader).setup_loader(
instance)
def lazyload():
if self._should_log_debug:
self.logger.debug("deferred load %s group %s" %
(mapperutil.attribute_str(
instance, self.key), str(self.group)))
if not mapper.has_identity(instance):
return None
try:
pk = self.parent.pks_by_table[self.columns[0].table]
except KeyError:
pk = self.columns[0].table.primary_key
clause = sql.and_()
for primary_key in pk:
attr = self.parent.get_attr_by_column(instance, primary_key)
if not attr:
return None
clause.clauses.append(primary_key == attr)
session = sessionlib.object_session(instance)
if session is None:
raise exceptions.InvalidRequestError(
"Parent instance %s is not bound to a Session; deferred load operation of attribute '%s' cannot proceed"
% (instance.__class__, self.key))
localparent = mapper.object_mapper(instance)
if self.group is not None:
groupcols = [
p for p in localparent.props.values()
if isinstance(p.strategy, DeferredColumnLoader)
and p.group == self.group
]
result = session.execute(
localparent,
sql.select([g.columns[0] for g in groupcols],
clause,
use_labels=True), None)
try:
row = result.fetchone()
for prop in groupcols:
if prop is self:
continue
# set a scalar object instance directly on the object,
# bypassing SmartProperty event handlers.
sessionlib.attribute_manager.init_instance_attribute(
instance, prop.key, uselist=False)
instance.__dict__[prop.key] = row[prop.columns[0]]
return row[self.columns[0]]
finally:
result.close()
else:
return session.scalar(
localparent,
sql.select([self.columns[0]], clause, use_labels=True),
None)
return lazyload
def setup_loader(self, instance, options=None):
if not mapper.has_mapper(instance):
return None
else:
prop = mapper.object_mapper(instance).props[self.key]
if prop is not self.parent_property:
return prop._get_strategy(LazyLoader).setup_loader(instance)
def lazyload():
self.logger.debug("lazy load attribute %s on instance %s" %
(self.key, mapperutil.instance_str(instance)))
params = {}
allparams = True
# if the instance wasnt loaded from the database, then it cannot lazy load
# child items. one reason for this is that a bi-directional relationship
# will not update properly, since bi-directional uses lazy loading functions
# in both directions, and this instance will not be present in the lazily-loaded
# results of the other objects since its not in the database
if not mapper.has_identity(instance):
return None
#print "setting up loader, lazywhere", str(self.lazywhere), "binds", self.lazybinds
for col, bind in self.lazybinds.iteritems():
params[bind.key] = self.parent.get_attr_by_column(
instance, col)
if params[bind.key] is None:
allparams = False
break
if not allparams:
return None
session = sessionlib.object_session(instance)
if session is None:
try:
session = mapper.object_mapper(instance).get_session()
except exceptions.InvalidRequestError:
raise exceptions.InvalidRequestError(
"Parent instance %s is not bound to a Session, and no contextual session is established; lazy load operation of attribute '%s' cannot proceed"
% (instance.__class__, self.key))
# if we have a simple straight-primary key load, use mapper.get()
# to possibly save a DB round trip
if self.use_get:
ident = []
for primary_key in self.select_mapper.pks_by_table[
self.select_mapper.mapped_table]:
bind = self.lazyreverse[primary_key]
ident.append(params[bind.key])
return session.query(self.mapper).get(ident)
elif self.order_by is not False:
order_by = self.order_by
elif self.secondary is not None and self.secondary.default_order_by(
) is not None:
order_by = self.secondary.default_order_by()
else:
order_by = False
result = session.query(self.mapper,
with_options=options).select_whereclause(
self.lazywhere,
order_by=order_by,
params=params)
if self.uselist:
return result
else:
if len(result):
return result[0]
else:
return None
return lazyload
def setup_loader(self, instance, options=None):
if not mapper.has_mapper(instance):
return None
else:
# adjust for the PropertyLoader associated with the instance
# not being our own PropertyLoader. This can occur when entity_name
# mappers are used to map different versions of the same PropertyLoader
# to the class.
prop = mapper.object_mapper(instance).get_property(self.key)
if prop is not self.parent_property:
return prop._get_strategy(LazyLoader).setup_loader(instance)
def lazyload():
if self._should_log_debug:
self.logger.debug(
"lazy load attribute %s on instance %s" %
(self.key, mapperutil.instance_str(instance)))
if not mapper.has_identity(instance):
return None
session = sessionlib.object_session(instance)
if session is None:
try:
session = mapper.object_mapper(instance).get_session()
except exceptions.InvalidRequestError:
raise exceptions.InvalidRequestError(
"Parent instance %s is not bound to a Session, and no contextual session is established; lazy load operation of attribute '%s' cannot proceed"
% (instance.__class__, self.key))
# if we have a simple straight-primary key load, use mapper.get()
# to possibly save a DB round trip
q = session.query(self.mapper).autoflush(False)
if self.use_get:
params = {}
for col, bind in self.lazybinds.iteritems():
params[bind.key] = self.parent.get_attr_by_column(
instance, col)
ident = []
nonnulls = False
for primary_key in self.select_mapper.primary_key:
bind = self.lazyreverse[primary_key]
v = params[bind.key]
if v is not None:
nonnulls = True
ident.append(v)
if not nonnulls:
return None
if options:
q = q.options(*options)
return q.get(ident)
elif self.order_by is not False:
q = q.order_by(self.order_by)
elif self.secondary is not None and self.secondary.default_order_by(
) is not None:
q = q.order_by(self.secondary.default_order_by())
if options:
q = q.options(*options)
q = q.filter(self.lazy_clause(instance))
result = q.all()
if self.uselist:
return result
else:
if result:
return result[0]
else:
return None
return lazyload
