def where(self, *where: Combinable, **kwargs):
for i in where:
self.where_delegate.where(i)
for key, value in kwargs.items():
column = self._meta.get_column_by_name(key)
self.where_delegate.where(Where(column=column, value=value, operator=Equal))
return self
def ilike(self, value: str) -> Where:
if "%" not in value:
raise ValueError("% is required for ilike operators")
if self._meta.engine_type == "postgres":
operator: t.Type[ComparisonOperator] = ILike
else:
colored_warning(
"SQLite doesn't support ILIKE currently, falling back to LIKE."
)
operator = Like
return Where(column=self, value=value, operator=operator)
def ilike(self, value: str) -> Where:
"""
Only Postgres supports ILIKE. It's used for case insensitive matching.
For SQLite, it's just proxied to a LIKE query instead.
"""
if self._meta.engine_type == "postgres":
operator: t.Type[ComparisonOperator] = ILike
else:
colored_warning(
"SQLite doesn't support ILIKE, falling back to LIKE.")
operator = Like
return Where(column=self, value=value, operator=operator)
def like(self, value: str) -> Where:
"""
Both SQLite and Postgres support LIKE, but they mean different things.
In Postgres, LIKE is case sensitive (i.e. 'foo' equals 'foo', but
'foo' doesn't equal 'Foo').
In SQLite, LIKE is case insensitive for ASCII characters
(i.e. 'foo' equals 'Foo'). But not for non-ASCII characters. To learn
more, see the docs:
https://sqlite.org/lang_expr.html#the_like_glob_regexp_and_match_operators
"""
return Where(column=self, value=value, operator=Like)
def all(self, value: t.Any) -> Where:
"""
Check if all of the items in the array match the given value.
.. code-block:: python
>>> Ticket.select().where(Ticket.seat_numbers.all(510)).run_sync()
"""
engine_type = self._meta.table._meta.db.engine_type
if engine_type == "postgres":
return Where(column=self, value=value, operator=ArrayAll)
elif engine_type == "sqlite":
raise ValueError("Unsupported by SQLite")
else:
raise ValueError("Unrecognised engine type")
def __ne__(self, value) -> Where: # type: ignore
return Where(column=self, value=value, operator=NotEqual)
def __eq__(self, value) -> Where: # type: ignore
if value is None:
return Where(column=self, operator=IsNull)
else:
return Where(column=self, value=value, operator=Equal)
def __ge__(self, value) -> Where:
return Where(column=self, value=value, operator=GreaterEqualThan)
def __le__(self, value) -> Where:
return Where(column=self, value=value, operator=LessEqualThan)
def not_like(self, value: str) -> Where:
if "%" not in value:
raise ValueError("% is required for like operators")
return Where(column=self, value=value, operator=NotLike)
def not_in(self, values: t.List[t.Any]) -> Where:
if len(values) == 0:
raise ValueError(
"The `values` list argument must contain at least one value.")
return Where(column=self, values=values, operator=NotIn)
def is_not_null(self) -> Where:
"""
Can be used instead of `MyTable.column == None`, because some linters
don't like a comparison to None.
"""
return Where(column=self, operator=IsNotNull)
def __ne__(self, value) -> Where: # type: ignore[override]
if value is None:
return Where(column=self, operator=IsNotNull)
else:
return Where(column=self, value=value, operator=NotEqual)
def not_like(self, value: str) -> Where:
return Where(column=self, value=value, operator=NotLike)
