def create_row_processor(self, selectcontext, path, mapper, row, adapter): if not self.is_class_level: def new_execute(state, dict_, row, **flags): # 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. # this currently only happens when using a "lazyload" option on a "no load" # attribute - "eager" attributes always have a class-level lazyloader # installed. self._init_instance_attribute(state, callable_=LoadLazyAttribute(state, self.key)) if self._should_log_debug: new_execute = self.debug_callable(new_execute, self.logger, None, lambda state, dict_, row, **flags: "set instance-level lazy loader on %s" % \ mapperutil.state_attribute_str(state, self.key) ) return (new_execute, None) else: def new_execute(state, dict_, row, **flags): # we are the primary manager for this attribute on this class - reset its # per-instance attribute state, so that the class-level lazy loader is # executed when next referenced on this instance. this is needed in # populate_existing() types of scenarios to reset any existing state. state.reset(self.key, dict_) if self._should_log_debug: new_execute = self.debug_callable(new_execute, self.logger, None, lambda state, dict_, row, **flags: "set class-level lazy loader on %s" % \ mapperutil.state_attribute_str(state, self.key) ) return (new_execute, None)
def create_row_processor(self, selectcontext, path, mapper, row, adapter): key, col = self.key, self.columns[0] if adapter: col = adapter.columns[col] if col in row: def new_execute(state, row, **flags): state.dict[key] = row[col] if self._should_log_debug: new_execute = self.debug_callable( new_execute, self.logger, "%s returning active column fetcher" % self, lambda state, row, **flags: "%s populating %s" % (self, mapperutil.state_attribute_str(state, key))) return (new_execute, None) else: def new_execute(state, row, isnew, **flags): if isnew: state.expire_attributes([key]) if self._should_log_debug: self.logger.debug("%s deferring load" % self) return (new_execute, None)
def create_row_processor(self, selectcontext, path, mapper, row, adapter): key, columns, composite_class = self.key, self.columns, self.parent_property.composite_class if adapter: columns = [adapter.columns[c] for c in columns] for c in columns: if c not in row: def new_execute(state, row, isnew, **flags): if isnew: state.expire_attributes([key]) if self._should_log_debug: self.logger.debug("%s deferring load" % self) return (new_execute, None) else: def new_execute(state, row, **flags): state.dict[key] = composite_class(*[row[c] for c in columns]) if self._should_log_debug: new_execute = self.debug_callable( new_execute, self.logger, "%s returning active composite column fetcher" % self, lambda state, row, **flags: "populating %s" % (mapperutil.state_attribute_str(state, key))) return (new_execute, None)
def create_row_processor(self, selectcontext, path, mapper, row, adapter): col = self.columns[0] if adapter: col = adapter.columns[col] if col in row: return self.parent_property._get_strategy(ColumnLoader).create_row_processor( selectcontext, path, mapper, row, adapter ) elif not self.is_class_level or len(selectcontext.options): def new_execute(state, row, **flags): state.set_callable(self.key, self.setup_loader(state)) else: def new_execute(state, row, **flags): state.reset(self.key) if self._should_log_debug: new_execute = self.debug_callable( new_execute, self.logger, None, lambda state, row, **flags: "set deferred callable on %s" % mapperutil.state_attribute_str(state, self.key), ) return (new_execute, None)
def create_row_processor(self, selectcontext, path, mapper, row, adapter): key, columns, composite_class = self.key, self.columns, self.parent_property.composite_class if adapter: columns = [adapter.columns[c] for c in columns] for c in columns: if c not in row: def new_execute(state, row, isnew, **flags): if isnew: state.expire_attributes([key]) if self._should_log_debug: self.logger.debug("%s deferring load" % self) return (new_execute, None) else: def new_execute(state, row, **flags): state.dict[key] = composite_class(*[row[c] for c in columns]) if self._should_log_debug: new_execute = self.debug_callable( new_execute, self.logger, "%s returning active composite column fetcher" % self, lambda state, row, **flags: "populating %s" % (mapperutil.state_attribute_str(state, key)), ) return (new_execute, None)
def create_row_processor(self, selectcontext, path, mapper, row, adapter): key, col = self.key, self.columns[0] if adapter: col = adapter.columns[col] if col in row: def new_execute(state, row, **flags): state.dict[key] = row[col] if self._should_log_debug: new_execute = self.debug_callable( new_execute, self.logger, "%s returning active column fetcher" % self, lambda state, row, **flags: "%s populating %s" % (self, mapperutil.state_attribute_str(state, key)), ) return (new_execute, None) else: def new_execute(state, row, isnew, **flags): if isnew: state.expire_attributes([key]) if self._should_log_debug: self.logger.debug("%s deferring load" % self) return (new_execute, None)
def create_row_processor(self, selectcontext, path, mapper, row, adapter): col = self.columns[0] if adapter: col = adapter.columns[col] if col in row: return self.parent_property._get_strategy( ColumnLoader).create_row_processor(selectcontext, path, mapper, row, adapter) elif not self.is_class_level: def new_execute(state, dict_, row, **flags): state.set_callable(self.key, LoadDeferredColumns(state, self.key)) else: def new_execute(state, dict_, row, **flags): # reset state on the key so that deferred callables # fire off on next access. state.reset(self.key, dict_) if self._should_log_debug: new_execute = self.debug_callable(new_execute, self.logger, None, lambda state, dict_, row, **flags: "set deferred callable on %s" % \ mapperutil.state_attribute_str(state, self.key) ) return (new_execute, None)
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 create_row_processor(self, selectcontext, path, mapper, row, adapter): def new_execute(state, dict_, row, **flags): self._init_instance_attribute(state) if self._should_log_debug: new_execute = self.debug_callable(new_execute, self.logger, None, lambda state, dict_, row, **flags: "initializing blank scalar/collection on %s" % \ mapperutil.state_attribute_str(state, self.key) ) return (new_execute, None)
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 create_row_processor(self, selectcontext, path, mapper, row, adapter): if not self.is_class_level or len(selectcontext.options): path = path + (self.key,) def new_execute(state, row, **flags): # 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( state, callable_=self.setup_loader(state, selectcontext.options, selectcontext.query._current_path + path), ) if self._should_log_debug: new_execute = self.debug_callable( new_execute, self.logger, None, lambda state, row, **flags: "set instance-level lazy loader on %s" % mapperutil.state_attribute_str(state, self.key), ) return (new_execute, None) else: def new_execute(state, row, **flags): # we are the primary manager for this attribute on this class - reset its per-instance attribute state, # so that the class-level lazy loader is executed when next referenced on this instance. # this usually is not needed unless the constructor of the object referenced the attribute before we got # to load data into it. state.reset(self.key) if self._should_log_debug: new_execute = self.debug_callable( new_execute, self.logger, None, lambda state, row, **flags: "set class-level lazy loader on %s" % mapperutil.state_attribute_str(state, self.key), ) return (new_execute, None)
def create_row_processor(self, selectcontext, path, mapper, row, adapter): if not self.is_class_level: def new_execute(state, dict_, row, **flags): # 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. # this currently only happens when using a "lazyload" option on a "no load" # attribute - "eager" attributes always have a class-level lazyloader # installed. self._init_instance_attribute(state, callable_=LoadLazyAttribute( state, self.key)) if self._should_log_debug: new_execute = self.debug_callable(new_execute, self.logger, None, lambda state, dict_, row, **flags: "set instance-level lazy loader on %s" % \ mapperutil.state_attribute_str(state, self.key) ) return (new_execute, None) else: def new_execute(state, dict_, row, **flags): # we are the primary manager for this attribute on this class - reset its # per-instance attribute state, so that the class-level lazy loader is # executed when next referenced on this instance. this is needed in # populate_existing() types of scenarios to reset any existing state. state.reset(self.key, dict_) if self._should_log_debug: new_execute = self.debug_callable(new_execute, self.logger, None, lambda state, dict_, row, **flags: "set class-level lazy loader on %s" % \ mapperutil.state_attribute_str(state, self.key) ) return (new_execute, None)
def __call__(self, **kw): if kw.get('passive') is attributes.PASSIVE_NO_FETCH: return attributes.PASSIVE_NO_RESULT state = self.state localparent = mapper._state_mapper(state) prop = localparent.get_property(self.key) strategy = prop._get_strategy(DeferredColumnLoader) if 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 orm_exc.DetachedInstanceError( "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 __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 __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 create_row_processor(self, selectcontext, path, mapper, row, adapter): col = self.columns[0] if adapter: col = adapter.columns[col] if col in row: return self.parent_property._get_strategy(ColumnLoader).create_row_processor(selectcontext, path, mapper, row, adapter) elif not self.is_class_level: def new_execute(state, dict_, row, **flags): state.set_callable(self.key, LoadDeferredColumns(state, self.key)) else: def new_execute(state, dict_, row, **flags): # reset state on the key so that deferred callables # fire off on next access. state.reset(self.key, dict_) if self._should_log_debug: new_execute = self.debug_callable(new_execute, self.logger, None, lambda state, row, **flags: "set deferred callable on %s" % mapperutil.state_attribute_str(state, self.key) ) return (new_execute, None)
def create_row_processor(self, selectcontext, path, mapper, row, adapter): col = self.columns[0] if adapter: col = adapter.columns[col] if col in row: return self.parent_property._get_strategy( ColumnLoader).create_row_processor(selectcontext, path, mapper, row, adapter) elif not self.is_class_level or len(selectcontext.options): def new_execute(state, row, **flags): state.set_callable(self.key, self.setup_loader(state)) else: def new_execute(state, row, **flags): state.reset(self.key) if self._should_log_debug: new_execute = self.debug_callable( new_execute, self.logger, None, lambda state, row, **flags: "set deferred callable on %s" % mapperutil.state_attribute_str(state, self.key)) return (new_execute, None)
def __call__(self, **kw): state = self.state instance_mapper = mapper._state_mapper(state) prop = instance_mapper.get_property(self.key) strategy = prop._get_strategy(LazyLoader) if kw.get("passive") is attributes.PASSIVE_NO_FETCH and not strategy.use_get: return attributes.PASSIVE_NO_RESULT 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 orm_exc.DetachedInstanceError( "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 state.load_path: q = q._with_current_path(state.load_path + (self.key,)) # 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, state.dict, strategy._equated_columns[primary_key], **kw ) if val is attributes.PASSIVE_NO_RESULT: return val allnulls = allnulls and val is None ident.append(val) if allnulls: return None if state.load_options: q = q._conditional_options(*state.load_options) key = prop.mapper.identity_key_from_primary_key(ident) return q._get(key, ident, **kw) if prop.order_by: q = q.order_by(*util.to_list(prop.order_by)) for rev in prop._reverse_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(EagerLazyOption(rev.key, lazy="select")) if state.load_options: q = q._conditional_options(*state.load_options) q = q.filter(strategy.lazy_clause(state)) result = q.all() if strategy.uselist: return result else: l = len(result) if l: if l > 1: util.warn("Multiple rows returned with " "uselist=False for lazily-loaded attribute '%s' " % prop) return result[0] else: return None
def __call__(self, **kw): state = self.state instance_mapper = mapper._state_mapper(state) prop = instance_mapper.get_property(self.key) strategy = prop._get_strategy(LazyLoader) if kw.get('passive') is attributes.PASSIVE_NO_FETCH and \ not strategy.use_get: return attributes.PASSIVE_NO_RESULT 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 orm_exc.DetachedInstanceError( "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 state.load_path: q = q._with_current_path(state.load_path + (self.key, )) # 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, state.dict, strategy._equated_columns[primary_key], **kw) if val is attributes.PASSIVE_NO_RESULT: return val allnulls = allnulls and val is None ident.append(val) if allnulls: return None if state.load_options: q = q._conditional_options(*state.load_options) key = prop.mapper.identity_key_from_primary_key(ident) return q._get(key, ident, **kw) if prop.order_by: q = q.order_by(*util.to_list(prop.order_by)) for rev in prop._reverse_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(EagerLazyOption(rev.key, lazy='select')) if state.load_options: q = q._conditional_options(*state.load_options) q = q.filter(strategy.lazy_clause(state)) result = q.all() if strategy.uselist: return result else: l = len(result) if l: if l > 1: util.warn( "Multiple rows returned with " "uselist=False for lazily-loaded attribute '%s' " % prop) return result[0] else: return None