# be using this method.
return self.type.comparator_factory(self) # type: ignore
- def self_group(
- self, against: Optional[OperatorType] = None
- ) -> ClauseElement:
+ def self_group(self, against: Optional[OperatorType] = None):
if against is operators.in_op:
return Grouping(self)
else:
def _from_objects(self) -> List[FromClause]:
return list(itertools.chain(*[c._from_objects for c in self.clauses]))
- def self_group(
- self, against: Optional[OperatorType] = None
- ) -> ClauseElement:
+ def self_group(self, against: Optional[OperatorType] = None):
if self.group and operators.is_precedent(self.operator, against):
return Grouping(self)
else:
def is_comparison(self):
return operators.is_comparison(self.operator)
- def self_group(
- self, against: Optional[OperatorType] = None
- ) -> ClauseElement:
+ def self_group(self, against: Optional[OperatorType] = None):
if (
self.group
and operators.is_precedent(self.operator, against)
def _select_iterable(self) -> _SelectIterable:
return (self,)
- def self_group(
- self, against: Optional[OperatorType] = None
- ) -> ClauseElement:
+ def self_group(self, against: Optional[OperatorType] = None):
if not self.clauses:
return self
else:
]
)
- def self_group(
- self, against: Optional[OperatorType] = None
- ) -> ClauseElement:
+ def self_group(self, against: Optional[OperatorType] = None):
# Tuple is parenthesized by definition.
return self
def wrapped_column_expression(self):
return self.clause
- def self_group(
- self, against: Optional[OperatorType] = None
- ) -> ClauseElement:
+ def self_group(self, against: Optional[OperatorType] = None):
grouped = self.clause.self_group(against=against)
if grouped is not self.clause:
return TypeCoerce(grouped, self.type)
else:
return ClauseElement._negate(self)
- def self_group(self, against=None):
+ def self_group(self, against: Optional[OperatorType] = None):
if self.operator and operators.is_precedent(self.operator, against):
return Grouping(self)
else:
def wrapped_column_expression(self):
return self.element
- def self_group(
- self, against: Optional[OperatorType] = None
- ) -> ClauseElement:
+ def self_group(self, against: Optional[OperatorType] = None):
return self
def _negate(self):
)
self.type = type_api.NULLTYPE
- def self_group(
- self, against: Optional[OperatorType] = None
- ) -> ClauseElement:
+ def self_group(self, against: Optional[OperatorType] = None):
assert against is operator.getitem
return self
element: ClauseElement
- def self_group(
- self, against: Optional[OperatorType] = None
- ) -> ClauseElement:
+ def self_group(self, against: Optional[OperatorType] = None):
return self
def _ungroup(self):
def element(self) -> ColumnElement[_T]:
return self._element.self_group(against=operators.as_)
- def self_group(
- self, against: Optional[OperatorType] = None
- ) -> ClauseElement:
+ def self_group(self, against: Optional[OperatorType] = None):
return self._apply_to_inner(self._element.self_group, against=against)
def _negate(self):