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
