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:
if self.direction is MANYTOONE:
eq_pairs = criterion_as_pairs(
self.primaryjoin, consider_as_referenced_keys=self.remote_side, any_operator=True
)
else:
eq_pairs = criterion_as_pairs(
self.primaryjoin, consider_as_foreign_keys=self.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 _determine_local_remote_pairs(self):
if not self.local_remote_pairs:
if self.remote_side:
if self.direction is MANYTOONE:
self.local_remote_pairs = [
(r, l) for l, r in
criterion_as_pairs(self.primaryjoin, consider_as_referenced_keys=self.remote_side, any_operator=True)
]
else:
self.local_remote_pairs = criterion_as_pairs(self.primaryjoin, consider_as_foreign_keys=self.remote_side, any_operator=True)
if not self.local_remote_pairs:
raise sa_exc.ArgumentError("Relation %s could not determine any local/remote column pairs from remote side argument %r" % (self, self.remote_side))
else:
if self.viewonly:
eq_pairs = self.synchronize_pairs
if self.secondaryjoin:
eq_pairs += self.secondary_synchronize_pairs
else:
eq_pairs = criterion_as_pairs(self.primaryjoin, consider_as_foreign_keys=self._foreign_keys, any_operator=True)
if self.secondaryjoin:
eq_pairs += criterion_as_pairs(self.secondaryjoin, consider_as_foreign_keys=self._foreign_keys, any_operator=True)
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.local_remote_pairs = [(r, l) for l, r in eq_pairs]
else:
self.local_remote_pairs = eq_pairs
elif self.remote_side:
raise sa_exc.ArgumentError("remote_side argument is redundant against more detailed _local_remote_side argument.")
for l, r in self.local_remote_pairs:
if self.direction is ONETOMANY and not self._col_is_part_of_mappings(l):
raise sa_exc.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 and not self._col_is_part_of_mappings(r):
raise sa_exc.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))
self.local_side, self.remote_side = [util.ordered_column_set(x) for x in zip(*list(self.local_remote_pairs))]
def __determine_remote_side(self):
if self.remote_side:
if self.direction is MANYTOONE:
eq_pairs = criterion_as_pairs(self.primaryjoin, consider_as_referenced_keys=self.remote_side, any_operator=True)
else:
eq_pairs = criterion_as_pairs(self.primaryjoin, consider_as_foreign_keys=self.remote_side, any_operator=True)
if self.secondaryjoin:
sq_pairs = criterion_as_pairs(self.secondaryjoin, consider_as_foreign_keys=self.foreign_keys, any_operator=True)
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)]
eq_pairs += sq_pairs
else:
eq_pairs = zip(self._opposite_side, self.foreign_keys)
if self.direction is MANYTOONE:
self.remote_side, self.local_side = [util.OrderedSet(s) for s in zip(*eq_pairs)]
else:
self.local_side, self.remote_side = [util.OrderedSet(s) for s in zip(*eq_pairs)]
def __determine_fks(self):
if self._legacy_foreignkey and not self._refers_to_parent_table():
self.foreign_keys = self._legacy_foreignkey
arg_foreign_keys = self.foreign_keys
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)]
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 column pairs for primaryjoin condition '%s' on relation %s. "
"If no equated pairs exist, the relation must be marked as viewonly=True." % (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)
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)]
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 column pairs for secondaryjoin condition '%s' on relation %s. "
"If no equated pairs exist, the relation must 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 _determine_synchronize_pairs(self):
if self.local_remote_pairs:
if not self._foreign_keys:
raise sa_exc.ArgumentError("foreign_keys argument is required with _local_remote_pairs argument")
self.synchronize_pairs = []
for l, r in self.local_remote_pairs:
if r in self._foreign_keys:
self.synchronize_pairs.append((l, r))
elif l in self._foreign_keys:
self.synchronize_pairs.append((r, l))
else:
eq_pairs = criterion_as_pairs(self.primaryjoin, consider_as_foreign_keys=self._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 self.viewonly and r in self._foreign_keys]
if not eq_pairs:
if not self.viewonly and criterion_as_pairs(self.primaryjoin, consider_as_foreign_keys=self._foreign_keys, any_operator=True):
raise sa_exc.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 self._foreign_keys:
raise sa_exc.ArgumentError("Could not determine relation direction for "
"primaryjoin condition '%s', on relation %s. "
"Are the columns in 'foreign_keys' present within the given "
"join condition ?" % (self.primaryjoin, self))
else:
raise sa_exc.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.synchronize_pairs = eq_pairs
if self.secondaryjoin:
sq_pairs = criterion_as_pairs(self.secondaryjoin, consider_as_foreign_keys=self._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 self._foreign_keys]
if not sq_pairs:
if not self.viewonly and criterion_as_pairs(self.secondaryjoin, consider_as_foreign_keys=self._foreign_keys, any_operator=True):
raise sa_exc.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 sa_exc.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.secondary_synchronize_pairs = sq_pairs
else:
self.secondary_synchronize_pairs = None
self._foreign_keys = util.column_set(r for l, r in self.synchronize_pairs)
if self.secondary_synchronize_pairs:
self._foreign_keys.update(r for l, r in self.secondary_synchronize_pairs)
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 _determine_local_remote_pairs(self):
if not self.local_remote_pairs:
if self.remote_side:
if self.direction is MANYTOONE:
self.local_remote_pairs = [
(r, l)
for l, r in criterion_as_pairs(
self.primaryjoin, consider_as_referenced_keys=self.remote_side, any_operator=True
)
]
else:
self.local_remote_pairs = criterion_as_pairs(
self.primaryjoin, consider_as_foreign_keys=self.remote_side, any_operator=True
)
if not self.local_remote_pairs:
raise sa_exc.ArgumentError(
"Relation %s could not determine any local/remote column pairs from remote side argument %r"
% (self, self.remote_side)
)
else:
if self.viewonly:
eq_pairs = self.synchronize_pairs
if self.secondaryjoin:
eq_pairs += self.secondary_synchronize_pairs
else:
eq_pairs = criterion_as_pairs(
self.primaryjoin, consider_as_foreign_keys=self._foreign_keys, any_operator=True
)
if self.secondaryjoin:
eq_pairs += criterion_as_pairs(
self.secondaryjoin, consider_as_foreign_keys=self._foreign_keys, any_operator=True
)
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.local_remote_pairs = [(r, l) for l, r in eq_pairs]
else:
self.local_remote_pairs = eq_pairs
elif self.remote_side:
raise sa_exc.ArgumentError(
"remote_side argument is redundant against more detailed _local_remote_side argument."
)
for l, r in self.local_remote_pairs:
if self.direction is ONETOMANY and not self._col_is_part_of_mappings(l):
raise sa_exc.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 and not self._col_is_part_of_mappings(r):
raise sa_exc.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)
)
self.local_side, self.remote_side = [util.ordered_column_set(x) for x in zip(*list(self.local_remote_pairs))]
def _determine_synchronize_pairs(self):
if self.local_remote_pairs:
if not self._foreign_keys:
raise sa_exc.ArgumentError("foreign_keys argument is required with _local_remote_pairs argument")
self.synchronize_pairs = []
for l, r in self.local_remote_pairs:
if r in self._foreign_keys:
self.synchronize_pairs.append((l, r))
elif l in self._foreign_keys:
self.synchronize_pairs.append((r, l))
else:
eq_pairs = criterion_as_pairs(
self.primaryjoin, consider_as_foreign_keys=self._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 self.viewonly
and r in self._foreign_keys
]
if not eq_pairs:
if not self.viewonly and criterion_as_pairs(
self.primaryjoin, consider_as_foreign_keys=self._foreign_keys, any_operator=True
):
raise sa_exc.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 self._foreign_keys:
raise sa_exc.ArgumentError(
"Could not determine relation direction for "
"primaryjoin condition '%s', on relation %s. "
"Are the columns in 'foreign_keys' present within the given "
"join condition ?" % (self.primaryjoin, self)
)
else:
raise sa_exc.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.synchronize_pairs = eq_pairs
if self.secondaryjoin:
sq_pairs = criterion_as_pairs(
self.secondaryjoin, consider_as_foreign_keys=self._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 self._foreign_keys
]
if not sq_pairs:
if not self.viewonly and criterion_as_pairs(
self.secondaryjoin, consider_as_foreign_keys=self._foreign_keys, any_operator=True
):
raise sa_exc.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 sa_exc.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.secondary_synchronize_pairs = sq_pairs
else:
self.secondary_synchronize_pairs = None
self._foreign_keys = util.column_set(r for l, r in self.synchronize_pairs)
if self.secondary_synchronize_pairs:
self._foreign_keys.update(r for l, r in self.secondary_synchronize_pairs)
