def __determine_fks(self): if self._legacy_foreignkey and not self._refers_to_parent_table(): self.foreign_keys = self._legacy_foreignkey arg_foreign_keys = util.Set([expression._literal_as_column(x) for x in util.to_set(self.foreign_keys)]) if self._arg_local_remote_pairs: if not arg_foreign_keys: raise exceptions.ArgumentError("foreign_keys argument is required with _local_remote_pairs argument") self.foreign_keys = util.OrderedSet(arg_foreign_keys) self._opposite_side = util.OrderedSet() for l, r in self._arg_local_remote_pairs: if r in self.foreign_keys: self._opposite_side.add(l) elif l in self.foreign_keys: self._opposite_side.add(r) self.synchronize_pairs = zip(self._opposite_side, self.foreign_keys) else: eq_pairs = criterion_as_pairs(self.primaryjoin, consider_as_foreign_keys=arg_foreign_keys, any_operator=self.viewonly) eq_pairs = [(l, r) for l, r in eq_pairs if (self.__col_is_part_of_mappings(l) and self.__col_is_part_of_mappings(r)) or r in arg_foreign_keys] if not eq_pairs: if not self.viewonly and criterion_as_pairs(self.primaryjoin, consider_as_foreign_keys=arg_foreign_keys, any_operator=True): raise exceptions.ArgumentError("Could not locate any equated, locally mapped column pairs for primaryjoin condition '%s' on relation %s. " "For more relaxed rules on join conditions, the relation may be marked as viewonly=True." % (self.primaryjoin, self) ) else: if arg_foreign_keys: raise exceptions.ArgumentError("Could not determine relation direction for primaryjoin condition '%s', on relation %s. " "Specify _local_remote_pairs=[(local, remote), (local, remote), ...] to explicitly establish the local/remote column pairs." % (self.primaryjoin, self)) else: raise exceptions.ArgumentError("Could not determine relation direction for primaryjoin condition '%s', on relation %s. " "Specify the foreign_keys argument to indicate which columns on the relation are foreign." % (self.primaryjoin, self)) self.foreign_keys = util.OrderedSet([r for l, r in eq_pairs]) self._opposite_side = util.OrderedSet([l for l, r in eq_pairs]) self.synchronize_pairs = eq_pairs if self.secondaryjoin: sq_pairs = criterion_as_pairs(self.secondaryjoin, consider_as_foreign_keys=arg_foreign_keys, any_operator=self.viewonly) sq_pairs = [(l, r) for l, r in sq_pairs if (self.__col_is_part_of_mappings(l) and self.__col_is_part_of_mappings(r)) or r in arg_foreign_keys] if not sq_pairs: if not self.viewonly and criterion_as_pairs(self.secondaryjoin, consider_as_foreign_keys=arg_foreign_keys, any_operator=True): raise exceptions.ArgumentError("Could not locate any equated, locally mapped column pairs for secondaryjoin condition '%s' on relation %s. " "For more relaxed rules on join conditions, the relation may be marked as viewonly=True." % (self.secondaryjoin, self) ) else: raise exceptions.ArgumentError("Could not determine relation direction for secondaryjoin condition '%s', on relation %s. " "Specify the foreign_keys argument to indicate which columns on the relation are foreign." % (self.secondaryjoin, self)) self.foreign_keys.update([r for l, r in sq_pairs]) self._opposite_side.update([l for l, r in sq_pairs]) self.secondary_synchronize_pairs = sq_pairs else: self.secondary_synchronize_pairs = None
def __init__(self, argument, secondary, primaryjoin, secondaryjoin, entity_name=None, foreign_keys=None, foreignkey=None, uselist=None, private=False, association=None, order_by=False, attributeext=None, backref=None, is_backref=False, post_update=False, cascade=None, viewonly=False, lazy=True, collection_class=None, passive_deletes=False, remote_side=None, enable_typechecks=True): self.uselist = uselist self.argument = argument self.entity_name = entity_name self.secondary = secondary self.primaryjoin = primaryjoin self.secondaryjoin = secondaryjoin self.post_update = post_update self.direction = None self.viewonly = viewonly self.lazy = lazy self.foreign_keys = util.to_set(foreign_keys) self._legacy_foreignkey = util.to_set(foreignkey) self.collection_class = collection_class self.passive_deletes = passive_deletes self.remote_side = util.to_set(remote_side) self.enable_typechecks = enable_typechecks self._parent_join_cache = {} if cascade is not None: self.cascade = mapperutil.CascadeOptions(cascade) else: if private: self.cascade = mapperutil.CascadeOptions("all, delete-orphan") else: self.cascade = mapperutil.CascadeOptions("save-update, merge") self.association = association self.order_by = order_by self.attributeext = attributeext if isinstance(backref, str): # propigate explicitly sent primary/secondary join conditions to the BackRef object if # just a string was sent if secondary is not None: # reverse primary/secondary in case of a many-to-many self.backref = BackRef(backref, primaryjoin=secondaryjoin, secondaryjoin=primaryjoin) else: self.backref = BackRef(backref, primaryjoin=primaryjoin, secondaryjoin=secondaryjoin) else: self.backref = backref self.is_backref = is_backref
def __init__(self, argument, secondary, primaryjoin, secondaryjoin, foreignkey=None, uselist=None, private=False, association=None, order_by=False, attributeext=None, backref=None, is_backref=False, post_update=False, cascade=None): self.uselist = uselist self.argument = argument self.secondary = secondary self.primaryjoin = primaryjoin self.secondaryjoin = secondaryjoin self.post_update = post_update self.direction = None self.foreignkey = util.to_set(foreignkey) if cascade is not None: self.cascade = mapperutil.CascadeOptions(cascade) else: if private: self.cascade = mapperutil.CascadeOptions("all, delete-orphan") else: self.cascade = mapperutil.CascadeOptions("save-update") self.association = association self.order_by = order_by self.attributeext = attributeext if isinstance(backref, str): self.backref = BackRef(backref) else: self.backref = backref self.is_backref = is_backref
def __determine_remote_side(self): if self._arg_local_remote_pairs: if self.remote_side: raise exceptions.ArgumentError("remote_side argument is redundant against more detailed _local_remote_side argument.") if self.direction is MANYTOONE: eq_pairs = [(r, l) for l, r in self._arg_local_remote_pairs] else: eq_pairs = self._arg_local_remote_pairs elif self.remote_side: remote_side = util.Set([expression._literal_as_column(x) for x in util.to_set(self.remote_side)]) if self.direction is MANYTOONE: eq_pairs = criterion_as_pairs(self.primaryjoin, consider_as_referenced_keys=remote_side, any_operator=True) else: eq_pairs = criterion_as_pairs(self.primaryjoin, consider_as_foreign_keys=remote_side, any_operator=True) else: if self.viewonly: eq_pairs = self.synchronize_pairs else: eq_pairs = criterion_as_pairs(self.primaryjoin, consider_as_foreign_keys=self.foreign_keys, any_operator=True) if self.secondaryjoin: sq_pairs = criterion_as_pairs(self.secondaryjoin, consider_as_foreign_keys=self.foreign_keys, any_operator=True) eq_pairs += sq_pairs eq_pairs = [(l, r) for l, r in eq_pairs if self.__col_is_part_of_mappings(l) and self.__col_is_part_of_mappings(r)] if self.direction is MANYTOONE: self.remote_side, self.local_side = [util.OrderedSet(s) for s in zip(*eq_pairs)] self.local_remote_pairs = [(r, l) for l, r in eq_pairs] else: self.local_side, self.remote_side = [util.OrderedSet(s) for s in zip(*eq_pairs)] self.local_remote_pairs = eq_pairs if self.direction is ONETOMANY: for l in self.local_side: if not self.__col_is_part_of_mappings(l): raise exceptions.ArgumentError("Local column '%s' is not part of mapping %s. Specify remote_side argument to indicate which column lazy join condition should compare against." % (l, self.parent)) elif self.direction is MANYTOONE: for r in self.remote_side: if not self.__col_is_part_of_mappings(r): raise exceptions.ArgumentError("Remote column '%s' is not part of mapping %s. Specify remote_side argument to indicate which column lazy join condition should bind." % (r, self.mapper))
def __init__(self, argument, secondary=None, primaryjoin=None, secondaryjoin=None, entity_name=None, foreign_keys=None, foreignkey=None, uselist=None, private=False, association=None, order_by=False, attributeext=None, backref=None, is_backref=False, post_update=False, cascade=None, viewonly=False, lazy=True, collection_class=None, passive_deletes=False, passive_updates=True, remote_side=None, enable_typechecks=True, join_depth=None, strategy_class=None, _local_remote_pairs=None): self.uselist = uselist self.argument = argument self.entity_name = entity_name self.secondary = secondary self.primaryjoin = primaryjoin self.secondaryjoin = secondaryjoin self.post_update = post_update self.direction = None self.viewonly = viewonly self.lazy = lazy self.foreign_keys = util.to_set(foreign_keys) self._legacy_foreignkey = util.to_set(foreignkey) if foreignkey: util.warn_deprecated('foreignkey option is deprecated; see docs for details') self.collection_class = collection_class self.passive_deletes = passive_deletes self.passive_updates = passive_updates self.remote_side = util.to_set(remote_side) self.enable_typechecks = enable_typechecks self.comparator = PropertyLoader.Comparator(self) self.join_depth = join_depth self._arg_local_remote_pairs = _local_remote_pairs util.set_creation_order(self) if strategy_class: self.strategy_class = strategy_class elif self.lazy == 'dynamic': from sqlalchemy.orm import dynamic self.strategy_class = dynamic.DynaLoader elif self.lazy is False: self.strategy_class = strategies.EagerLoader elif self.lazy is None: self.strategy_class = strategies.NoLoader else: self.strategy_class = strategies.LazyLoader self._reverse_property = None if cascade is not None: self.cascade = CascadeOptions(cascade) else: if private: util.warn_deprecated('private option is deprecated; see docs for details') self.cascade = CascadeOptions("all, delete-orphan") else: self.cascade = CascadeOptions("save-update, merge") if self.passive_deletes == 'all' and ("delete" in self.cascade or "delete-orphan" in self.cascade): raise exceptions.ArgumentError("Can't set passive_deletes='all' in conjunction with 'delete' or 'delete-orphan' cascade") self.association = association if association: util.warn_deprecated('association option is deprecated; see docs for details') self.order_by = order_by self.attributeext=attributeext if isinstance(backref, str): # propigate explicitly sent primary/secondary join conditions to the BackRef object if # just a string was sent if secondary is not None: # reverse primary/secondary in case of a many-to-many self.backref = BackRef(backref, primaryjoin=secondaryjoin, secondaryjoin=primaryjoin, passive_updates=self.passive_updates) else: self.backref = BackRef(backref, primaryjoin=primaryjoin, secondaryjoin=secondaryjoin, passive_updates=self.passive_updates) else: self.backref = backref self.is_backref = is_backref
def __init__(self, argument, secondary=None, primaryjoin=None, secondaryjoin=None, entity_name=None, foreign_keys=None, foreignkey=None, uselist=None, private=False, association=None, order_by=False, attributeext=None, backref=None, is_backref=False, post_update=False, cascade=None, viewonly=False, lazy=True, collection_class=None, passive_deletes=False, passive_updates=True, remote_side=None, enable_typechecks=True, join_depth=None, strategy_class=None): self.uselist = uselist self.argument = argument self.entity_name = entity_name self.secondary = secondary self.primaryjoin = primaryjoin self.secondaryjoin = secondaryjoin self.post_update = post_update self.direction = None self.viewonly = viewonly self.lazy = lazy self.foreign_keys = util.to_set(foreign_keys) self._legacy_foreignkey = util.to_set(foreignkey) if foreignkey: util.warn_deprecated('foreignkey option is deprecated; see docs for details') self.collection_class = collection_class self.passive_deletes = passive_deletes self.passive_updates = passive_updates self.remote_side = util.to_set(remote_side) self.enable_typechecks = enable_typechecks self.comparator = PropertyLoader.Comparator(self) self.join_depth = join_depth if strategy_class: self.strategy_class = strategy_class elif self.lazy == 'dynamic': from sqlalchemy.orm import dynamic self.strategy_class = dynamic.DynaLoader elif self.lazy is False: self.strategy_class = strategies.EagerLoader elif self.lazy is None: self.strategy_class = strategies.NoLoader else: self.strategy_class = strategies.LazyLoader self._reverse_property = None if cascade is not None: self.cascade = CascadeOptions(cascade) else: if private: util.warn_deprecated('private option is deprecated; see docs for details') self.cascade = CascadeOptions("all, delete-orphan") else: self.cascade = CascadeOptions("save-update, merge") if self.passive_deletes == 'all' and ("delete" in self.cascade or "delete-orphan" in self.cascade): raise exceptions.ArgumentError("Can't set passive_deletes='all' in conjunction with 'delete' or 'delete-orphan' cascade") self.association = association if association: util.warn_deprecated('association option is deprecated; see docs for details') self.order_by = order_by self.attributeext=attributeext if isinstance(backref, str): # propigate explicitly sent primary/secondary join conditions to the BackRef object if # just a string was sent if secondary is not None: # reverse primary/secondary in case of a many-to-many self.backref = BackRef(backref, primaryjoin=secondaryjoin, secondaryjoin=primaryjoin, passive_updates=self.passive_updates) else: self.backref = BackRef(backref, primaryjoin=primaryjoin, secondaryjoin=secondaryjoin, passive_updates=self.passive_updates) else: self.backref = backref self.is_backref = is_backref
def __determine_remote_side(self): if self._arg_local_remote_pairs: if self.remote_side: raise exceptions.ArgumentError( "remote_side argument is redundant against more detailed _local_remote_side argument." ) if self.direction is MANYTOONE: eq_pairs = [(r, l) for l, r in self._arg_local_remote_pairs] else: eq_pairs = self._arg_local_remote_pairs elif self.remote_side: remote_side = util.Set([ expression._literal_as_column(x) for x in util.to_set(self.remote_side) ]) if self.direction is MANYTOONE: eq_pairs = criterion_as_pairs( self.primaryjoin, consider_as_referenced_keys=remote_side, any_operator=True) else: eq_pairs = criterion_as_pairs( self.primaryjoin, consider_as_foreign_keys=remote_side, any_operator=True) else: if self.viewonly: eq_pairs = self.synchronize_pairs else: eq_pairs = criterion_as_pairs( self.primaryjoin, consider_as_foreign_keys=self.foreign_keys, any_operator=True) if self.secondaryjoin: sq_pairs = criterion_as_pairs( self.secondaryjoin, consider_as_foreign_keys=self.foreign_keys, any_operator=True) eq_pairs += sq_pairs eq_pairs = [(l, r) for l, r in eq_pairs if self.__col_is_part_of_mappings(l) and self.__col_is_part_of_mappings(r)] if self.direction is MANYTOONE: self.remote_side, self.local_side = [ util.OrderedSet(s) for s in zip(*eq_pairs) ] self.local_remote_pairs = [(r, l) for l, r in eq_pairs] else: self.local_side, self.remote_side = [ util.OrderedSet(s) for s in zip(*eq_pairs) ] self.local_remote_pairs = eq_pairs if self.direction is ONETOMANY: for l in self.local_side: if not self.__col_is_part_of_mappings(l): raise exceptions.ArgumentError( "Local column '%s' is not part of mapping %s. Specify remote_side argument to indicate which column lazy join condition should compare against." % (l, self.parent)) elif self.direction is MANYTOONE: for r in self.remote_side: if not self.__col_is_part_of_mappings(r): raise exceptions.ArgumentError( "Remote column '%s' is not part of mapping %s. Specify remote_side argument to indicate which column lazy join condition should bind." % (r, self.mapper))
def __determine_fks(self): if self._legacy_foreignkey and not self._refers_to_parent_table(): self.foreign_keys = self._legacy_foreignkey arg_foreign_keys = util.Set([ expression._literal_as_column(x) for x in util.to_set(self.foreign_keys) ]) if self._arg_local_remote_pairs: if not arg_foreign_keys: raise exceptions.ArgumentError( "foreign_keys argument is required with _local_remote_pairs argument" ) self.foreign_keys = util.OrderedSet(arg_foreign_keys) self._opposite_side = util.OrderedSet() for l, r in self._arg_local_remote_pairs: if r in self.foreign_keys: self._opposite_side.add(l) elif l in self.foreign_keys: self._opposite_side.add(r) self.synchronize_pairs = zip(self._opposite_side, self.foreign_keys) else: eq_pairs = criterion_as_pairs( self.primaryjoin, consider_as_foreign_keys=arg_foreign_keys, any_operator=self.viewonly) eq_pairs = [ (l, r) for l, r in eq_pairs if (self.__col_is_part_of_mappings(l) and self.__col_is_part_of_mappings(r)) or r in arg_foreign_keys ] if not eq_pairs: if not self.viewonly and criterion_as_pairs( self.primaryjoin, consider_as_foreign_keys=arg_foreign_keys, any_operator=True): raise exceptions.ArgumentError( "Could not locate any equated, locally mapped column pairs for primaryjoin condition '%s' on relation %s. " "For more relaxed rules on join conditions, the relation may be marked as viewonly=True." % (self.primaryjoin, self)) else: if arg_foreign_keys: raise exceptions.ArgumentError( "Could not determine relation direction for primaryjoin condition '%s', on relation %s. " "Specify _local_remote_pairs=[(local, remote), (local, remote), ...] to explicitly establish the local/remote column pairs." % (self.primaryjoin, self)) else: raise exceptions.ArgumentError( "Could not determine relation direction for primaryjoin condition '%s', on relation %s. " "Specify the foreign_keys argument to indicate which columns on the relation are foreign." % (self.primaryjoin, self)) self.foreign_keys = util.OrderedSet([r for l, r in eq_pairs]) self._opposite_side = util.OrderedSet([l for l, r in eq_pairs]) self.synchronize_pairs = eq_pairs if self.secondaryjoin: sq_pairs = criterion_as_pairs( self.secondaryjoin, consider_as_foreign_keys=arg_foreign_keys, any_operator=self.viewonly) sq_pairs = [ (l, r) for l, r in sq_pairs if (self.__col_is_part_of_mappings(l) and self.__col_is_part_of_mappings(r)) or r in arg_foreign_keys ] if not sq_pairs: if not self.viewonly and criterion_as_pairs( self.secondaryjoin, consider_as_foreign_keys=arg_foreign_keys, any_operator=True): raise exceptions.ArgumentError( "Could not locate any equated, locally mapped column pairs for secondaryjoin condition '%s' on relation %s. " "For more relaxed rules on join conditions, the relation may be marked as viewonly=True." % (self.secondaryjoin, self)) else: raise exceptions.ArgumentError( "Could not determine relation direction for secondaryjoin condition '%s', on relation %s. " "Specify the foreign_keys argument to indicate which columns on the relation are foreign." % (self.secondaryjoin, self)) self.foreign_keys.update([r for l, r in sq_pairs]) self._opposite_side.update([l for l, r in sq_pairs]) self.secondary_synchronize_pairs = sq_pairs else: self.secondary_synchronize_pairs = None
def __init__(self, argument, secondary, primaryjoin, secondaryjoin, foreign_keys=None, foreignkey=None, uselist=None, private=False, association=None, order_by=False, attributeext=None, backref=None, is_backref=False, post_update=False, cascade=None, viewonly=False, lazy=True, collection_class=None, passive_deletes=False, remote_side=None, enable_typechecks=True): self.uselist = uselist self.argument = argument self.secondary = secondary self.primaryjoin = primaryjoin self.secondaryjoin = secondaryjoin self.post_update = post_update self.direction = None self.viewonly = viewonly self.lazy = lazy self.foreign_keys = util.to_set(foreign_keys) self._legacy_foreignkey = util.to_set(foreignkey) self.collection_class = collection_class self.passive_deletes = passive_deletes self.remote_side = util.to_set(remote_side) self.enable_typechecks = enable_typechecks self._parent_join_cache = {} if cascade is not None: self.cascade = mapperutil.CascadeOptions(cascade) else: if private: self.cascade = mapperutil.CascadeOptions("all, delete-orphan") else: self.cascade = mapperutil.CascadeOptions("save-update, merge") self.association = association self.order_by = order_by self.attributeext = attributeext if isinstance(backref, str): # propigate explicitly sent primary/secondary join conditions to the BackRef object if # just a string was sent if secondary is not None: # reverse primary/secondary in case of a many-to-many self.backref = BackRef(backref, primaryjoin=secondaryjoin, secondaryjoin=primaryjoin) else: self.backref = BackRef(backref, primaryjoin=primaryjoin, secondaryjoin=secondaryjoin) else: self.backref = backref self.is_backref = is_backref