identitykey = self.identity_key_from_row(row)
populate_existing = context.populate_existing or self.always_refresh
if identitykey in context.session.identity_map:
- instance = context.session._get(identitykey)
+ instance = context.session.identity_map[identitykey]
if self.__should_log_debug:
self.__log_debug("_instance(): using existing instance %s identity %s" % (mapperutil.instance_str(instance), str(identitykey)))
isnew = False
if extension.append_result(self, context, row, instance, result, **flags) is EXT_CONTINUE:
if result is not None:
result.append(instance)
+
+ instance._instance_key = identitykey
+
return instance
def _create_instance(self, session):
newrow[c] = row[c2]
return newrow
- def populate_instance(self, selectcontext, instance, row, ispostselect=None, **flags):
+ def populate_instance(self, selectcontext, instance, row, ispostselect=None, isnew=False, **flags):
"""populate an instance from a result row."""
selectcontext.stack.push_mapper(self)
# "snapshot" of the stack, which represents a path from the lead mapper in the query to this one,
# including relation() names. the key also includes "self", and allows us to distinguish between
# other mappers within our inheritance hierarchy
- populators = selectcontext.attributes.get(('instance_populators', self, selectcontext.stack.snapshot(), ispostselect), None)
+ snapshot = selectcontext.stack.snapshot()
+ populators = selectcontext.attributes.get(((isnew or ispostselect) and 'new_populators' or 'existing_populators', self, snapshot, ispostselect), None)
if populators is None:
# no populators; therefore this is the first time we are receiving a row for
# this result set. issue create_row_processor() on all MapperProperty objects
# and cache in the select context.
- populators = []
+ new_populators = []
+ existing_populators = []
post_processors = []
for prop in self.__props.values():
- (pop, post_proc) = prop.create_row_processor(selectcontext, self, row)
- if pop is not None:
- populators.append(pop)
+ (newpop, existingpop, post_proc) = prop.create_row_processor(selectcontext, self, row)
+ if newpop is not None:
+ new_populators.append(newpop)
+ if existingpop is not None:
+ existing_populators.append(existingpop)
if post_proc is not None:
post_processors.append(post_proc)
if poly_select_loader is not None:
post_processors.append(poly_select_loader)
- selectcontext.attributes[('instance_populators', self, selectcontext.stack.snapshot(), ispostselect)] = populators
+ selectcontext.attributes[('new_populators', self, snapshot, ispostselect)] = new_populators
+ selectcontext.attributes[('existing_populators', self, snapshot, ispostselect)] = existing_populators
selectcontext.attributes[('post_processors', self, ispostselect)] = post_processors
-
+ if isnew or ispostselect:
+ populators = new_populators
+ else:
+ populators = existing_populators
+
for p in populators:
- p(instance, row, ispostselect=ispostselect, **flags)
+ p(instance, row, ispostselect=ispostselect, isnew=isnew, **flags)
selectcontext.stack.pop()
def __init__(self, class_, entity_name):
self.class_ = class_
self.entity_name = entity_name
-
+ self._hash = hash((self.class_, self.entity_name))
+
def __hash__(self):
- return hash((self.class_, self.entity_name))
+ return self._hash
def __eq__(self, other):
return self is other
raise exceptions.InvalidRequestError("Class '%s' entity name '%s' has no mapper associated with it" % (object.__class__.__name__, getattr(object, '_entity_name', entity_name)))
else:
return None
- return mapper.compile()
+ return mapper
def class_mapper(class_, entity_name=None, compile=True):
"""Given a class and optional entity_name, return the primary Mapper associated with the key.
return object_session(obj)
object_session = classmethod(object_session)
- def _save_impl(self, object, **kwargs):
- if hasattr(object, '_instance_key'):
- if object._instance_key not in self.identity_map:
+ def _save_impl(self, obj, **kwargs):
+ if hasattr(obj, '_instance_key'):
+ if obj._instance_key not in self.identity_map:
raise exceptions.InvalidRequestError("Instance '%s' is a detached instance "
"or is already persistent in a "
- "different Session" % repr(object))
+ "different Session" % repr(obj))
else:
- m = _class_mapper(object.__class__, entity_name=kwargs.get('entity_name', None))
+ m = _class_mapper(obj.__class__, entity_name=kwargs.get('entity_name', None))
# this would be a nice exception to raise...however this is incompatible with a contextual
# session which puts all objects into the session upon construction.
# "and must be attached to a parent "
# "object to be saved" % (repr(object)))
- m._assign_entity_name(object)
- self._register_pending(object)
+ m._assign_entity_name(obj)
+ self._attach(obj)
+ self.uow.register_new(obj)
- def _update_impl(self, object, **kwargs):
- if self._is_attached(object) and object not in self.deleted:
+ def _update_impl(self, obj, **kwargs):
+ if self._is_attached(obj) and obj not in self.deleted:
return
- if not hasattr(object, '_instance_key'):
- raise exceptions.InvalidRequestError("Instance '%s' is not persisted" % repr(object))
- self._attach(object)
-
- def _register_pending(self, obj):
+ if not hasattr(obj, '_instance_key'):
+ raise exceptions.InvalidRequestError("Instance '%s' is not persisted" % repr(obj))
self._attach(obj)
- self.uow.register_new(obj)
def _register_persistent(self, obj):
- self._attach(obj)
- self.uow.register_clean(obj)
-
- def _register_deleted(self, obj):
- self._attach(obj)
- self.uow.register_deleted(obj)
+ obj._sa_session_id = self.hash_key
+ self.identity_map[obj._instance_key] = obj
+ attribute_manager.commit(obj)
def _attach(self, obj):
- """Attach the given object to this ``Session``."""
-
old_id = getattr(obj, '_sa_session_id', None)
if old_id != self.hash_key:
if old_id is not None and old_id in _sessions:
return iter(list(self.uow.new) + self.uow.identity_map.values())
- def _get(self, key):
- return self.identity_map[key]
-
dirty = property(lambda s:s.uow.locate_dirty(),
doc="A ``Set`` of all objects marked as 'dirty' within this ``Session``")
new = property(lambda s:s.uow.new,
doc="A ``Set`` of all objects marked as 'new' within this ``Session``.")
- def import_instance(self, *args, **kwargs):
- """A synynom for ``merge()``."""
-
- return self.merge(*args, **kwargs)
- import_instance = util.deprecated(import_instance)
# this is the AttributeManager instance used to provide attribute behavior on objects.
# to all the "global variable police" out there: its a stateless object.
if c not in row:
break
else:
- def execute(instance, row, isnew, ispostselect=None, **flags):
- if isnew or ispostselect:
- if self._should_log_debug:
- self.logger.debug("populating %s with %s/%s..." % (mapperutil.attribute_str(instance, self.key), row.__class__.__name__, self.columns[0].key))
- instance.__dict__[self.key] = self.parent_property.composite_class(*[row[c] for c in self.columns])
- self.logger.debug("Returning active composite column fetcher for %s %s" % (mapper, self.key))
- return (execute, None)
+ def new_execute(instance, row, **flags):
+ if self._should_log_debug:
+ self.logger.debug("populating %s with %s/%s..." % (mapperutil.attribute_str(instance, self.key), row.__class__.__name__, self.columns[0].key))
+ instance.__dict__[self.key] = self.parent_property.composite_class(*[row[c] for c in self.columns])
+ if self._should_log_debug:
+ self.logger.debug("Returning active composite column fetcher for %s %s" % (mapper, self.key))
+ return (new_execute, None, None)
elif self.columns[0] in row:
- def execute(instance, row, isnew, ispostselect=None, **flags):
- if isnew or ispostselect:
- if self._should_log_debug:
- self.logger.debug("populating %s with %s/%s" % (mapperutil.attribute_str(instance, self.key), row.__class__.__name__, self.columns[0].key))
- instance.__dict__[self.key] = row[self.columns[0]]
- self.logger.debug("Returning active column fetcher for %s %s" % (mapper, self.key))
- return (execute, None)
+ def new_execute(instance, row, **flags):
+ if self._should_log_debug:
+ self.logger.debug("populating %s with %s/%s" % (mapperutil.attribute_str(instance, self.key), row.__class__.__name__, self.columns[0].key))
+ instance.__dict__[self.key] = row[self.columns[0]]
+ if self._should_log_debug:
+ self.logger.debug("Returning active column fetcher for %s %s" % (mapper, self.key))
+ return (new_execute, None, None)
# our mapped column is not present in the row. check if we need to initialize a polymorphic
# row fetcher used by inheritance.
if hosted_mapper.polymorphic_fetch == 'deferred':
# 'deferred' polymorphic row fetcher, put a callable on the property.
- def execute(instance, row, isnew, **flags):
+ def new_execute(instance, row, isnew, **flags):
if isnew:
sessionlib.attribute_manager.init_instance_attribute(instance, self.key, callable_=self._get_deferred_inheritance_loader(instance, mapper, needs_tables))
- self.logger.debug("Returning deferred column fetcher for %s %s" % (mapper, self.key))
- return (execute, None)
+ if self._should_log_debug:
+ self.logger.debug("Returning deferred column fetcher for %s %s" % (mapper, self.key))
+ return (new_execute, None, None)
else:
# immediate polymorphic row fetcher. no processing needed for this row.
- self.logger.debug("Returning no column fetcher for %s %s" % (mapper, self.key))
- return (None, None)
+ if self._should_log_debug:
+ self.logger.debug("Returning no column fetcher for %s %s" % (mapper, self.key))
+ return (None, None, None)
def _get_deferred_inheritance_loader(self, instance, mapper, needs_tables):
def create_statement():
if self.group is not None and selectcontext.attributes.get(('undefer', self.group), False):
return self.parent_property._get_strategy(ColumnLoader).create_row_processor(selectcontext, mapper, row)
elif not self.is_class_level or len(selectcontext.options):
- def execute(instance, row, isnew, **flags):
- if isnew:
- if self._should_log_debug:
- self.logger.debug("set deferred callable on %s" % mapperutil.attribute_str(instance, self.key))
- sessionlib.attribute_manager.init_instance_attribute(instance, self.key, callable_=self.setup_loader(instance))
- return (execute, None)
+ def new_execute(instance, row, **flags):
+ if self._should_log_debug:
+ self.logger.debug("set deferred callable on %s" % mapperutil.attribute_str(instance, self.key))
+ sessionlib.attribute_manager.init_instance_attribute(instance, self.key, callable_=self.setup_loader(instance))
+ return (new_execute, None, None)
else:
- def execute(instance, row, isnew, **flags):
- if isnew:
- if self._should_log_debug:
- self.logger.debug("set deferred callable on %s" % mapperutil.attribute_str(instance, self.key))
- sessionlib.attribute_manager.reset_instance_attribute(instance, self.key)
- return (execute, None)
+ def new_execute(instance, row, **flags):
+ if self._should_log_debug:
+ self.logger.debug("set deferred callable on %s" % mapperutil.attribute_str(instance, self.key))
+ sessionlib.attribute_manager.reset_instance_attribute(instance, self.key)
+ return (new_execute, None, None)
def init(self):
super(DeferredColumnLoader, self).init()
self._register_attribute(self.parent.class_, dynamic=True, target_mapper=self.parent_property.mapper)
def create_row_processor(self, selectcontext, mapper, row):
- return (None, None)
+ return (None, None, None)
DynaLoader.logger = logging.class_logger(DynaLoader)
self._register_attribute(self.parent.class_)
def create_row_processor(self, selectcontext, mapper, row):
- def execute(instance, row, isnew, **flags):
- if isnew:
+ def new_execute(instance, row, ispostselect, **flags):
+ if not ispostselect:
if self._should_log_debug:
self.logger.debug("initializing blank scalar/collection on %s" % mapperutil.attribute_str(instance, self.key))
self._init_instance_attribute(instance)
- return (execute, None)
+ return (new_execute, None, None)
NoLoader.logger = logging.class_logger(NoLoader)
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)))
+ 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
def create_row_processor(self, selectcontext, mapper, row):
if not self.is_class_level or len(selectcontext.options):
- def execute(instance, row, isnew, **flags):
- if isnew:
+ def new_execute(instance, row, ispostselect, **flags):
+ if not ispostselect:
if self._should_log_debug:
self.logger.debug("set instance-level lazy loader on %s" % mapperutil.attribute_str(instance, self.key))
# we are not the primary manager for this attribute on this class - set up a per-instance lazyloader,
# which will override the class-level behavior
self._init_instance_attribute(instance, callable_=self.setup_loader(instance, selectcontext.options))
- return (execute, None)
+ return (new_execute, None, None)
else:
- def execute(instance, row, isnew, **flags):
- if isnew:
+ def new_execute(instance, row, ispostselect, **flags):
+ if not ispostselect:
if self._should_log_debug:
self.logger.debug("set class-level lazy loader on %s" % mapperutil.attribute_str(instance, self.key))
# we are the primary manager for this attribute on this class - reset its per-instance attribute state,
# this usually is not needed unless the constructor of the object referenced the attribute before we got
# to load data into it.
sessionlib.attribute_manager.reset_instance_attribute(instance, self.key)
- return (execute, None)
+ return (new_execute, None, None)
def _create_lazy_clause(cls, prop, reverse_direction=False):
(primaryjoin, secondaryjoin, remote_side) = (prop.polymorphic_primaryjoin, prop.polymorphic_secondaryjoin, prop.remote_side)
# FIXME: instead of...
sessionlib.attribute_manager.get_attribute(instance, self.key).set_raw_value(instance, self.select_mapper._instance(selectcontext, decorated_row, None))
# bypass and set directly:
- #instance.__dict__[self.key] = ...
+ #instance.__dict__[self.key] = self.select_mapper._instance(selectcontext, decorated_row, None)
else:
# call _instance on the row, even though the object has been created,
# so that we further descend into properties
selectcontext.stack.pop()
selectcontext.stack.pop()
- return (execute, None)
+ return (execute, execute, None)
else:
- self.logger.debug("eager loader %s degrading to lazy loader" % str(self))
+ if self._should_log_debug:
+ self.logger.debug("eager loader %s degrading to lazy loader" % str(self))
selectcontext.stack.pop()
return self.parent_property._get_strategy(LazyLoader).create_row_processor(selectcontext, mapper, row)
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
