Операторы

Категория	Описание
Логические	Операторы булевой логики (AND, OR, NOT).
Сравнения	Сравнение значений и проверка принадлежности (=, >, <, IS, BETWEEN, IN, ALL, ANY).
Числовые	Арифметические операторы (+, -, *, /, //, %, унарные).
Побитовые	Побитовые операторы для целых чисел (&, \|, XOR).
Строковые	Сопоставление строк и конкатенация (LIKE, ILIKE, \|\|, ^@).
Регулярные выражения	Сопоставление с регулярными выражениями (~, ~*, REGEXP, RLIKE).
Индексация	Доступ к полям структур и элементам массивов (->, ->>, #>, [n]).

Логические операторы

Оператор	Описание
AND	Объединяет условия и возвращает True, если оба условия имеют значение True.
OR	Объединяет условия и возвращает True, если хотя бы одно из условий имеет значение True.
NOT	Отрицает условие и возвращает True, если условие имеет значение False.

AND: Объединяет условия и возвращает True, если оба условия имеют значение True.

Пример:

df = pl.DataFrame({"foo": [10, 20, 50, 35], "bar": [10, 10, 50, 35]})
df.sql("""
  SELECT * FROM self
  WHERE (foo >= bar) AND (bar < 50) AND (foo != 10)
""")
# shape: (2, 2)
# ┌─────┬─────┐
# │ foo ┆ bar │
# │ --- ┆ --- │
# │ i64 ┆ i64 │
# ╞═════╪═════╡
# │ 20  ┆ 10  │
# │ 35  ┆ 35  │
# └─────┴─────┘

OR: Объединяет условия и возвращает True, если хотя бы одно из условий имеет значение True.

Пример:

df = pl.DataFrame({"foo": [10, 20, 50, 35], "bar": [10, 10, 50, 35]})
df.sql("""
  SELECT * FROM self
  WHERE (foo % 2 != 0) OR (bar > 40)
""")
# shape: (2, 2)
# ┌─────┬─────┐
# │ foo ┆ bar │
# │ --- ┆ --- │
# │ i64 ┆ i64 │
# ╞═════╪═════╡
# │ 50  ┆ 50  │
# │ 35  ┆ 35  │
# └─────┴─────┘

NOT: Отрицает условие и возвращает True, если условие имеет значение False.

Пример:

df = pl.DataFrame({"foo": [10, 20, 50, 35], "bar": [10, 10, 50, 35]})
df.sql("""
  SELECT * FROM self
  WHERE NOT(foo % 2 != 0 OR bar > 40)
""")
# shape: (2, 2)
# ┌─────┬─────┐
# │ foo ┆ bar │
# │ --- ┆ --- │
# │ i64 ┆ i64 │
# ╞═════╪═════╡
# │ 10  ┆ 10  │
# │ 20  ┆ 10  │
# └─────┴─────┘

Сравнения

Оператор	Описание
>, >=	Больше (или равно).
<, <=	Меньше (или равно).
==, !=, <>	Равно (или не равно).
IS [NOT]	Проверяет, равно ли значение одному из специальных значений NULL, TRUE или FALSE.
IS [NOT] DISTINCT FROM, <=>	Проверяет, отличается ли значение от другого значения; это эквивалент `==` (и `!=`), безопасный для NULL.
[NOT] BETWEEN	Проверяет, находится ли значение между двумя другими значениями.
[NOT] IN	Проверяет, содержится ли значение в списке значений.
> ALL, < ALL, …	Сравнивает значение со всеми значениями в столбце.
> ANY, < ANY, = ANY, …	Сравнивает значение с любым значением в столбце.

Возвращает True, если первое значение больше второго.

Пример:

df = pl.DataFrame({"n": [1000, 3000, 5000]})
df.sql("SELECT * FROM self WHERE n > 3000")
# shape: (1, 1)
# ┌──────┐
# │ n    │
# │ ---  │
# │ i64  │
# ╞══════╡
# │ 5000 │
# └──────┘

df.sql("SELECT * FROM self WHERE n >= 3000")
# shape: (2, 1)
# ┌──────┐
# │ n    │
# │ ---  │
# │ i64  │
# ╞══════╡
# │ 3000 │
# │ 5000 │
# └──────┘

Возвращает True, если первое значение меньше второго.

Пример:

df = pl.DataFrame({"n": [1000, 3000, 5000]})
df.sql("SELECT * FROM self WHERE n < 3000")
# shape: (1, 1)
# ┌──────┐
# │ n    │
# │ ---  │
# │ i64  │
# ╞══════╡
# │ 1000 │
# └──────┘

df.sql("SELECT * FROM self WHERE n <= 3000")
# shape: (2, 1)
# ┌──────┐
# │ n    │
# │ ---  │
# │ i64  │
# ╞══════╡
# │ 1000 │
# │ 3000 │
# └──────┘

Возвращает True, если два значения считаются равными.

Пример:

df = pl.DataFrame({"n": [1000, 3000, 5000]})
df.sql("SELECT * FROM self WHERE n = 3000")
# shape: (1, 1)
# ┌──────┐
# │ n    │
# │ ---  │
# │ i64  │
# ╞══════╡
# │ 3000 │
# └──────┘

df.sql("SELECT * FROM self WHERE n != 3000")
# shape: (2, 1)
# ┌──────┐
# │ n    │
# │ ---  │
# │ i64  │
# ╞══════╡
# │ 1000 │
# │ 5000 │
# └──────┘

IS: Возвращает True, если первое значение идентично второму (обычно это одно из значений NULL, TRUE или FALSE). В отличие от == (и !=), этот оператор всегда возвращает TRUE или FALSE, но никогда не NULL.

Пример:

df = pl.DataFrame({"lbl": ["aa", "bb", "cc"], "n": [1000, None, 5000]})
df.sql("SELECT * FROM self WHERE n IS NULL")
# shape: (1, 2)
# ┌─────┬──────┐
# │ lbl ┆ n    │
# │ --- ┆ ---  │
# │ str ┆ i64  │
# ╞═════╪══════╡
# │ bb  ┆ null │
# └─────┴──────┘

df.sql("SELECT * FROM self WHERE n IS NOT NULL")
# shape: (2, 2)
# ┌─────┬──────┐
# │ lbl ┆ n    │
# │ --- ┆ ---  │
# │ str ┆ i64  │
# ╞═════╪══════╡
# │ aa  ┆ 1000 │
# │ cc  ┆ 5000 │
# └─────┴──────┘

Пример:

df = pl.DataFrame({"n1": [2222, None, 8888], "n2": [4444, None, 8888]})
df.sql("SELECT * FROM self WHERE n1 IS DISTINCT FROM n2")
# shape: (1, 2)
# ┌──────┬──────┐
# │ n1   ┆ n2   │
# │ ---  ┆ ---  │
# │ i64  ┆ i64  │
# ╞══════╪══════╡
# │ 2222 ┆ 4444 │
# └──────┴──────┘

df.sql("SELECT * FROM self WHERE n1 IS NOT DISTINCT FROM n2")
df.sql("SELECT * FROM self WHERE n1 <=> n2")
# shape: (2, 2)
# ┌──────┬──────┐
# │ n1   ┆ n2   │
# │ ---  ┆ ---  │
# │ i64  ┆ i64  │
# ╞══════╪══════╡
# │ null ┆ null │
# │ 8888 ┆ 8888 │
# └──────┴──────┘

BETWEEN: Возвращает True, если первое значение находится между вторым и третьим значениями (включительно).

Пример:

df = pl.DataFrame({"n": [1000, 2000, 3000, 4000]})
df.sql("SELECT * FROM self WHERE n BETWEEN 2000 AND 3000")
# shape: (2, 1)
# ┌──────┐
# │ n    │
# │ ---  │
# │ i64  │
# ╞══════╡
# │ 2000 │
# │ 3000 │
# └──────┘

df.sql("SELECT * FROM self WHERE n NOT BETWEEN 2000 AND 3000")
# shape: (2, 1)
# ┌──────┐
# │ n    │
# │ ---  │
# │ i64  │
# ╞══════╡
# │ 1000 │
# │ 4000 │
# └──────┘

IN: Возвращает True, если значение найдено в заданном списке (или результате подзапроса).

Пример:

df = pl.DataFrame({"n": [1, 2, 3, 4, 5]})
df.sql("SELECT * FROM self WHERE n IN (2, 4)")
# shape: (2, 1)
# ┌─────┐
# │ n   │
# │ --- │
# │ i64 │
# ╞═════╡
# │ 2   │
# │ 4   │
# └─────┘

df.sql("SELECT * FROM self WHERE n NOT IN (2, 4)")
# shape: (3, 1)
# ┌─────┐
# │ n   │
# │ --- │
# │ i64 │
# ╞═════╡
# │ 1   │
# │ 3   │
# │ 5   │
# └─────┘

Пример:

df = pl.DataFrame({"a": [1, 5, 10], "b": [3, 3, 3]})
df.sql("SELECT * FROM self WHERE a > ALL(b)")
# shape: (2, 2)
# ┌─────┬─────┐
# │ a   ┆ b   │
# │ --- ┆ --- │
# │ i64 ┆ i64 │
# ╞═════╪═════╡
# │ 5   ┆ 3   │
# │ 10  ┆ 3   │
# └─────┴─────┘

Пример:

df = pl.DataFrame({"a": [1, 5, 10], "b": [3, 7, 3]})
df.sql("SELECT * FROM self WHERE a < ANY(b)")
# shape: (2, 2)
# ┌─────┬─────┐
# │ a   ┆ b   │
# │ --- ┆ --- │
# │ i64 ┆ i64 │
# ╞═════╪═════╡
# │ 1   ┆ 3   │
# │ 5   ┆ 7   │
# └─────┴─────┘

Числовые операторы

Оператор	Описание
+, -	Сложение и вычитание.
*, /	Умножение и деление.
%	Деление по модулю (остаток).
Unary +, -	Унарные плюс и минус.

Пример:

df = pl.DataFrame({"a": [10, 20, 30], "b": [3, 7, 4]})
df.sql("SELECT a + b AS sum, a - b AS diff FROM self")
# shape: (3, 2)
# ┌─────┬──────┐
# │ sum ┆ diff │
# │ --- ┆ ---  │
# │ i64 ┆ i64  │
# ╞═════╪══════╡
# │ 13  ┆ 7    │
# │ 27  ┆ 13   │
# │ 34  ┆ 26   │
# └─────┴──────┘

Изменено в версии 1.41.0: Оператор / теперь выполняет настоящее деление и всегда возвращает результат типа float. Для целочисленного деления (с округлением вниз) используйте //.

Пример:

df = pl.DataFrame({"a": [10, 20, 30], "b": [3, 4, 5]})
df.sql("""
    SELECT
      *,
      a * b AS mul,
      a / b AS div,
      a // b AS int_div
    FROM self
""")
# shape: (3, 5)
# ┌─────┬─────┬─────┬──────────┬─────────┐
# │ a   ┆ b   ┆ mul ┆ div      ┆ int_div │
# │ --- ┆ --- ┆ --- ┆ ---      ┆ ---     │
# │ i64 ┆ i64 ┆ i64 ┆ f64      ┆ i64     │
# ╞═════╪═════╪═════╪══════════╪═════════╡
# │ 10  ┆ 3   ┆ 30  ┆ 3.333333 ┆ 3       │
# │ 20  ┆ 4   ┆ 80  ┆ 5.0      ┆ 5       │
# │ 30  ┆ 5   ┆ 150 ┆ 6.0      ┆ 6       │
# └─────┴─────┴─────┴──────────┴─────────┘

%: Возвращает остаток от деления.

Пример:

df = pl.DataFrame({"a": [10, 20, 30], "b": [3, 7, 4]})
df.sql("SELECT a % b AS mod FROM self")
# shape: (3, 1)
# ┌─────┐
# │ mod │
# │ --- │
# │ i64 │
# ╞═════╡
# │ 1   │
# │ 6   │
# │ 2   │
# └─────┘

Пример:

df = pl.DataFrame({"n": [1, -2, 3]})
df.sql("SELECT -n AS neg FROM self")
# shape: (3, 1)
# ┌─────┐
# │ neg │
# │ --- │
# │ i64 │
# ╞═════╡
# │ -1  │
# │ 2   │
# │ -3  │
# └─────┘

Побитовые операторы

Оператор	Описание
&	Побитовое AND.
\|	Побитовое OR.
XOR	Побитовое исключающее OR.

&: Выполняет побитовое AND для двух целочисленных значений.

Пример:

df = pl.DataFrame({"a": [12, 10], "b": [10, 6]})
df.sql("SELECT a & b AS bw_and FROM self")
# shape: (2, 1)
# ┌────────┐
# │ bw_and │
# │ ---    │
# │ i64    │
# ╞════════╡
# │ 8      │
# │ 2      │
# └────────┘

|: Выполняет побитовое OR для двух целочисленных значений.

Пример:

df = pl.DataFrame({"a": [12, 10], "b": [10, 6]})
df.sql("SELECT a | b AS bw_or FROM self")
# shape: (2, 1)
# ┌───────┐
# │ bw_or │
# │ ---   │
# │ i64   │
# ╞═══════╡
# │ 14    │
# │ 14    │
# └───────┘

XOR: Выполняет побитовое исключающее OR для двух целочисленных значений.

Пример:

df = pl.DataFrame({"a": [12, 10], "b": [10, 6]})
df.sql("SELECT a XOR b AS bw_xor FROM self")
# shape: (2, 1)
# ┌────────┐
# │ bw_xor │
# │ ---    │
# │ i64    │
# ╞════════╡
# │ 6      │
# │ 12     │
# └────────┘

Строковые операторы

Оператор	Описание
[NOT] LIKE, ~~, !~~	Сопоставляет строку с выражением SQL «LIKE».
[NOT] ILIKE, ~~, !~~	Сопоставляет строку с выражением SQL «ILIKE» (вариант «LIKE», не учитывающий регистр).
\|\|	Объединяет два строковых значения.
^@	Проверяет, начинается ли строка с заданного префикса.

Примечание

Операторы LIKE сопоставляют строки с шаблонами, используя следующие подстановочные символы:

Знак процента % соответствует нулю или более символам.
Знак подчёркивания _ соответствует одному символу.

Пример:

df = pl.DataFrame({"name": ["Alice", "Bob", "Charlie", "David"]})
df.sql("SELECT * FROM self WHERE name LIKE 'A%'")
# shape: (1, 1)
# ┌───────┐
# │ name  │
# │ ---   │
# │ str   │
# ╞═══════╡
# │ Alice │
# └───────┘

df.sql("SELECT * FROM self WHERE name NOT LIKE '%o%'")
# shape: (3, 1)
# ┌─────────┐
# │ name    │
# │ ---     │
# │ str     │
# ╞═════════╡
# │ Alice   │
# │ Charlie │
# │ David   │
# └─────────┘

Использование синтаксиса операторов в стиле PostgreSQL:

df.sql("SELECT * FROM self WHERE name ~~ '_o%'")
# shape: (1, 1)
# ┌──────┐
# │ name │
# │ ---  │
# │ str  │
# ╞══════╡
# │ Bob  │
# └──────┘

Пример:

df = pl.DataFrame({"name": ["Alice", "bob", "CHARLIE", "David"]})
df.sql("SELECT * FROM self WHERE name ILIKE '%LI%'")
# shape: (2, 1)
# ┌─────────┐
# │ name    │
# │ ---     │
# │ str     │
# ╞═════════╡
# │ Alice   │
# │ CHARLIE │
# └─────────┘

df.sql("SELECT * FROM self WHERE name NOT ILIKE 'b%'")
# shape: (3, 1)
# ┌─────────┐
# │ name    │
# │ ---     │
# │ str     │
# ╞═════════╡
# │ Alice   │
# │ CHARLIE │
# │ David   │
# └─────────┘

||: Объединяет два или более строковых значения.

Пример:

df = pl.DataFrame({"first": ["Alice", "Bob"], "last": ["Smith", "Jones"]})
df.sql("SELECT first || ' ' || last AS full_name FROM self")
# shape: (2, 1)
# ┌─────────────┐
# │ full_name   │
# │ ---         │
# │ str         │
# ╞═════════════╡
# │ Alice Smith │
# │ Bob Jones   │
# └─────────────┘

Примечание

Нестрочные значения автоматически преобразуются в строки при использовании оператора ||.

^@: Возвращает True, если первое строковое значение начинается со второго.

Пример:

df = pl.DataFrame({"name": ["Alice", "Bob", "Arthur", "David"]})
df.sql("SELECT * FROM self WHERE name ^@ 'A'")
# shape: (2, 1)
# ┌────────┐
# │ name   │
# │ ---    │
# │ str    │
# ╞════════╡
# │ Alice  │
# │ Arthur │
# └────────┘

Регулярные выражения

Оператор	Описание
~, !~	Сопоставляет строку с регулярным выражением.
~, !~	Сопоставляет строку с регулярным выражением без учёта регистра.
[NOT] REGEXP, [NOT] RLIKE	Сопоставляет строку с регулярным выражением с помощью ключевого синтаксиса.

Пример:

df = pl.DataFrame({"idx": [0, 1, 2, 3], "lbl": ["foo", "bar", "baz", "zap"]})
df.sql("SELECT * FROM self WHERE lbl ~ '.*[aeiou]$'")
# shape: (1, 2)
# ┌─────┬─────┐
# │ idx ┆ lbl │
# │ --- ┆ --- │
# │ i64 ┆ str │
# ╞═════╪═════╡
# │ 0   ┆ foo │
# └─────┴─────┘

df.sql("SELECT * FROM self WHERE lbl !~ '^b[aeiou]'")
# shape: (2, 2)
# ┌─────┬─────┐
# │ idx ┆ lbl │
# │ --- ┆ --- │
# │ i64 ┆ str │
# ╞═════╪═════╡
# │ 0   ┆ foo │
# │ 3   ┆ zap │
# └─────┴─────┘

Пример:

df = pl.DataFrame({"idx": [0, 1, 2, 3], "lbl": ["FOO", "bar", "Baz", "ZAP"]})
df.sql("SELECT * FROM self WHERE lbl ~* '.*[aeiou]$'")
# shape: (1, 2)
# ┌─────┬─────┐
# │ idx ┆ lbl │
# │ --- ┆ --- │
# │ i64 ┆ str │
# ╞═════╪═════╡
# │ 0   ┆ FOO │
# └─────┴─────┘

df.sql("SELECT * FROM self WHERE lbl !~* '^b[aeiou]'")
# shape: (2, 2)
# ┌─────┬─────┐
# │ idx ┆ lbl │
# │ --- ┆ --- │
# │ i64 ┆ str │
# ╞═════╪═════╡
# │ 0   ┆ FOO │
# │ 3   ┆ ZAP │
# └─────┴─────┘

Эти операторы эквивалентны операторам ~ и !~, но вместо символов используют ключевые слова.

Пример:

df = pl.DataFrame({"idx": [0, 1, 2, 3], "lbl": ["foo", "bar", "baz", "zap"]})
df.sql("SELECT * FROM self WHERE lbl REGEXP '^b'")
# shape: (2, 2)
# ┌─────┬─────┐
# │ idx ┆ lbl │
# │ --- ┆ --- │
# │ i64 ┆ str │
# ╞═════╪═════╡
# │ 1   ┆ bar │
# │ 2   ┆ baz │
# └─────┴─────┘

df.sql("SELECT * FROM self WHERE lbl NOT RLIKE '[aeiou]$'")
# shape: (3, 2)
# ┌─────┬─────┐
# │ idx ┆ lbl │
# │ --- ┆ --- │
# │ i64 ┆ str │
# ╞═════╪═════╡
# │ 1   ┆ bar │
# │ 2   ┆ baz │
# │ 3   ┆ zap │
# └─────┴─────┘

Индексация

Оператор	Описание
->	Обращается к полю структуры по имени или индексу и возвращает значение исходного типа.
->>	Обращается к полю структуры по имени или индексу и возвращает строку.
#>, #>>	Обращается к полю структуры по пути и возвращает значение исходного типа или строку.
[n]	Обращается к элементу массива по индексу (индексация начинается с 1).

->: Обращается к полю структуры по имени или порядковому индексу и возвращает значение исходного типа.

Пример:

df = pl.DataFrame(
    {"data": [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]}
)
df.sql("SELECT data -> 'name' AS name, data -> 'age' AS age FROM self")
# shape: (2, 2)
# ┌───────┬─────┐
# │ name  ┆ age │
# │ ---   ┆ --- │
# │ str   ┆ i64 │
# ╞═══════╪═════╡
# │ Alice ┆ 30  │
# │ Bob   ┆ 25  │
# └───────┴─────┘

->>: Обращается к полю структуры по имени или порядковому индексу и возвращает значение, преобразованное в строку.

Пример:

df = pl.DataFrame(
    {"data": [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]}
)
df.sql("SELECT data ->> 'age' AS age FROM self")
# shape: (2, 1)
# ┌─────┐
# │ age │
# │ --- │
# │ str │
# ╞═════╡
# │ 30  │
# │ 25  │
# └─────┘

Пример:

df = pl.DataFrame(
    {"data": [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]}
)
df.sql("SELECT data #>> 'name' AS name FROM self")
# shape: (2, 1)
# ┌───────┐
# │ name  │
# │ ---   │
# │ str   │
# ╞═══════╡
# │ Alice │
# │ Bob   │
# └───────┘

[n]: Обращается к элементу массива по индексу. Индексация элементов массива в SQL начинается с 1.

Пример:

df = pl.DataFrame({"arr": [[10, 20, 30], [40, 50, 60]]})
df.sql("SELECT arr[1] AS first, arr[3] AS last FROM self")
# shape: (2, 2)
# ┌───────┬──────┐
# │ first ┆ last │
# │ ---   ┆ ---  │
# │ i64   ┆ i64  │
# ╞═══════╪══════╡
# │ 10    ┆ 30   │
# │ 40    ┆ 60   │
# └───────┴──────┘

© 2020 Ritchie Vink
© 2022 Polars contributors
Licensed under the MIT License.
https://docs.pola.rs/api/python/stable/reference/sql/operators/index.html