AlkantarClanX12
Your IP : 18.217.140.224
# sql/traversals.py
# Copyright (C) 2005-2024 the SQLAlchemy authors and contributors
# <see AUTHORS file>
#
# This module is part of SQLAlchemy and is released under
# the MIT License: https://www.opensource.org/licenses/mit-license.php
# mypy: allow-untyped-defs, allow-untyped-calls
from __future__ import annotations
from collections import deque
import collections.abc as collections_abc
import itertools
from itertools import zip_longest
import operator
import typing
from typing import Any
from typing import Callable
from typing import Deque
from typing import Dict
from typing import Iterable
from typing import Optional
from typing import Set
from typing import Tuple
from typing import Type
from . import operators
from .cache_key import HasCacheKey
from .visitors import _TraverseInternalsType
from .visitors import anon_map
from .visitors import ExternallyTraversible
from .visitors import HasTraversalDispatch
from .visitors import HasTraverseInternals
from .. import util
from ..util import langhelpers
from ..util.typing import Self
SKIP_TRAVERSE = util.symbol("skip_traverse")
COMPARE_FAILED = False
COMPARE_SUCCEEDED = True
def compare(obj1: Any, obj2: Any, **kw: Any) -> bool:
strategy: TraversalComparatorStrategy
if kw.get("use_proxies", False):
strategy = ColIdentityComparatorStrategy()
else:
strategy = TraversalComparatorStrategy()
return strategy.compare(obj1, obj2, **kw)
def _preconfigure_traversals(target_hierarchy: Type[Any]) -> None:
for cls in util.walk_subclasses(target_hierarchy):
if hasattr(cls, "_generate_cache_attrs") and hasattr(
cls, "_traverse_internals"
):
cls._generate_cache_attrs()
_copy_internals.generate_dispatch(
cls,
cls._traverse_internals,
"_generated_copy_internals_traversal",
)
_get_children.generate_dispatch(
cls,
cls._traverse_internals,
"_generated_get_children_traversal",
)
class HasShallowCopy(HasTraverseInternals):
"""attribute-wide operations that are useful for classes that use
__slots__ and therefore can't operate on their attributes in a dictionary.
"""
__slots__ = ()
if typing.TYPE_CHECKING:
def _generated_shallow_copy_traversal(self, other: Self) -> None: ...
def _generated_shallow_from_dict_traversal(
self, d: Dict[str, Any]
) -> None: ...
def _generated_shallow_to_dict_traversal(self) -> Dict[str, Any]: ...
@classmethod
def _generate_shallow_copy(
cls,
internal_dispatch: _TraverseInternalsType,
method_name: str,
) -> Callable[[Self, Self], None]:
code = "\n".join(
f" other.{attrname} = self.{attrname}"
for attrname, _ in internal_dispatch
)
meth_text = f"def {method_name}(self, other):\n{code}\n"
return langhelpers._exec_code_in_env(meth_text, {}, method_name)
@classmethod
def _generate_shallow_to_dict(
cls,
internal_dispatch: _TraverseInternalsType,
method_name: str,
) -> Callable[[Self], Dict[str, Any]]:
code = ",\n".join(
f" '{attrname}': self.{attrname}"
for attrname, _ in internal_dispatch
)
meth_text = f"def {method_name}(self):\n return {{{code}}}\n"
return langhelpers._exec_code_in_env(meth_text, {}, method_name)
@classmethod
def _generate_shallow_from_dict(
cls,
internal_dispatch: _TraverseInternalsType,
method_name: str,
) -> Callable[[Self, Dict[str, Any]], None]:
code = "\n".join(
f" self.{attrname} = d['{attrname}']"
for attrname, _ in internal_dispatch
)
meth_text = f"def {method_name}(self, d):\n{code}\n"
return langhelpers._exec_code_in_env(meth_text, {}, method_name)
def _shallow_from_dict(self, d: Dict[str, Any]) -> None:
cls = self.__class__
shallow_from_dict: Callable[[HasShallowCopy, Dict[str, Any]], None]
try:
shallow_from_dict = cls.__dict__[
"_generated_shallow_from_dict_traversal"
]
except KeyError:
shallow_from_dict = self._generate_shallow_from_dict(
cls._traverse_internals,
"_generated_shallow_from_dict_traversal",
)
cls._generated_shallow_from_dict_traversal = shallow_from_dict # type: ignore # noqa: E501
shallow_from_dict(self, d)
def _shallow_to_dict(self) -> Dict[str, Any]:
cls = self.__class__
shallow_to_dict: Callable[[HasShallowCopy], Dict[str, Any]]
try:
shallow_to_dict = cls.__dict__[
"_generated_shallow_to_dict_traversal"
]
except KeyError:
shallow_to_dict = self._generate_shallow_to_dict(
cls._traverse_internals, "_generated_shallow_to_dict_traversal"
)
cls._generated_shallow_to_dict_traversal = shallow_to_dict # type: ignore # noqa: E501
return shallow_to_dict(self)
def _shallow_copy_to(self, other: Self) -> None:
cls = self.__class__
shallow_copy: Callable[[Self, Self], None]
try:
shallow_copy = cls.__dict__["_generated_shallow_copy_traversal"]
except KeyError:
shallow_copy = self._generate_shallow_copy(
cls._traverse_internals, "_generated_shallow_copy_traversal"
)
cls._generated_shallow_copy_traversal = shallow_copy # type: ignore # noqa: E501
shallow_copy(self, other)
def _clone(self, **kw: Any) -> Self:
"""Create a shallow copy"""
c = self.__class__.__new__(self.__class__)
self._shallow_copy_to(c)
return c
class GenerativeOnTraversal(HasShallowCopy):
"""Supplies Generative behavior but making use of traversals to shallow
copy.
.. seealso::
:class:`sqlalchemy.sql.base.Generative`
"""
__slots__ = ()
def _generate(self) -> Self:
cls = self.__class__
s = cls.__new__(cls)
self._shallow_copy_to(s)
return s
def _clone(element, **kw):
return element._clone()
class HasCopyInternals(HasTraverseInternals):
__slots__ = ()
def _clone(self, **kw):
raise NotImplementedError()
def _copy_internals(
self, *, omit_attrs: Iterable[str] = (), **kw: Any
) -> None:
"""Reassign internal elements to be clones of themselves.
Called during a copy-and-traverse operation on newly
shallow-copied elements to create a deep copy.
The given clone function should be used, which may be applying
additional transformations to the element (i.e. replacement
traversal, cloned traversal, annotations).
"""
try:
traverse_internals = self._traverse_internals
except AttributeError:
# user-defined classes may not have a _traverse_internals
return
for attrname, obj, meth in _copy_internals.run_generated_dispatch(
self, traverse_internals, "_generated_copy_internals_traversal"
):
if attrname in omit_attrs:
continue
if obj is not None:
result = meth(attrname, self, obj, **kw)
if result is not None:
setattr(self, attrname, result)
class _CopyInternalsTraversal(HasTraversalDispatch):
"""Generate a _copy_internals internal traversal dispatch for classes
with a _traverse_internals collection."""
def visit_clauseelement(
self, attrname, parent, element, clone=_clone, **kw
):
return clone(element, **kw)
def visit_clauseelement_list(
self, attrname, parent, element, clone=_clone, **kw
):
return [clone(clause, **kw) for clause in element]
def visit_clauseelement_tuple(
self, attrname, parent, element, clone=_clone, **kw
):
return tuple([clone(clause, **kw) for clause in element])
def visit_executable_options(
self, attrname, parent, element, clone=_clone, **kw
):
return tuple([clone(clause, **kw) for clause in element])
def visit_clauseelement_unordered_set(
self, attrname, parent, element, clone=_clone, **kw
):
return {clone(clause, **kw) for clause in element}
def visit_clauseelement_tuples(
self, attrname, parent, element, clone=_clone, **kw
):
return [
tuple(clone(tup_elem, **kw) for tup_elem in elem)
for elem in element
]
def visit_string_clauseelement_dict(
self, attrname, parent, element, clone=_clone, **kw
):
return {key: clone(value, **kw) for key, value in element.items()}
def visit_setup_join_tuple(
self, attrname, parent, element, clone=_clone, **kw
):
return tuple(
(
clone(target, **kw) if target is not None else None,
clone(onclause, **kw) if onclause is not None else None,
clone(from_, **kw) if from_ is not None else None,
flags,
)
for (target, onclause, from_, flags) in element
)
def visit_memoized_select_entities(self, attrname, parent, element, **kw):
return self.visit_clauseelement_tuple(attrname, parent, element, **kw)
def visit_dml_ordered_values(
self, attrname, parent, element, clone=_clone, **kw
):
# sequence of 2-tuples
return [
(
(
clone(key, **kw)
if hasattr(key, "__clause_element__")
else key
),
clone(value, **kw),
)
for key, value in element
]
def visit_dml_values(self, attrname, parent, element, clone=_clone, **kw):
return {
(
clone(key, **kw) if hasattr(key, "__clause_element__") else key
): clone(value, **kw)
for key, value in element.items()
}
def visit_dml_multi_values(
self, attrname, parent, element, clone=_clone, **kw
):
# sequence of sequences, each sequence contains a list/dict/tuple
def copy(elem):
if isinstance(elem, (list, tuple)):
return [
(
clone(value, **kw)
if hasattr(value, "__clause_element__")
else value
)
for value in elem
]
elif isinstance(elem, dict):
return {
(
clone(key, **kw)
if hasattr(key, "__clause_element__")
else key
): (
clone(value, **kw)
if hasattr(value, "__clause_element__")
else value
)
for key, value in elem.items()
}
else:
# TODO: use abc classes
assert False
return [
[copy(sub_element) for sub_element in sequence]
for sequence in element
]
def visit_propagate_attrs(
self, attrname, parent, element, clone=_clone, **kw
):
return element
_copy_internals = _CopyInternalsTraversal()
def _flatten_clauseelement(element):
while hasattr(element, "__clause_element__") and not getattr(
element, "is_clause_element", False
):
element = element.__clause_element__()
return element
class _GetChildrenTraversal(HasTraversalDispatch):
"""Generate a _children_traversal internal traversal dispatch for classes
with a _traverse_internals collection."""
def visit_has_cache_key(self, element, **kw):
# the GetChildren traversal refers explicitly to ClauseElement
# structures. Within these, a plain HasCacheKey is not a
# ClauseElement, so don't include these.
return ()
def visit_clauseelement(self, element, **kw):
return (element,)
def visit_clauseelement_list(self, element, **kw):
return element
def visit_clauseelement_tuple(self, element, **kw):
return element
def visit_clauseelement_tuples(self, element, **kw):
return itertools.chain.from_iterable(element)
def visit_fromclause_canonical_column_collection(self, element, **kw):
return ()
def visit_string_clauseelement_dict(self, element, **kw):
return element.values()
def visit_fromclause_ordered_set(self, element, **kw):
return element
def visit_clauseelement_unordered_set(self, element, **kw):
return element
def visit_setup_join_tuple(self, element, **kw):
for target, onclause, from_, flags in element:
if from_ is not None:
yield from_
if not isinstance(target, str):
yield _flatten_clauseelement(target)
if onclause is not None and not isinstance(onclause, str):
yield _flatten_clauseelement(onclause)
def visit_memoized_select_entities(self, element, **kw):
return self.visit_clauseelement_tuple(element, **kw)
def visit_dml_ordered_values(self, element, **kw):
for k, v in element:
if hasattr(k, "__clause_element__"):
yield k
yield v
def visit_dml_values(self, element, **kw):
expr_values = {k for k in element if hasattr(k, "__clause_element__")}
str_values = expr_values.symmetric_difference(element)
for k in sorted(str_values):
yield element[k]
for k in expr_values:
yield k
yield element[k]
def visit_dml_multi_values(self, element, **kw):
return ()
def visit_propagate_attrs(self, element, **kw):
return ()
_get_children = _GetChildrenTraversal()
@util.preload_module("sqlalchemy.sql.elements")
def _resolve_name_for_compare(element, name, anon_map, **kw):
if isinstance(name, util.preloaded.sql_elements._anonymous_label):
name = name.apply_map(anon_map)
return name
class TraversalComparatorStrategy(HasTraversalDispatch, util.MemoizedSlots):
__slots__ = "stack", "cache", "anon_map"
def __init__(self):
self.stack: Deque[
Tuple[
Optional[ExternallyTraversible],
Optional[ExternallyTraversible],
]
] = deque()
self.cache = set()
def _memoized_attr_anon_map(self):
return (anon_map(), anon_map())
def compare(
self,
obj1: ExternallyTraversible,
obj2: ExternallyTraversible,
**kw: Any,
) -> bool:
stack = self.stack
cache = self.cache
compare_annotations = kw.get("compare_annotations", False)
stack.append((obj1, obj2))
while stack:
left, right = stack.popleft()
if left is right:
continue
elif left is None or right is None:
# we know they are different so no match
return False
elif (left, right) in cache:
continue
cache.add((left, right))
visit_name = left.__visit_name__
if visit_name != right.__visit_name__:
return False
meth = getattr(self, "compare_%s" % visit_name, None)
if meth:
attributes_compared = meth(left, right, **kw)
if attributes_compared is COMPARE_FAILED:
return False
elif attributes_compared is SKIP_TRAVERSE:
continue
# attributes_compared is returned as a list of attribute
# names that were "handled" by the comparison method above.
# remaining attribute names in the _traverse_internals
# will be compared.
else:
attributes_compared = ()
for (
(left_attrname, left_visit_sym),
(right_attrname, right_visit_sym),
) in zip_longest(
left._traverse_internals,
right._traverse_internals,
fillvalue=(None, None),
):
if not compare_annotations and (
(left_attrname == "_annotations")
or (right_attrname == "_annotations")
):
continue
if (
left_attrname != right_attrname
or left_visit_sym is not right_visit_sym
):
return False
elif left_attrname in attributes_compared:
continue
assert left_visit_sym is not None
assert left_attrname is not None
assert right_attrname is not None
dispatch = self.dispatch(left_visit_sym)
assert dispatch is not None, (
f"{self.__class__} has no dispatch for "
f"'{self._dispatch_lookup[left_visit_sym]}'"
)
left_child = operator.attrgetter(left_attrname)(left)
right_child = operator.attrgetter(right_attrname)(right)
if left_child is None:
if right_child is not None:
return False
else:
continue
elif right_child is None:
return False
comparison = dispatch(
left_attrname, left, left_child, right, right_child, **kw
)
if comparison is COMPARE_FAILED:
return False
return True
def compare_inner(self, obj1, obj2, **kw):
comparator = self.__class__()
return comparator.compare(obj1, obj2, **kw)
def visit_has_cache_key(
self, attrname, left_parent, left, right_parent, right, **kw
):
if left._gen_cache_key(self.anon_map[0], []) != right._gen_cache_key(
self.anon_map[1], []
):
return COMPARE_FAILED
def visit_propagate_attrs(
self, attrname, left_parent, left, right_parent, right, **kw
):
return self.compare_inner(
left.get("plugin_subject", None), right.get("plugin_subject", None)
)
def visit_has_cache_key_list(
self, attrname, left_parent, left, right_parent, right, **kw
):
for l, r in zip_longest(left, right, fillvalue=None):
if l is None:
if r is not None:
return COMPARE_FAILED
else:
continue
elif r is None:
return COMPARE_FAILED
if l._gen_cache_key(self.anon_map[0], []) != r._gen_cache_key(
self.anon_map[1], []
):
return COMPARE_FAILED
def visit_executable_options(
self, attrname, left_parent, left, right_parent, right, **kw
):
for l, r in zip_longest(left, right, fillvalue=None):
if l is None:
if r is not None:
return COMPARE_FAILED
else:
continue
elif r is None:
return COMPARE_FAILED
if (
l._gen_cache_key(self.anon_map[0], [])
if l._is_has_cache_key
else l
) != (
r._gen_cache_key(self.anon_map[1], [])
if r._is_has_cache_key
else r
):
return COMPARE_FAILED
def visit_clauseelement(
self, attrname, left_parent, left, right_parent, right, **kw
):
self.stack.append((left, right))
def visit_fromclause_canonical_column_collection(
self, attrname, left_parent, left, right_parent, right, **kw
):
for lcol, rcol in zip_longest(left, right, fillvalue=None):
self.stack.append((lcol, rcol))
def visit_fromclause_derived_column_collection(
self, attrname, left_parent, left, right_parent, right, **kw
):
pass
def visit_string_clauseelement_dict(
self, attrname, left_parent, left, right_parent, right, **kw
):
for lstr, rstr in zip_longest(
sorted(left), sorted(right), fillvalue=None
):
if lstr != rstr:
return COMPARE_FAILED
self.stack.append((left[lstr], right[rstr]))
def visit_clauseelement_tuples(
self, attrname, left_parent, left, right_parent, right, **kw
):
for ltup, rtup in zip_longest(left, right, fillvalue=None):
if ltup is None or rtup is None:
return COMPARE_FAILED
for l, r in zip_longest(ltup, rtup, fillvalue=None):
self.stack.append((l, r))
def visit_clauseelement_list(
self, attrname, left_parent, left, right_parent, right, **kw
):
for l, r in zip_longest(left, right, fillvalue=None):
self.stack.append((l, r))
def visit_clauseelement_tuple(
self, attrname, left_parent, left, right_parent, right, **kw
):
for l, r in zip_longest(left, right, fillvalue=None):
self.stack.append((l, r))
def _compare_unordered_sequences(self, seq1, seq2, **kw):
if seq1 is None:
return seq2 is None
completed: Set[object] = set()
for clause in seq1:
for other_clause in set(seq2).difference(completed):
if self.compare_inner(clause, other_clause, **kw):
completed.add(other_clause)
break
return len(completed) == len(seq1) == len(seq2)
def visit_clauseelement_unordered_set(
self, attrname, left_parent, left, right_parent, right, **kw
):
return self._compare_unordered_sequences(left, right, **kw)
def visit_fromclause_ordered_set(
self, attrname, left_parent, left, right_parent, right, **kw
):
for l, r in zip_longest(left, right, fillvalue=None):
self.stack.append((l, r))
def visit_string(
self, attrname, left_parent, left, right_parent, right, **kw
):
return left == right
def visit_string_list(
self, attrname, left_parent, left, right_parent, right, **kw
):
return left == right
def visit_string_multi_dict(
self, attrname, left_parent, left, right_parent, right, **kw
):
for lk, rk in zip_longest(
sorted(left.keys()), sorted(right.keys()), fillvalue=(None, None)
):
if lk != rk:
return COMPARE_FAILED
lv, rv = left[lk], right[rk]
lhc = isinstance(left, HasCacheKey)
rhc = isinstance(right, HasCacheKey)
if lhc and rhc:
if lv._gen_cache_key(
self.anon_map[0], []
) != rv._gen_cache_key(self.anon_map[1], []):
return COMPARE_FAILED
elif lhc != rhc:
return COMPARE_FAILED
elif lv != rv:
return COMPARE_FAILED
def visit_multi(
self, attrname, left_parent, left, right_parent, right, **kw
):
lhc = isinstance(left, HasCacheKey)
rhc = isinstance(right, HasCacheKey)
if lhc and rhc:
if left._gen_cache_key(
self.anon_map[0], []
) != right._gen_cache_key(self.anon_map[1], []):
return COMPARE_FAILED
elif lhc != rhc:
return COMPARE_FAILED
else:
return left == right
def visit_anon_name(
self, attrname, left_parent, left, right_parent, right, **kw
):
return _resolve_name_for_compare(
left_parent, left, self.anon_map[0], **kw
) == _resolve_name_for_compare(
right_parent, right, self.anon_map[1], **kw
)
def visit_boolean(
self, attrname, left_parent, left, right_parent, right, **kw
):
return left == right
def visit_operator(
self, attrname, left_parent, left, right_parent, right, **kw
):
return left == right
def visit_type(
self, attrname, left_parent, left, right_parent, right, **kw
):
return left._compare_type_affinity(right)
def visit_plain_dict(
self, attrname, left_parent, left, right_parent, right, **kw
):
return left == right
def visit_dialect_options(
self, attrname, left_parent, left, right_parent, right, **kw
):
return left == right
def visit_annotations_key(
self, attrname, left_parent, left, right_parent, right, **kw
):
if left and right:
return (
left_parent._annotations_cache_key
== right_parent._annotations_cache_key
)
else:
return left == right
def visit_with_context_options(
self, attrname, left_parent, left, right_parent, right, **kw
):
return tuple((fn.__code__, c_key) for fn, c_key in left) == tuple(
(fn.__code__, c_key) for fn, c_key in right
)
def visit_plain_obj(
self, attrname, left_parent, left, right_parent, right, **kw
):
return left == right
def visit_named_ddl_element(
self, attrname, left_parent, left, right_parent, right, **kw
):
if left is None:
if right is not None:
return COMPARE_FAILED
return left.name == right.name
def visit_prefix_sequence(
self, attrname, left_parent, left, right_parent, right, **kw
):
for (l_clause, l_str), (r_clause, r_str) in zip_longest(
left, right, fillvalue=(None, None)
):
if l_str != r_str:
return COMPARE_FAILED
else:
self.stack.append((l_clause, r_clause))
def visit_setup_join_tuple(
self, attrname, left_parent, left, right_parent, right, **kw
):
# TODO: look at attrname for "legacy_join" and use different structure
for (
(l_target, l_onclause, l_from, l_flags),
(r_target, r_onclause, r_from, r_flags),
) in zip_longest(left, right, fillvalue=(None, None, None, None)):
if l_flags != r_flags:
return COMPARE_FAILED
self.stack.append((l_target, r_target))
self.stack.append((l_onclause, r_onclause))
self.stack.append((l_from, r_from))
def visit_memoized_select_entities(
self, attrname, left_parent, left, right_parent, right, **kw
):
return self.visit_clauseelement_tuple(
attrname, left_parent, left, right_parent, right, **kw
)
def visit_table_hint_list(
self, attrname, left_parent, left, right_parent, right, **kw
):
left_keys = sorted(left, key=lambda elem: (elem[0].fullname, elem[1]))
right_keys = sorted(
right, key=lambda elem: (elem[0].fullname, elem[1])
)
for (ltable, ldialect), (rtable, rdialect) in zip_longest(
left_keys, right_keys, fillvalue=(None, None)
):
if ldialect != rdialect:
return COMPARE_FAILED
elif left[(ltable, ldialect)] != right[(rtable, rdialect)]:
return COMPARE_FAILED
else:
self.stack.append((ltable, rtable))
def visit_statement_hint_list(
self, attrname, left_parent, left, right_parent, right, **kw
):
return left == right
def visit_unknown_structure(
self, attrname, left_parent, left, right_parent, right, **kw
):
raise NotImplementedError()
def visit_dml_ordered_values(
self, attrname, left_parent, left, right_parent, right, **kw
):
# sequence of tuple pairs
for (lk, lv), (rk, rv) in zip_longest(
left, right, fillvalue=(None, None)
):
if not self._compare_dml_values_or_ce(lk, rk, **kw):
return COMPARE_FAILED
def _compare_dml_values_or_ce(self, lv, rv, **kw):
lvce = hasattr(lv, "__clause_element__")
rvce = hasattr(rv, "__clause_element__")
if lvce != rvce:
return False
elif lvce and not self.compare_inner(lv, rv, **kw):
return False
elif not lvce and lv != rv:
return False
elif not self.compare_inner(lv, rv, **kw):
return False
return True
def visit_dml_values(
self, attrname, left_parent, left, right_parent, right, **kw
):
if left is None or right is None or len(left) != len(right):
return COMPARE_FAILED
if isinstance(left, collections_abc.Sequence):
for lv, rv in zip(left, right):
if not self._compare_dml_values_or_ce(lv, rv, **kw):
return COMPARE_FAILED
elif isinstance(right, collections_abc.Sequence):
return COMPARE_FAILED
else:
# dictionaries guaranteed to support insert ordering in
# py37 so that we can compare the keys in order. without
# this, we can't compare SQL expression keys because we don't
# know which key is which
for (lk, lv), (rk, rv) in zip(left.items(), right.items()):
if not self._compare_dml_values_or_ce(lk, rk, **kw):
return COMPARE_FAILED
if not self._compare_dml_values_or_ce(lv, rv, **kw):
return COMPARE_FAILED
def visit_dml_multi_values(
self, attrname, left_parent, left, right_parent, right, **kw
):
for lseq, rseq in zip_longest(left, right, fillvalue=None):
if lseq is None or rseq is None:
return COMPARE_FAILED
for ld, rd in zip_longest(lseq, rseq, fillvalue=None):
if (
self.visit_dml_values(
attrname, left_parent, ld, right_parent, rd, **kw
)
is COMPARE_FAILED
):
return COMPARE_FAILED
def compare_expression_clauselist(self, left, right, **kw):
if left.operator is right.operator:
if operators.is_associative(left.operator):
if self._compare_unordered_sequences(
left.clauses, right.clauses, **kw
):
return ["operator", "clauses"]
else:
return COMPARE_FAILED
else:
return ["operator"]
else:
return COMPARE_FAILED
def compare_clauselist(self, left, right, **kw):
return self.compare_expression_clauselist(left, right, **kw)
def compare_binary(self, left, right, **kw):
if left.operator == right.operator:
if operators.is_commutative(left.operator):
if (
self.compare_inner(left.left, right.left, **kw)
and self.compare_inner(left.right, right.right, **kw)
) or (
self.compare_inner(left.left, right.right, **kw)
and self.compare_inner(left.right, right.left, **kw)
):
return ["operator", "negate", "left", "right"]
else:
return COMPARE_FAILED
else:
return ["operator", "negate"]
else:
return COMPARE_FAILED
def compare_bindparam(self, left, right, **kw):
compare_keys = kw.pop("compare_keys", True)
compare_values = kw.pop("compare_values", True)
if compare_values:
omit = []
else:
# this means, "skip these, we already compared"
omit = ["callable", "value"]
if not compare_keys:
omit.append("key")
return omit
class ColIdentityComparatorStrategy(TraversalComparatorStrategy):
def compare_column_element(
self, left, right, use_proxies=True, equivalents=(), **kw
):
"""Compare ColumnElements using proxies and equivalent collections.
This is a comparison strategy specific to the ORM.
"""
to_compare = (right,)
if equivalents and right in equivalents:
to_compare = equivalents[right].union(to_compare)
for oth in to_compare:
if use_proxies and left.shares_lineage(oth):
return SKIP_TRAVERSE
elif hash(left) == hash(right):
return SKIP_TRAVERSE
else:
return COMPARE_FAILED
def compare_column(self, left, right, **kw):
return self.compare_column_element(left, right, **kw)
def compare_label(self, left, right, **kw):
return self.compare_column_element(left, right, **kw)
def compare_table(self, left, right, **kw):
# tables compare on identity, since it's not really feasible to
# compare them column by column with the above rules
return SKIP_TRAVERSE if left is right else COMPARE_FAILED