from ..sql import util as sql_util, visitors
from .. import sql
from . import (
- attributes, interfaces, exc as orm_exc, loading,
- unitofwork, util as orm_util
- )
+ attributes, interfaces, exc as orm_exc, loading,
+ unitofwork, util as orm_util
+)
from .state import InstanceState
from .util import _none_set
from . import properties
from .session import _state_session
import itertools
-def _register_attribute(strategy, mapper, useobject,
- compare_function=None,
- typecallable=None,
- uselist=False,
- callable_=None,
- proxy_property=None,
- active_history=False,
- impl_class=None,
- **kw
+
+def _register_attribute(
+ strategy, mapper, useobject,
+ compare_function=None,
+ typecallable=None,
+ uselist=False,
+ callable_=None,
+ proxy_property=None,
+ active_history=False,
+ impl_class=None,
+ **kw
):
prop = strategy.parent_property
for hook in listen_hooks:
hook(desc, prop)
+
@properties.ColumnProperty.strategy_for(instrument=False, deferred=False)
class UninstrumentedColumnLoader(LoaderStrategy):
"""Represent the a non-instrumented MapperProperty.
self.columns = self.parent_property.columns
def setup_query(self, context, entity, path, loadopt, adapter,
- column_collection=None, **kwargs):
+ column_collection=None, **kwargs):
for c in self.columns:
if adapter:
c = adapter.columns[c]
column_collection.append(c)
- def create_row_processor(self, context, path, loadopt, mapper, row, adapter):
+ def create_row_processor(self, context, path, loadopt,
+ mapper, row, adapter):
return None, None, None
self.is_composite = hasattr(self.parent_property, 'composite_class')
def setup_query(self, context, entity, path, loadopt,
- adapter, column_collection, **kwargs):
+ adapter, column_collection, **kwargs):
for c in self.columns:
if adapter:
c = adapter.columns[c]
coltype = self.columns[0].type
# TODO: check all columns ? check for foreign key as well?
active_history = self.parent_property.active_history or \
- self.columns[0].primary_key or \
- mapper.version_id_col in set(self.columns)
+ self.columns[0].primary_key or \
+ mapper.version_id_col in set(self.columns)
- _register_attribute(self, mapper, useobject=False,
+ _register_attribute(
+ self, mapper, useobject=False,
compare_function=coltype.compare_values,
active_history=active_history
- )
+ )
def create_row_processor(self, context, path,
- loadopt, mapper, row, adapter):
+ loadopt, mapper, row, adapter):
key = self.key
# look through list of columns represented here
# to see which, if any, is present in the row.
return expire_for_non_present_col, None, None
-
@log.class_logger
@properties.ColumnProperty.strategy_for(deferred=True, instrument=True)
class DeferredColumnLoader(LoaderStrategy):
self.columns = self.parent_property.columns
self.group = self.parent_property.group
- def create_row_processor(self, context, path, loadopt, mapper, row, adapter):
+ def create_row_processor(self, context, path, loadopt,
+ mapper, row, adapter):
col = self.columns[0]
if adapter:
col = adapter.columns[col]
key = self.key
if col in row:
return self.parent_property._get_strategy_by_cls(ColumnLoader).\
- create_row_processor(
- context, path, loadopt, mapper, row, adapter)
+ create_row_processor(
+ context, path, loadopt, mapper, row, adapter)
elif not self.is_class_level:
set_deferred_for_local_state = InstanceState._row_processor(
- mapper.class_manager,
- LoadDeferredColumns(key), key)
+ mapper.class_manager,
+ LoadDeferredColumns(key), key)
return set_deferred_for_local_state, None, None
else:
def reset_col_for_deferred(state, dict_, row):
def init_class_attribute(self, mapper):
self.is_class_level = True
- _register_attribute(self, mapper, useobject=False,
- compare_function=self.columns[0].type.compare_values,
- callable_=self._load_for_state,
- expire_missing=False
+ _register_attribute(
+ self, mapper, useobject=False,
+ compare_function=self.columns[0].type.compare_values,
+ callable_=self._load_for_state,
+ expire_missing=False
)
def setup_query(self, context, entity, path, loadopt, adapter,
- only_load_props=None, **kwargs):
+ only_load_props=None, **kwargs):
if (
(
)
):
self.parent_property._get_strategy_by_cls(ColumnLoader).\
- setup_query(context, entity,
- path, loadopt, adapter, **kwargs)
+ setup_query(context, entity,
+ path, loadopt, adapter, **kwargs)
def _load_for_state(self, state, passive):
if not state.key:
if self.group:
toload = [
- p.key for p in
- localparent.iterate_properties
- if isinstance(p, StrategizedProperty) and
- isinstance(p.strategy, DeferredColumnLoader) and
- p.group == self.group
- ]
+ p.key for p in
+ localparent.iterate_properties
+ if isinstance(p, StrategizedProperty) and
+ isinstance(p.strategy, DeferredColumnLoader) and
+ p.group == self.group
+ ]
else:
toload = [self.key]
return attributes.ATTR_WAS_SET
-
class LoadDeferredColumns(object):
"""serializable loader object used by DeferredColumnLoader"""
return strategy._load_for_state(state, passive)
-
class AbstractRelationshipLoader(LoaderStrategy):
"""LoaderStratgies which deal with related objects."""
self.uselist = self.parent_property.uselist
-
@log.class_logger
@properties.RelationshipProperty.strategy_for(lazy="noload")
@properties.RelationshipProperty.strategy_for(lazy=None)
def init_class_attribute(self, mapper):
self.is_class_level = True
- _register_attribute(self, mapper,
+ _register_attribute(
+ self, mapper,
useobject=True,
uselist=self.parent_property.uselist,
typecallable=self.parent_property.collection_class,
)
- def create_row_processor(self, context, path, loadopt, mapper, row, adapter):
+ def create_row_processor(self, context, path, loadopt, mapper,
+ row, adapter):
def invoke_no_load(state, dict_, row):
state._initialize(self.key)
return invoke_no_load, None, None
-
@log.class_logger
@properties.RelationshipProperty.strategy_for(lazy=True)
@properties.RelationshipProperty.strategy_for(lazy="select")
super(LazyLoader, self).__init__(parent)
join_condition = self.parent_property._join_condition
self._lazywhere, \
- self._bind_to_col, \
- self._equated_columns = join_condition.create_lazy_clause()
+ self._bind_to_col, \
+ self._equated_columns = join_condition.create_lazy_clause()
self._rev_lazywhere, \
- self._rev_bind_to_col, \
- self._rev_equated_columns = join_condition.create_lazy_clause(
- reverse_direction=True)
+ self._rev_bind_to_col, \
+ self._rev_equated_columns = join_condition.create_lazy_clause(
+ reverse_direction=True)
self.logger.info("%s lazy loading clause %s", self, self._lazywhere)
# determine if our "lazywhere" clause is the same as the mapper's
# get() clause. then we can just use mapper.get()
self.use_get = not self.uselist and \
- self.mapper._get_clause[0].compare(
- self._lazywhere,
- use_proxies=True,
- equivalents=self.mapper._equivalent_columns
- )
+ self.mapper._get_clause[0].compare(
+ self._lazywhere,
+ use_proxies=True,
+ equivalents=self.mapper._equivalent_columns
+ )
if self.use_get:
for col in list(self._equated_columns):
self._equated_columns[c] = self._equated_columns[col]
self.logger.info("%s will use query.get() to "
- "optimize instance loads" % self)
+ "optimize instance loads" % self)
def init_class_attribute(self, mapper):
self.is_class_level = True
# will enable active_history
# in that case. otherwise we don't need the
# "old" value during backref operations.
- _register_attribute(self,
+ _register_attribute(
+ self,
mapper,
useobject=True,
callable_=self._load_for_state,
)
def lazy_clause(self, state, reverse_direction=False,
- alias_secondary=False,
- adapt_source=None,
- passive=None):
+ alias_secondary=False,
+ adapt_source=None,
+ passive=None):
if state is None:
return self._lazy_none_clause(
- reverse_direction,
- adapt_source=adapt_source)
+ reverse_direction,
+ adapt_source=adapt_source)
if not reverse_direction:
- criterion, bind_to_col, rev = \
- self._lazywhere, \
- self._bind_to_col, \
- self._equated_columns
+ criterion, bind_to_col = \
+ self._lazywhere, \
+ self._bind_to_col
else:
- criterion, bind_to_col, rev = \
- self._rev_lazywhere, \
- self._rev_bind_to_col, \
- self._rev_equated_columns
+ criterion, bind_to_col = \
+ self._rev_lazywhere, \
+ self._rev_bind_to_col
if reverse_direction:
mapper = self.parent_property.mapper
def visit_bindparam(bindparam):
if bindparam._identifying_key in bind_to_col:
bindparam.callable = \
- lambda: mapper._get_state_attr_by_column(
- state, dict_,
- bind_to_col[bindparam._identifying_key])
+ lambda: mapper._get_state_attr_by_column(
+ state, dict_,
+ bind_to_col[bindparam._identifying_key])
if self.parent_property.secondary is not None and alias_secondary:
criterion = sql_util.ClauseAdapter(
- self.parent_property.secondary.alias()).\
- traverse(criterion)
+ self.parent_property.secondary.alias()).\
+ traverse(criterion)
criterion = visitors.cloned_traverse(
- criterion, {}, {'bindparam': visit_bindparam})
+ criterion, {}, {'bindparam': visit_bindparam})
if adapt_source:
criterion = adapt_source(criterion)
def _lazy_none_clause(self, reverse_direction=False, adapt_source=None):
if not reverse_direction:
- criterion, bind_to_col, rev = \
- self._lazywhere, \
- self._bind_to_col,\
- self._equated_columns
+ criterion, bind_to_col = \
+ self._lazywhere, \
+ self._bind_to_col
else:
- criterion, bind_to_col, rev = \
- self._rev_lazywhere, \
- self._rev_bind_to_col, \
- self._rev_equated_columns
+ criterion, bind_to_col = \
+ self._rev_lazywhere, \
+ self._rev_bind_to_col
criterion = sql_util.adapt_criterion_to_null(criterion, bind_to_col)
return [
get_attr(
- state,
- dict_,
- self._equated_columns[pk],
- passive=passive)
+ state,
+ dict_,
+ self._equated_columns[pk],
+ passive=passive)
for pk in self.mapper.primary_key
]
@util.dependencies("sqlalchemy.orm.strategy_options")
- def _emit_lazyload(self, strategy_options, session, state, ident_key, passive):
+ def _emit_lazyload(self, strategy_options, session, state,
+ ident_key, passive):
q = session.query(self.mapper)._adapt_all_clauses()
if self.parent_property.secondary is not None:
if pending or passive & attributes.NO_AUTOFLUSH:
q = q.autoflush(False)
-
if state.load_path:
q = q._with_current_path(state.load_path[self.parent_property])
# reverse props that are MANYTOONE are loading *this*
# object from get(), so don't need to eager out to those.
if rev.direction is interfaces.MANYTOONE and \
- rev._use_get and \
- not isinstance(rev.strategy, LazyLoader):
- q = q.options(strategy_options.Load(rev.parent).lazyload(rev.key))
+ rev._use_get and \
+ not isinstance(rev.strategy, LazyLoader):
+ q = q.options(strategy_options.Load(rev.parent).
+ lazyload(rev.key))
lazy_clause = self.lazy_clause(state, passive=passive)
q = q.filter(lazy_clause)
-
result = q.all()
if self.uselist:
return result
return None
def create_row_processor(self, context, path, loadopt,
- mapper, row, adapter):
+ mapper, row, adapter):
key = self.key
if not self.is_class_level:
# we are not the primary manager for this attribute
# attribute - "eager" attributes always have a
# class-level lazyloader installed.
set_lazy_callable = InstanceState._row_processor(
- mapper.class_manager,
- LoadLazyAttribute(key), key)
+ mapper.class_manager,
+ LoadLazyAttribute(key), key)
return set_lazy_callable, None, None
else:
return reset_for_lazy_callable, None, None
-
class LoadLazyAttribute(object):
"""serializable loader object used by LazyLoader"""
class ImmediateLoader(AbstractRelationshipLoader):
def init_class_attribute(self, mapper):
self.parent_property.\
- _get_strategy_by_cls(LazyLoader).\
- init_class_attribute(mapper)
+ _get_strategy_by_cls(LazyLoader).\
+ init_class_attribute(mapper)
def setup_query(self, context, entity,
- path, loadopt, adapter, column_collection=None,
- parentmapper=None, **kwargs):
+ path, loadopt, adapter, column_collection=None,
+ parentmapper=None, **kwargs):
pass
def create_row_processor(self, context, path, loadopt,
- mapper, row, adapter):
+ mapper, row, adapter):
def load_immediate(state, dict_, row):
state.get_impl(self.key).get(state, dict_)
def init_class_attribute(self, mapper):
self.parent_property.\
- _get_strategy_by_cls(LazyLoader).\
- init_class_attribute(mapper)
+ _get_strategy_by_cls(LazyLoader).\
+ init_class_attribute(mapper)
def setup_query(self, context, entity,
- path, loadopt, adapter,
- column_collection=None,
- parentmapper=None, **kwargs):
+ path, loadopt, adapter,
+ column_collection=None,
+ parentmapper=None, **kwargs):
if not context.query._enable_eagerloads:
return
return
leftmost_mapper, leftmost_attr, leftmost_relationship = \
- self._get_leftmost(subq_path)
+ self._get_leftmost(subq_path)
orig_query = context.attributes.get(
- ("orig_query", SubqueryLoader),
- context.query)
+ ("orig_query", SubqueryLoader),
+ context.query)
# generate a new Query from the original, then
# produce a subquery from it.
left_alias = self._generate_from_original_query(
- orig_query, leftmost_mapper,
- leftmost_attr, leftmost_relationship,
- entity.entity_zero
+ orig_query, leftmost_mapper,
+ leftmost_attr, leftmost_relationship,
+ entity.entity_zero
)
# generate another Query that will join the
q = q._set_enable_single_crit(False)
to_join, local_attr, parent_alias = \
- self._prep_for_joins(left_alias, subq_path)
+ self._prep_for_joins(left_alias, subq_path)
q = q.order_by(*local_attr)
q = q.add_columns(*local_attr)
q = self._apply_joins(q, to_join, left_alias,
subq_mapper = orm_util._class_to_mapper(subq_path[0])
# determine attributes of the leftmost mapper
- if self.parent.isa(subq_mapper) and self.parent_property is subq_path[1]:
+ if self.parent.isa(subq_mapper) and \
+ self.parent_property is subq_path[1]:
leftmost_mapper, leftmost_prop = \
- self.parent, self.parent_property
+ self.parent, self.parent_property
else:
leftmost_mapper, leftmost_prop = \
- subq_mapper, \
- subq_path[1]
+ subq_mapper, \
+ subq_path[1]
leftmost_cols = leftmost_prop.local_columns
return leftmost_mapper, leftmost_attr, leftmost_prop
- def _generate_from_original_query(self,
- orig_query, leftmost_mapper,
- leftmost_attr, leftmost_relationship,
- orig_entity
+ def _generate_from_original_query(
+ self,
+ orig_query, leftmost_mapper,
+ leftmost_attr, leftmost_relationship, orig_entity
):
# reformat the original query
# to look only for significant columns
else:
if last and effective_entity is not self.mapper:
attr = getattr(parent_alias, key).\
- of_type(effective_entity)
+ of_type(effective_entity)
else:
attr = getattr(mapper.entity, key)
# right now.
eagerjoin = q._from_obj[0]
eager_order_by = \
- eagerjoin._target_adapter.\
- copy_and_process(
- util.to_list(
- self.parent_property.order_by
- )
- )
+ eagerjoin._target_adapter.\
+ copy_and_process(
+ util.to_list(
+ self.parent_property.order_by
+ )
+ )
q = q.order_by(*eager_order_by)
return q
self._load()
def create_row_processor(self, context, path, loadopt,
- mapper, row, adapter):
+ mapper, row, adapter):
if not self.parent.class_manager[self.key].impl.supports_population:
raise sa_exc.InvalidRequestError(
- "'%s' does not support object "
- "population - eager loading cannot be applied." %
- self)
+ "'%s' does not support object "
+ "population - eager loading cannot be applied." %
+ self)
path = path[self.parent_property]
()
)
state.get_impl(self.key).\
- set_committed_value(state, dict_, collection)
+ set_committed_value(state, dict_, collection)
return load_collection_from_subq, None, None, collections.loader
scalar = collection[0]
state.get_impl(self.key).\
- set_committed_value(state, dict_, scalar)
+ set_committed_value(state, dict_, scalar)
return load_scalar_from_subq, None, None, collections.loader
-
@log.class_logger
@properties.RelationshipProperty.strategy_for(lazy="joined")
@properties.RelationshipProperty.strategy_for(lazy=False)
self.parent_property.\
_get_strategy_by_cls(LazyLoader).init_class_attribute(mapper)
- def setup_query(self, context, entity, path, loadopt, adapter, \
- column_collection=None, parentmapper=None,
- chained_from_outerjoin=False,
- **kwargs):
+ def setup_query(self, context, entity, path, loadopt, adapter,
+ column_collection=None, parentmapper=None,
+ chained_from_outerjoin=False,
+ **kwargs):
"""Add a left outer join to the statement that's being constructed."""
if not context.query._enable_eagerloads:
with_polymorphic = None
user_defined_adapter = self._init_user_defined_eager_proc(
- loadopt, context) if loadopt else False
+ loadopt, context) if loadopt else False
if user_defined_adapter is not False:
clauses, adapter, add_to_collection = \
clauses, adapter, add_to_collection, chained_from_outerjoin = \
self._generate_row_adapter(
- context, entity, path, loadopt, adapter,
- column_collection, parentmapper, chained_from_outerjoin
- )
+ context, entity, path, loadopt, adapter,
+ column_collection, parentmapper, chained_from_outerjoin
+ )
with_poly_info = path.get(
context.attributes,
path = path[self.mapper]
for value in self.mapper._iterate_polymorphic_properties(
- mappers=with_polymorphic):
+ mappers=with_polymorphic):
value.setup(
context,
entity,
if with_poly_info is not None and \
None in set(context.secondary_columns):
raise sa_exc.InvalidRequestError(
- "Detected unaliased columns when generating joined "
- "load. Make sure to use aliased=True or flat=True "
- "when using joined loading with with_polymorphic()."
- )
+ "Detected unaliased columns when generating joined "
+ "load. Make sure to use aliased=True or flat=True "
+ "when using joined loading with with_polymorphic()."
+ )
def _init_user_defined_eager_proc(self, loadopt, context):
# the option applies. check if the "user_defined_eager_row_processor"
# has been built up.
adapter = path.get(context.attributes,
- "user_defined_eager_row_processor", False)
+ "user_defined_eager_row_processor", False)
if adapter is not False:
# just return it
return adapter
else:
if path.contains(context.attributes, "path_with_polymorphic"):
with_poly_info = path.get(context.attributes,
- "path_with_polymorphic")
+ "path_with_polymorphic")
adapter = orm_util.ORMAdapter(
- with_poly_info.entity,
- equivalents=prop.mapper._equivalent_columns)
+ with_poly_info.entity,
+ equivalents=prop.mapper._equivalent_columns)
else:
- adapter = context.query._polymorphic_adapters.get(prop.mapper, None)
+ adapter = context.query._polymorphic_adapters.get(
+ prop.mapper, None)
path.set(context.attributes,
- "user_defined_eager_row_processor",
- adapter)
+ "user_defined_eager_row_processor",
+ adapter)
return adapter
if adapter and user_defined_adapter:
user_defined_adapter = user_defined_adapter.wrap(adapter)
path.set(context.attributes, "user_defined_eager_row_processor",
- user_defined_adapter)
+ user_defined_adapter)
elif adapter:
user_defined_adapter = adapter
path.set(context.attributes, "user_defined_eager_row_processor",
- user_defined_adapter)
+ user_defined_adapter)
add_to_collection = context.primary_columns
return user_defined_adapter, adapter, add_to_collection
def _generate_row_adapter(self,
context, entity, path, loadopt, adapter,
- column_collection, parentmapper, chained_from_outerjoin
- ):
+ column_collection, parentmapper, chained_from_outerjoin):
with_poly_info = path.get(
context.attributes,
"path_with_polymorphic",
flat=True,
use_mapper_path=True)
clauses = orm_util.ORMAdapter(
- to_adapt,
- equivalents=self.mapper._equivalent_columns,
- adapt_required=True)
+ to_adapt,
+ equivalents=self.mapper._equivalent_columns,
+ adapt_required=True)
assert clauses.aliased_class is not None
if self.parent_property.direction != interfaces.MANYTOONE:
context.multi_row_eager_loaders = True
innerjoin = (
- loadopt.local_opts.get(
- 'innerjoin', self.parent_property.innerjoin)
- if loadopt is not None
- else self.parent_property.innerjoin
- )
+ loadopt.local_opts.get(
+ 'innerjoin', self.parent_property.innerjoin)
+ if loadopt is not None
+ else self.parent_property.innerjoin
+ )
if not innerjoin:
# if this is an outer join, all non-nested eager joins from
return clauses, adapter, add_to_collection, chained_from_outerjoin
def _create_eager_join(self, context, entity,
- path, adapter, parentmapper,
- clauses, innerjoin, chained_from_outerjoin):
+ path, adapter, parentmapper,
+ clauses, innerjoin, chained_from_outerjoin):
if parentmapper is None:
localparent = entity.mapper
if entity not in context.eager_joins and \
not should_nest_selectable and \
context.from_clause:
- index, clause = \
- sql_util.find_join_source(
- context.from_clause, entity.selectable)
+ index, clause = sql_util.find_join_source(
+ context.from_clause, entity.selectable)
if clause is not None:
# join to an existing FROM clause on the query.
# key it to its list index in the eager_joins dict.
if adapter:
if getattr(adapter, 'aliased_class', None):
onclause = getattr(
- adapter.aliased_class, self.key,
- self.parent_property)
+ adapter.aliased_class, self.key,
+ self.parent_property)
else:
onclause = getattr(
- orm_util.AliasedClass(
- self.parent,
- adapter.selectable,
- use_mapper_path=True
- ),
- self.key, self.parent_property
- )
+ orm_util.AliasedClass(
+ self.parent,
+ adapter.selectable,
+ use_mapper_path=True
+ ),
+ self.key, self.parent_property
+ )
else:
onclause = self.parent_property
assert clauses.aliased_class is not None
- join_to_outer = innerjoin and isinstance(towrap, sql.Join) and towrap.isouter
+ join_to_outer = innerjoin and isinstance(towrap, sql.Join) and \
+ towrap.isouter
if chained_from_outerjoin and join_to_outer and innerjoin == 'nested':
inner = orm_util.join(
- towrap.right,
- clauses.aliased_class,
- onclause,
- isouter=False
- )
+ towrap.right,
+ clauses.aliased_class,
+ onclause,
+ isouter=False
+ )
eagerjoin = orm_util.join(
- towrap.left,
- inner,
- towrap.onclause,
- isouter=True
- )
+ towrap.left,
+ inner,
+ towrap.onclause,
+ isouter=True
+ )
eagerjoin._target_adapter = inner._target_adapter
else:
if chained_from_outerjoin:
innerjoin = False
eagerjoin = orm_util.join(
- towrap,
- clauses.aliased_class,
- onclause,
- isouter=not innerjoin
- )
+ towrap,
+ clauses.aliased_class,
+ onclause,
+ isouter=not innerjoin
+ )
context.eager_joins[entity_key] = eagerjoin
# send a hint to the Query as to where it may "splice" this join
# This has the effect
# of "undefering" those columns.
for col in sql_util._find_columns(
- self.parent_property.primaryjoin):
+ self.parent_property.primaryjoin):
if localparent.mapped_table.c.contains_column(col):
if adapter:
col = adapter.columns[col]
context.primary_columns.append(col)
if self.parent_property.order_by:
- context.eager_order_by += \
- eagerjoin._target_adapter.\
- copy_and_process(
- util.to_list(
- self.parent_property.order_by
- )
- )
+ context.eager_order_by += eagerjoin._target_adapter.\
+ copy_and_process(
+ util.to_list(
+ self.parent_property.order_by
+ )
+ )
def _create_eager_adapter(self, context, row, adapter, path, loadopt):
user_defined_adapter = self._init_user_defined_eager_proc(
- loadopt, context) if loadopt else False
+ loadopt, context) if loadopt else False
if user_defined_adapter is not False:
decorator = user_defined_adapter
# processor, will cause a degrade to lazy
return False
- def create_row_processor(self, context, path, loadopt, mapper, row, adapter):
+ def create_row_processor(self, context, path, loadopt, mapper,
+ row, adapter):
if not self.parent.class_manager[self.key].impl.supports_population:
raise sa_exc.InvalidRequestError(
- "'%s' does not support object "
- "population - eager loading cannot be applied." %
- self)
+ "'%s' does not support object "
+ "population - eager loading cannot be applied." %
+ self
+ )
our_path = path[self.parent_property]
eager_adapter = self._create_eager_adapter(
- context,
- row,
- adapter, our_path, loadopt)
+ context,
+ row,
+ adapter, our_path, loadopt)
if eager_adapter is not False:
key = self.key
_instance = loading.instance_processor(
- self.mapper,
- context,
- our_path[self.mapper],
- eager_adapter)
+ self.mapper,
+ context,
+ our_path[self.mapper],
+ eager_adapter)
if not self.uselist:
return self._create_scalar_loader(context, key, _instance)
else:
return self._create_collection_loader(context, key, _instance)
else:
- return self.parent_property.\
- _get_strategy_by_cls(LazyLoader).\
- create_row_processor(
- context, path, loadopt,
- mapper, row, adapter)
+ return self.parent_property._get_strategy_by_cls(LazyLoader).\
+ create_row_processor(
+ context, path, loadopt,
+ mapper, row, adapter)
def _create_collection_loader(self, context, key, _instance):
def load_collection_from_joined_new_row(state, dict_, row):
collection = attributes.init_state_collection(
- state, dict_, key)
+ state, dict_, key)
result_list = util.UniqueAppender(collection,
'append_without_event')
context.attributes[(state, key)] = result_list
collection = attributes.init_state_collection(state,
dict_, key)
result_list = util.UniqueAppender(
- collection,
- 'append_without_event')
+ collection,
+ 'append_without_event')
context.attributes[(state, key)] = result_list
_instance(row, result_list)
_instance(row, None)
return load_collection_from_joined_new_row, \
- load_collection_from_joined_existing_row, \
- None, load_collection_from_joined_exec
+ load_collection_from_joined_existing_row, \
+ None, load_collection_from_joined_exec
def _create_scalar_loader(self, context, key, _instance):
def load_scalar_from_joined_new_row(state, dict_, row):
_instance(row, None)
return load_scalar_from_joined_new_row, \
- load_scalar_from_joined_existing_row, \
- None, load_scalar_from_joined_exec
-
+ load_scalar_from_joined_existing_row, \
+ None, load_scalar_from_joined_exec
def single_parent_validator(desc, prop):
return _do_check(state, value, oldvalue, initiator)
event.listen(desc, 'append', append, raw=True, retval=True,
- active_history=True)
+ active_history=True)
event.listen(desc, 'set', set_, raw=True, retval=True,
- active_history=True)
+ active_history=True)
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
