def __call__(self):
if not mapper.has_identity(self.instance):
return None
localparent = mapper.object_mapper(self.instance, raiseerror=False)
prop = localparent.get_property(self.key)
strategy = prop._get_strategy(DeferredColumnLoader)
if self.keys:
toload = self.keys
elif strategy.group:
toload = [p.key for p in localparent.iterate_properties if isinstance(p.strategy, DeferredColumnLoader) and p.group==strategy.group]
else:
toload = [self.key]
# narrow the keys down to just those which have no history
group = [k for k in toload if k in self.instance._state.unmodified]
if strategy._should_log_debug:
strategy.logger.debug("deferred load %s group %s" % (mapperutil.attribute_str(self.instance, self.key), group and ','.join(group) or 'None'))
session = sessionlib.object_session(self.instance)
if session is None:
raise exceptions.UnboundExecutionError("Parent instance %s is not bound to a Session; deferred load operation of attribute '%s' cannot proceed" % (self.instance.__class__, self.key))
query = session.query(localparent)
if not self.optimizing_statement:
ident = self.instance._instance_key[1]
query._get(None, ident=ident, only_load_props=group, refresh_instance=self.instance._state)
else:
statement, params = self.optimizing_statement(self.instance)
query.from_statement(statement).params(params)._get(None, only_load_props=group, refresh_instance=self.instance._state)
return attributes.ATTR_WAS_SET
def __call__(self):
state = self.state
if not mapper._state_has_identity(state):
return None
instance_mapper = mapper._state_mapper(state)
prop = instance_mapper.get_property(self.key)
strategy = prop._get_strategy(LazyLoader)
if strategy._should_log_debug:
strategy.logger.debug(
"loading %s" % mapperutil.state_attribute_str(state, self.key))
session = sessionlib._state_session(state)
if session is None:
raise sa_exc.UnboundExecutionError(
"Parent instance %s is not bound to a Session; "
"lazy load operation of attribute '%s' cannot proceed" %
(mapperutil.state_str(state), self.key))
q = session.query(prop.mapper)._adapt_all_clauses()
if self.path:
q = q._with_current_path(self.path)
# if we have a simple primary key load, use mapper.get()
# to possibly save a DB round trip
if strategy.use_get:
ident = []
allnulls = True
for primary_key in prop.mapper.primary_key:
val = instance_mapper._get_committed_state_attr_by_column(
state, strategy._equated_columns[primary_key])
allnulls = allnulls and val is None
ident.append(val)
if allnulls:
return None
if self.options:
q = q._conditional_options(*self.options)
return q.get(ident)
if prop.order_by:
q = q.order_by(*util.to_list(prop.order_by))
if self.options:
q = q._conditional_options(*self.options)
q = q.filter(strategy.lazy_clause(state))
result = q.all()
if strategy.uselist:
return result
else:
if result:
return result[0]
else:
return None
def __call__(self):
instance = self.instance
if not mapper.has_identity(instance):
return None
instance_mapper = mapper.object_mapper(instance)
prop = instance_mapper.get_property(self.key)
strategy = prop._get_strategy(LazyLoader)
if strategy._should_log_debug:
strategy.logger.debug("lazy load attribute %s on instance %s" % (self.key, mapperutil.instance_str(instance)))
session = sessionlib.object_session(instance)
if session is None:
try:
session = instance_mapper.get_session()
except exceptions.InvalidRequestError:
raise exceptions.UnboundExecutionError("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))
q = session.query(prop.mapper).autoflush(False)
if self.path:
q = q._with_current_path(self.path)
# if we have a simple primary key load, use mapper.get()
# to possibly save a DB round trip
if strategy.use_get:
ident = []
allnulls = True
for primary_key in prop.mapper.primary_key:
val = instance_mapper._get_committed_attr_by_column(instance, strategy._equated_columns[primary_key])
allnulls = allnulls and val is None
ident.append(val)
if allnulls:
return None
if self.options:
q = q._conditional_options(*self.options)
return q.get(ident)
if strategy.order_by is not False:
q = q.order_by(strategy.order_by)
elif strategy.secondary is not None and strategy.secondary.default_order_by() is not None:
q = q.order_by(strategy.secondary.default_order_by())
if self.options:
q = q._conditional_options(*self.options)
q = q.filter(strategy.lazy_clause(instance))
result = q.all()
if strategy.uselist:
return result
else:
if result:
return result[0]
else:
return None
def _clone(self, sess=None):
# note we're returning an entirely new Query class instance here
# without any assignment capabilities;
# the class of this query is determined by the session.
instance = self.instance
if sess is None:
sess = object_session(instance)
if sess is None:
try:
sess = object_mapper(instance).get_session()
except exceptions.InvalidRequestError:
raise exceptions.UnboundExecutionError(
"Parent instance %s is not bound to a Session, and no contextual session is established; lazy load operation of attribute '%s' cannot proceed"
% (mapperutil.instance_str(instance), self.attr.key))
return sess.query(self.attr.target_mapper).with_parent(
instance, self.attr.key)
def __call__(self):
state = self.state
if not mapper._state_has_identity(state):
return None
localparent = mapper._state_mapper(state)
prop = localparent.get_property(self.key)
strategy = prop._get_strategy(DeferredColumnLoader)
if self.keys:
toload = self.keys
elif strategy.group:
toload = [
p.key for p in localparent.iterate_properties
if isinstance(p, StrategizedProperty)
and isinstance(p.strategy, DeferredColumnLoader)
and p.group == strategy.group
]
else:
toload = [self.key]
# narrow the keys down to just those which have no history
group = [k for k in toload if k in state.unmodified]
if strategy._should_log_debug:
strategy.logger.debug(
"deferred load %s group %s" % (mapperutil.state_attribute_str(
state, self.key), group and ','.join(group) or 'None'))
session = sessionlib._state_session(state)
if session is None:
raise sa_exc.UnboundExecutionError(
"Parent instance %s is not bound to a Session; deferred load operation of attribute '%s' cannot proceed"
% (mapperutil.state_str(state), self.key))
query = session.query(localparent)
ident = state.key[1]
query._get(None,
ident=ident,
only_load_props=group,
refresh_state=state)
return attributes.ATTR_WAS_SET
def _clone(self, sess=None):
# note we're returning an entirely new Query class instance
# here without any assignment capabilities; the class of this
# query is determined by the session.
instance = self.instance
if sess is None:
sess = object_session(instance)
if sess is None:
raise sa_exc.UnboundExecutionError(
"Parent instance %s is not bound to a Session, and no "
"contextual session is established; lazy load operation "
"of attribute '%s' cannot proceed" % (
mapperutil.instance_str(instance), self.attr.key))
if self.query_class:
query = self.query_class(self.attr.target_mapper, session=sess)
else:
query = sess.query(self.attr.target_mapper)
query = query.with_parent(instance, self.attr.key)
if self.attr.order_by:
query = query.order_by(self.attr.order_by)
return query
