SELECT

SELECT запрашивает данные из одной или нескольких таблиц, представлений или материализованных представлений. Оператор SELECT обычно состоит из следующих предложений:

WITH
WHERE и операторы
GROUP BY
HAVING
UNION
INTERSECT
EXCEPT/MINUS
ORDER BY
LIMIT
OFFSET
Соединения
Подзапросы
DISTINCT
Псевдонимы

SELECT может работать как независимый оператор или как предложение, вложенное в другие операторы. Вывод предложения SELECT может использоваться как входные данные для других операторов.

Оператор запроса Selena в основном соответствует стандарту SQL92. Вот краткое описание поддерживаемого использования SELECT.

ПРИМЕЧАНИЕ

Для запроса данных из таблиц, представлений или материализованных представлений во внутренней таблице Selena, вы должны иметь привилегию SELECT на эти объекты. Для запроса данных из таблиц, представлений или материализованных представлений во внешнем источнике данных, вы должны иметь привилегию USAGE на соответствующий external catalog.

WITH

Предложение, которое может быть добавлено перед оператором SELECT для определения псевдонима для сложного выражения, на которое ссылаются несколько раз внутри SELECT.

Аналогично CRATE VIEW, но имена таблиц и столбцов, определенные в предложении, не сохраняются после завершения запроса и не конфликтуют с именами в фактической таблице или VIEW.

Преимущества использования предложения WITH:

Удобно и легко поддерживать, уменьшая дублирование в запросах.

Легче читать и понимать SQL-код, абстрагируя наиболее сложные части запроса в отдельные блоки.

Примеры:

-- Define one subquery at the outer level, and another at the inner level as part of the
-- initial stage of the UNION ALL query.

with t1 as (select 1),t2 as (select 2)
select * from t1 union all select * from t2;

Join

Операции соединения объединяют данные из двух или более таблиц, а затем возвращают результирующий набор некоторых столбцов из некоторых из них.

Selena поддерживает самосоединения, перекрестные соединения, внутренние соединения, внешние соединения, полусоединения и антисоединения. Внешние соединения включают левые соединения, правые соединения и полные соединения.

Синтаксис:

SELECT select_list FROM
table_or_subquery1 [INNER] JOIN table_or_subquery2 |
table_or_subquery1 {LEFT [OUTER] | RIGHT [OUTER] | FULL [OUTER]} JOIN table_or_subquery2 |
table_or_subquery1 {LEFT | RIGHT} SEMI JOIN table_or_subquery2 |
table_or_subquery1 {LEFT | RIGHT} ANTI JOIN table_or_subquery2 |
[ ON col1 = col2 [AND col3 = col4 ...] |
USING (col1 [, col2 ...]) ]
[other_join_clause ...]
[ WHERE where_clauses ]

SELECT select_list FROM
table_or_subquery1, table_or_subquery2 [, table_or_subquery3 ...]
[other_join_clause ...]
WHERE
col1 = col2 [AND col3 = col4 ...]

SELECT select_list FROM
table_or_subquery1 CROSS JOIN table_or_subquery2
[other_join_clause ...]
[ WHERE where_clauses ]

Self Join

Selena поддерживает самосоединения, которые являются самосоединениями и самосоединениями. Например, разные столбцы одной и той же таблицы соединяются.

На самом деле нет специального синтаксиса для идентификации самосоединения. Условия с обеих сторон соединения в самосоединении происходят из одной и той же таблицы.

Нам нужно назначить им разные псевдонимы.

Примеры:

SELECT lhs.id, rhs.parent, lhs.c1, rhs.c2 FROM tree_data lhs, tree_data rhs WHERE lhs.id = rhs.parent;

Cross Join

Перекрестное соединение может производить много результатов, поэтому перекрестное соединение следует использовать с осторожностью.

Даже если вам нужно использовать перекрестное соединение, вам нужно использовать условия фильтрации и убедиться, что возвращается меньше результатов. Пример:

SELECT * FROM t1, t2;

SELECT * FROM t1 CROSS JOIN t2;

Inner Join

Внутреннее соединение является наиболее известным и часто используемым соединением. Возвращает результаты из столбцов, запрошенных из двух похожих таблиц, соединенных, если столбцы обеих таблиц содержат одинаковое значение.

Если имя столбца обеих таблиц одинаково, нам нужно использовать полное имя (в форме table_name.column_name) или создать псевдоним для имени столбца.

Примеры:

Следующие три запроса эквивалентны.

SELECT t1.id, c1, c2 FROM t1, t2 WHERE t1.id = t2.id;

SELECT t1.id, c1, c2 FROM t1 JOIN t2 ON t1.id = t2.id;

SELECT t1.id, c1, c2 FROM t1 INNER JOIN t2 ON t1.id = t2.id;

Outer Join

Внешнее соединение возвращает левую или правую таблицу или все строки обеих. Если в другой таблице нет соответствующих данных, устанавливается значение NULL. Пример:

SELECT * FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.id;

SELECT * FROM t1 RIGHT OUTER JOIN t2 ON t1.id = t2.id;

SELECT * FROM t1 FULL OUTER JOIN t2 ON t1.id = t2.id;

Equivalent and unequal join

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

Неравное соединение может использоваться в условиях соединения!=, знак равенства. Неравные соединения производят большое количество результатов и могут превысить лимит памяти во время вычисления.

Используйте с осторожностью. Неравное соединение поддерживает только внутреннее соединение. Пример:

SELECT t1.id, c1, c2 FROM t1 INNER JOIN t2 ON t1.id = t2.id;

SELECT t1.id, c1, c2 FROM t1 INNER JOIN t2 ON t1.id > t2.id;

Semi Join

Левое полусоединение возвращает только строки в левой таблице, которые соответствуют данным в правой таблице, независимо от того, сколько строк соответствует данным в правой таблице.

Эта строка левой таблицы возвращается максимум один раз. Правое полусоединение работает аналогично, за исключением того, что возвращаемые данные являются правой таблицей.

Примеры:

SELECT t1.c1, t1.c2, t1.c2 FROM t1 LEFT SEMI JOIN t2 ON t1.id = t2.id;

Anti Join

Левое антисоединение возвращает только строки из левой таблицы, которые не соответствуют правой таблице.

Правое антисоединение обращает это сравнение, возвращая только строки из правой таблицы, которые не соответствуют левой таблице. Пример:

SELECT t1.c1, t1.c2, t1.c2 FROM t1 LEFT ANTI JOIN t2 ON t1.id = t2.id;

Equi-join and Non-equi-join

Различные соединения, поддерживаемые Selena, могут быть классифицированы как эквисоединения и неэквисоединения в зависимости от условий соединения, указанных в соединениях.

Эквисоединения	Самосоединения, перекрестные соединения, внутренние соединения, внешние соединения, полусоединения и антисоединения
Неэквисоединения	перекрестные соединения, внутренние соединения, левые полусоединения, левые антисоединения и внешние соединения

Эквисоединения

Эквисоединение использует условие соединения, в котором два элемента соединения объединяются оператором =. Пример: a JOIN b ON a.id = b.id.
Неэквисоединения

Неэквисоединение использует условие соединения, в котором два элемента соединения объединяются оператором сравнения, таким как <, <=, >, >= или <>. Пример: a JOIN b ON a.id < b.id. Неэквисоединения работают медленнее, чем эквисоединения. Мы рекомендуем проявлять осторожность при использовании неэквисоединений.

Следующие два примера показывают, как выполнять неэквисоединения:
```
SELECT t1.id, c1, c2 
FROM t1 
INNER JOIN t2 ON t1.id < t2.id;
  
SELECT t1.id, c1, c2 
FROM t1 
LEFT JOIN t2 ON t1.id > t2.id;
```

ORDER BY

Предложение ORDER BY оператора SELECT сортирует результирующий набор, сравнивая значения из одного или нескольких столбцов.

ORDER BY является времязатратной и ресурсоемкой операцией, поскольку все результаты должны быть отправлены на один узел для слияния перед тем, как результаты могут быть отсортированы. Сортировка потребляет больше ресурсов памяти, чем запрос без ORDER BY.

Поэтому, если вам нужны только первые N результатов из отсортированного результирующего набора, вы можете использовать предложение LIMIT, которое уменьшает использование памяти и сетевые накладные расходы. Если предложение LIMIT не указано, по умолчанию возвращаются первые 65535 результатов.

Синтаксис:

ORDER BY <column_name> 
    [ASC | DESC]
    [NULLS FIRST | NULLS LAST]

ASC указывает, что результаты должны быть возвращены в порядке возрастания. DESC указывает, что результаты должны быть возвращены в порядке убывания. Если порядок не указан, ASC (по возрастанию) является значением по умолчанию. Пример:

select * from big_table order by tiny_column, short_column desc;

Порядок сортировки для значений NULL: NULLS FIRST указывает, что значения NULL должны быть возвращены перед значениями, отличными от NULL. NULLS LAST указывает, что значения NULL должны быть возвращены после значений, отличных от NULL.

Примеры:

select  *  from  sales_record  order by  employee_id  nulls first;

GROUP BY

Предложение GROUP BY часто используется с агрегатными функциями, такими как COUNT(), SUM(), AVG(), MIN() и MAX().

Столбец, указанный GROUP BY, не будет участвовать в операции агрегации. Предложение GROUP BY может быть добавлено с предложением Having для фильтрации результатов, произведенных агрегатной функцией.

Примеры:

select tiny_column, sum(short_column)
from small_table 
group by tiny_column;

+-------------+---------------------+
| tiny_column |  sum('short_column')|
+-------------+---------------------+
|      1      |        2            |
|      2      |        1            |
+-------------+---------------------+

Синтаксис

SELECT ...
FROM ...
[ ... ]
GROUP BY [
    , ... |
    GROUPING SETS [, ...] (  groupSet [ , groupSet [ , ... ] ] ) |
    ROLLUP(expr  [ , expr [ , ... ] ]) |
    CUBE(expr  [ , expr [ , ... ] ])
    ]
[ ... ]

Параметры

groupSet представляет набор, состоящий из столбцов, псевдонимов или выражений в списке select. groupSet ::= { ( expr [ , expr [ , ... ] ] )}

expr указывает столбец, псевдоним или выражение в списке select.

Примечание

Selena поддерживает синтаксис, подобный PostgreSQL. Примеры синтаксиса следующие:

SELECT a, b, SUM( c ) FROM tab1 GROUP BY GROUPING SETS ( (a, b), (a), (b), ( ) );
SELECT a, b,c, SUM( d ) FROM tab1 GROUP BY ROLLUP(a,b,c)
SELECT a, b,c, SUM( d ) FROM tab1 GROUP BY CUBE(a,b,c)

ROLLUP(a,b,c) эквивалентен следующему оператору GROUPING SETS:

GROUPING SETS (
(a,b,c),
( a, b ),
( a),
( )
)

CUBE ( a, b, c ) эквивалентен следующему оператору GROUPING SETS:

GROUPING SETS (
( a, b, c ),
( a, b ),
( a,    c ),
( a       ),
(    b, c ),
(    b    ),
(       c ),
(         )
)

Примеры

Ниже приведен пример фактических данных:

SELECT * FROM t;
+------+------+------+
| k1   | k2   | k3   |
+------+------+------+
| a    | A    |    1 |
| a    | A    |    2 |
| a    | B    |    1 |
| a    | B    |    3 |
| b    | A    |    1 |
| b    | A    |    4 |
| b    | B    |    1 |
| b    | B    |    5 |
+------+------+------+
8 rows in set (0.01 sec)

SELECT k1, k2, SUM(k3) FROM t GROUP BY GROUPING SETS ( (k1, k2), (k2), (k1), ( ) );
+------+------+-----------+
| k1   | k2   | sum(`k3`) |
+------+------+-----------+
| b    | B    |         6 |
| a    | B    |         4 |
| a    | A    |         3 |
| b    | A    |         5 |
| NULL | B    |        10 |
| NULL | A    |         8 |
| a    | NULL |         7 |
| b    | NULL |        11 |
| NULL | NULL |        18 |
+------+------+-----------+
9 rows in set (0.06 sec)

> SELECT k1, k2, GROUPING_ID(k1,k2), SUM(k3) FROM t GROUP BY GROUPING SETS ((k1, k2), (k1), (k2), ());
+------+------+---------------+----------------+
| k1   | k2   | grouping_id(k1,k2) | sum(`k3`) |
+------+------+---------------+----------------+
| a    | A    |             0 |              3 |
| a    | B    |             0 |              4 |
| a    | NULL |             1 |              7 |
| b    | A    |             0 |              5 |
| b    | B    |             0 |              6 |
| b    | NULL |             1 |             11 |
| NULL | A    |             2 |              8 |
| NULL | B    |             2 |             10 |
| NULL | NULL |             3 |             18 |
+------+------+---------------+----------------+
9 rows in set (0.02 sec)

GROUP BY GROUPING SETS ｜ CUBE ｜ ROLLUP является расширением предложения GROUP BY. Он может реализовать агрегацию групп нескольких наборов в предложении GROUP BY. Результат эквивалентен операции UNION нескольких соответствующих предложений GROUP BY.

Предложение GROUP BY является частным случаем GROUP BY GROUPING SETS, содержащим только один элемент. Например, оператор GROUPING SETS:

SELECT a, b, SUM( c ) FROM tab1 GROUP BY GROUPING SETS ( (a, b), (a), (b), ( ) );

Результат запроса эквивалентен:

SELECT a, b, SUM( c ) FROM tab1 GROUP BY a, b
UNION
SELECT a, null, SUM( c ) FROM tab1 GROUP BY a
UNION
SELECT null, b, SUM( c ) FROM tab1 GROUP BY b
UNION
SELECT null, null, SUM( c ) FROM tab1

GROUPING(expr) указывает, является ли столбец агрегатным столбцом. Если это агрегатный столбец, то 0, иначе 1.

GROUPING_ID(expr [ , expr [ , ... ] ]) аналогичен GROUPING. GROUPING_ ID вычисляет битовое значение списка столбцов в соответствии с указанным порядком столбцов, и каждый бит является значением GROUPING.

Функция GROUPING_ID() возвращает десятичное значение битового вектора.

HAVING

Предложение HAVING не фильтрует данные строк в таблице, а фильтрует результаты агрегатных функций.

Вообще говоря, HAVING используется с агрегатными функциями (такими как COUNT(), SUM(), AVG(), MIN(), MAX()) и предложениями GROUP BY.

Примеры:

select tiny_column, sum(short_column) 
from small_table 
group by tiny_column 
having sum(short_column) = 1;

+-------------+---------------------+
|tiny_column  | sum('short_column') |
+-------------+---------------------+
|         2   |        1            |
+-------------+---------------------+

1 row in set (0.07 sec)

select tiny_column, sum(short_column) 
from small_table 
group by tiny_column 
having tiny_column > 1;

+-------------+---------------------+
|tiny_column  | sum('short_column') |
+-------------+---------------------+
|      2      |          1          |
+-------------+---------------------+

1 row in set (0.07 sec)

LIMIT

Предложения LIMIT используются для ограничения максимального количества возвращаемых строк. Установка максимального количества возвращаемых строк может помочь Selena оптимизировать использование памяти.

Это предложение в основном используется в следующих сценариях:

Возвращает результат запроса top-N.

Подумайте о том, что включено в таблицу ниже.

Размер результирующего набора запроса необходимо ограничить из-за большого количества данных в таблице или потому, что предложение where не фильтрует слишком много данных.

Инструкции по использованию: Значение предложения LIMIT должно быть числовой литеральной константой.

Примеры:

mysql> select tiny_column from small_table limit 1;

+-------------+
|tiny_column  |
+-------------+
|     1       |
+-------------+

1 row in set (0.02 sec)

mysql> select tiny_column from small_table limit 10000;

+-------------+
|tiny_column  |
+-------------+
|      1      |
|      2      |
+-------------+

2 rows in set (0.01 sec)

OFFSET

Предложение OFFSET заставляет результирующий набор пропустить первые несколько строк и вернуть следующие результаты напрямую.

Результирующий набор по умолчанию начинается со строки 0, поэтому offset 0 и отсутствие offset возвращают одинаковые результаты.

Вообще говоря, предложения OFFSET должны использоваться с предложениями ORDER BY и LIMIT, чтобы быть действительными.

Примеры:

mysql> select varchar_column from big_table order by varchar_column limit 3;

+----------------+
| varchar_column | 
+----------------+
|    beijing     | 
|    chongqing   | 
|    tianjin     | 
+----------------+

3 rows in set (0.02 sec)

mysql> select varchar_column from big_table order by varchar_column limit 1 offset 0;

+----------------+
|varchar_column  |
+----------------+
|     beijing    |
+----------------+

1 row in set (0.01 sec)

mysql> select varchar_column from big_table order by varchar_column limit 1 offset 1;

+----------------+
|varchar_column  |
+----------------+
|    chongqing   | 
+----------------+

1 row in set (0.01 sec)

mysql> select varchar_column from big_table order by varchar_column limit 1 offset 2;

+----------------+
|varchar_column  |
+----------------+
|     tianjin    |     
+----------------+

1 row in set (0.02 sec)

Примечание: Разрешено использовать синтаксис offset без order by, но offset не имеет смысла в этом случае.

В этом случае берется только значение limit, а значение offset игнорируется. Поэтому без order by.

Offset превышает максимальное количество строк в результирующем наборе и все еще является результатом. Рекомендуется, чтобы пользователи использовали offset с order by.

UNION

Объединяет результат нескольких запросов.

Синтаксис:

query_1 UNION [DISTINCT | ALL] query_2

DISTINCT (по умолчанию) возвращает только уникальные строки. UNION эквивалентен UNION DISTINCT.
ALL объединяет все строки, включая дубликаты. Поскольку дедупликация требует много памяти, запросы, использующие UNION ALL, работают быстрее и потребляют меньше памяти. Для лучшей производительности используйте UNION ALL.

ПРИМЕЧАНИЕ

Каждый оператор запроса должен возвращать одинаковое количество столбцов, и столбцы должны иметь совместимые типы данных.

Примеры:

Создайте таблицы select1 и select2.

CREATE TABLE select1(
    id          INT,
    price       INT
    )
DISTRIBUTED BY HASH(id);

INSERT INTO select1 VALUES
    (1,2),
    (1,2),
    (2,3),
    (5,6),
    (5,6);

CREATE TABLE select2(
    id          INT,
    price       INT
    )
DISTRIBUTED BY HASH(id);

INSERT INTO select2 VALUES
    (2,3),
    (3,4),
    (5,6),
    (7,8);

Пример 1: Вернуть все ID в двух таблицах, включая дубликаты.

mysql> (select id from select1) union all (select id from select2) order by id;

+------+
| id   |
+------+
|    1 |
|    1 |
|    2 |
|    2 |
|    3 |
|    5 |
|    5 |
|    5 |
|    7 |
+------+
11 rows in set (0.02 sec)

Пример 2: Вернуть все уникальные ID в двух таблицах. Следующие два оператора эквивалентны.

mysql> (select id from select1) union (select id from select2) order by id;

+------+
| id   |
+------+
|    1 |
|    2 |
|    3 |
|    5 |
|    7 |
+------+
6 rows in set (0.01 sec)

mysql> (select id from select1) union distinct (select id from select2) order by id;
+------+
| id   |
+------+
|    1 |
|    2 |
|    3 |
|    5 |
|    7 |
+------+
5 rows in set (0.02 sec)

Пример 3: Вернуть первые три ID среди всех уникальных ID в двух таблицах. Следующие два оператора эквивалентны.

mysql> (select id from select1) union distinct (select id from select2)
order by id
limit 3;
++------+
| id   |
+------+
|    1 |
|    2 |
|    3 |
+------+
4 rows in set (0.11 sec)

mysql> select * from (select id from select1 union distinct select id from select2) as t1
order by id
limit 3;
+------+
| id   |
+------+
|    1 |
|    2 |
|    3 |
+------+
3 rows in set (0.01 sec)

INTERSECT

Вычисляет пересечение результатов нескольких запросов, то есть результаты, которые появляются во всех результирующих наборах. Это предложение возвращает только уникальные строки среди результирующих наборов. Ключевое слово ALL не поддерживается.

Синтаксис:

query_1 INTERSECT [DISTINCT] query_2

ПРИМЕЧАНИЕ

INTERSECT эквивалентен INTERSECT DISTINCT.

Каждый оператор запроса должен возвращать одинаковое количество столбцов, и столбцы должны иметь совместимые типы данных.

Примеры:

Используются две таблицы из UNION.

Вернуть различные комбинации (id, price), которые являются общими для обеих таблиц. Следующие два оператора эквивалентны.

mysql> (select id, price from select1) intersect (select id, price from select2)
order by id;

+------+-------+
| id   | price |
+------+-------+
|    2 |     3 |
|    5 |     6 |
+------+-------+

mysql> (select id, price from select1) intersect distinct (select id, price from select2)
order by id;

+------+-------+
| id   | price |
+------+-------+
|    2 |     3 |
|    5 |     6 |
+------+-------+

EXCEPT/MINUS

Возвращает различные результаты левого запроса, которые не существуют в правом запросе. EXCEPT эквивалентен MINUS.

Синтаксис:

query_1 {EXCEPT | MINUS} [DISTINCT] query_2

ПРИМЕЧАНИЕ

EXCEPT эквивалентен EXCEPT DISTINCT. Ключевое слово ALL не поддерживается.

Каждый оператор запроса должен возвращать одинаковое количество столбцов, и столбцы должны иметь совместимые типы данных.

Примеры:

Используются две таблицы из UNION.

Вернуть различные комбинации (id, price) в select1, которые не могут быть найдены в select2.

mysql> (select id, price from select1) except (select id, price from select2)
order by id;
+------+-------+
| id   | price |
+------+-------+
|    1 |     2 |
+------+-------+

mysql> (select id, price from select1) minus (select id, price from select2)
order by id;
+------+-------+
| id   | price |
+------+-------+
|    1 |     2 |
+------+-------+

DISTINCT

Ключевое слово DISTINCT дедуплицирует результирующий набор. Пример:

-- Returns the unique values from one column.
select distinct tiny_column from big_table limit 2;

-- Returns the unique combinations of values from multiple columns.
select distinct tiny_column, int_column from big_table limit 2;

DISTINCT может использоваться с агрегатными функциями (обычно функциями count), и count (distinct) используется для вычисления того, сколько различных комбинаций содержится в одном или нескольких столбцах.

-- Counts the unique values from one column.
select count(distinct tiny_column) from small_table;

+-------------------------------+
| count(DISTINCT 'tiny_column') |
+-------------------------------+
|             2                 |
+-------------------------------+
1 row in set (0.06 sec)

-- Counts the unique combinations of values from multiple columns.
select count(distinct tiny_column, int_column) from big_table limit 2;

Selena поддерживает несколько агрегатных функций, использующих distinct одновременно.

-- Count the unique value from multiple aggregation function separately.
select count(distinct tiny_column, int_column), count(distinct varchar_column) from big_table;

Subquery

Подзапросы классифицируются на два типа с точки зрения релевантности:

Некоррелированный подзапрос получает свои результаты независимо от своего внешнего запроса.
Коррелированный подзапрос требует значений от своего внешнего запроса.

Noncorrelated subquery

Некоррелированные подзапросы поддерживают [NOT] IN и EXISTS.

Пример:

SELECT x FROM t1 WHERE x [NOT] IN (SELECT y FROM t2);

SELECT * FROM t1 WHERE (x,y) [NOT] IN (SELECT x,y FROM t2 LIMIT 2);

SELECT x FROM t1 WHERE EXISTS (SELECT y FROM t2 WHERE y = 1);

Начиная с версии 1.5.0, вы можете указать несколько полей в предложении WHERE SELECT... FROM... WHERE... [NOT] IN, например, WHERE (x,y) во втором операторе SELECT.

Correlated subquery

Связанные подзапросы поддерживают [NOT] IN и [NOT] EXISTS.

Пример:

SELECT * FROM t1 WHERE x [NOT] IN (SELECT a FROM t2 WHERE t1.y = t2.b);

SELECT * FROM t1 WHERE [NOT] EXISTS (SELECT a FROM t2 WHERE t1.y = t2.b);

Подзапросы также поддерживают скалярные квантовые запросы. Их можно разделить на нерелевантные скалярные квантовые запросы, связанные скалярные квантовые запросы и скалярные квантовые запросы как параметры общей функции.

Примеры:

Некоррелированный скалярный квантовый запрос с предикатом знак =. Например, вывести информацию о человеке с самой высокой зарплатой.
```
SELECT name FROM table WHERE salary = (SELECT MAX(salary) FROM table);
```
Некоррелированные скалярные квантовые запросы с предикатами >, < и т.д. Например, вывести информацию о людях, которые получают больше средней зарплаты.
```
SELECT name FROM table WHERE salary > (SELECT AVG(salary) FROM table);
```
Связанные скалярные квантовые запросы. Например, вывести информацию о самой высокой зарплате для каждого отдела.
```
SELECT name FROM table a WHERE salary = (SELECT MAX(salary) FROM table b WHERE b.Department= a.Department);
```
Скалярные квантовые запросы используются как параметры обычных функций.
```
SELECT name FROM table WHERE salary = abs((SELECT MAX(salary) FROM table));
```

Where and Operators

SQL-операторы представляют собой серию функций, используемых для сравнения, и широко используются в предложениях where операторов select.

Arithmetic operator

Арифметические операторы обычно появляются в выражениях, которые содержат левые, правые и чаще всего левые операнды

+и-: могут использоваться как единичные или как 2-арные операторы. При использовании в качестве единичного оператора, такого как +1, -2.5 или -col_ name, что означает, что значение умножается на +1 или -1.

Таким образом, ячеечный оператор + возвращает неизмененное значение, а ячеечный оператор - изменяет биты символа этого значения.

Пользователи могут наложить два ячеечных оператора, такие как +5 (возвращающий положительное значение), -+2 или +2 (возвращающий отрицательное значение), но пользователи не могут использовать два последовательных знака -.

Поскольку -- интерпретируется как комментарий в следующем операторе (когда пользователь может использовать два знака, между двумя знаками требуется пробел или скобки, такие как -(-2) или - -2, что фактически приводит к + 2).

Когда + или - является бинарным оператором, таким как 2+2, 3+1.5 или col1+col2, это означает, что левое значение добавляется или вычитается из правого значения. Оба левых и правых значения должны быть числовыми типами.

и/: представляют умножение и деление соответственно. Операнды с обеих сторон должны быть типами данных. Когда два числа умножаются.

Меньшие операнды могут быть повышены при необходимости (например, SMALLINT в INT или BIGINT), и результат выражения будет повышен до следующего большего типа.

Например, TINYINT, умноженный на INT, даст результат типа BIGINT. Когда два числа умножаются, оба операнда и результаты выражения интерпретируются как типы DOUBLE, чтобы избежать потери точности.

Если пользователь хочет преобразовать результат выражения в другой тип, его нужно преобразовать с помощью функции CAST.

%: Оператор модуляции. Возвращает остаток от деления левого операнда на правый операнд. Оба левых и правых операнда должны быть целыми числами.

&, |и ^: Битовый оператор возвращает результат битовых операций И, битовых ИЛИ, битовых исключающих ИЛИ на двух операндах. Оба операнда требуют целочисленного типа.

Если типы двух операндов битового оператора несовместимы, операнды меньшего типа повышаются до операндов большего типа, и выполняются соответствующие битовые операции.

Несколько арифметических операторов могут появляться в выражении, и пользователь может заключить соответствующее арифметическое выражение в скобки. Арифметические операторы обычно не имеют соответствующих математических функций для выражения тех же функций, что и арифметические операторы.

Например, у нас нет функции MOD() для представления оператора %. И наоборот, математические функции не имеют соответствующих арифметических операторов. Например, функция степени POW() не имеет соответствующего оператора ** возведения в степень.

Пользователи могут узнать, какие арифметические функции мы поддерживаем, через раздел Математические функции.

Between Operator

В предложении where выражения могут сравниваться как с верхними, так и с нижними границами. Если выражение больше или равно нижней границе и меньше или равно верхней границе, результат сравнения истинен.

Синтаксис:

expression BETWEEN lower_bound AND upper_bound

Тип данных: Обычно выражение оценивается как числовой тип, который также поддерживает другие типы данных. Если вы должны убедиться, что как нижние, так и верхние границы являются сравнимыми символами, вы можете использовать функцию cast().

Инструкции по использованию: Если операнд имеет тип string, обратите внимание, что длинная строка, начинающаяся с верхней границы, не будет соответствовать верхней границе, которая больше верхней границы. Например, "between'A'and'M' не будет соответствовать 'MJ'.

Если вам нужно убедиться, что выражение работает правильно, вы можете использовать функции, такие как upper(), lower(), substr(), trim().

Пример:

select c1 from t1 where month between 1 and 6;

Comparison operators

Операторы сравнения используются для сравнения двух значений. =, !=, >= применяются ко всем типам данных.

Операторы <> и != эквивалентны, что указывает на то, что два значения не равны.

In Operator

Оператор In сравнивается с коллекцией VALUE и возвращает TRUE, если он может соответствовать любому из элементов в коллекции.

Параметры и коллекции VALUE должны быть сравнимыми. Все выражения, использующие оператор IN, могут быть написаны как эквивалентные сравнения, соединенные с OR, но синтаксис IN проще, точнее и легче для оптимизации Selena.

Примеры:

select * from small_table where tiny_column in (1,2);

Like Operator

Этот оператор используется для сравнения со строкой. '' соответствует одному символу, '%' соответствует нескольким символам. Параметр должен соответствовать полной строке. Обычно размещение '%' в конце строки более практично.

Примеры:

mysql> select varchar_column from small_table where varchar_column like 'm%';

+----------------+
|varchar_column  |
+----------------+
|     milan      |
+----------------+

1 row in set (0.02 sec)

mysql> select varchar_column from small_table where varchar_column like 'm____';

+----------------+
| varchar_column | 
+----------------+
|    milan       | 
+----------------+

1 row in set (0.01 sec)

Logical Operator

Логические операторы возвращают значение BOOL, включая единичные и множественные операторы, каждый из которых обрабатывает параметры, которые являются выражениями, возвращающими значения BOOL. Поддерживаемые операторы:

AND: 2-арный оператор, оператор AND возвращает TRUE, если параметры слева и справа оба вычисляются как TRUE.

OR: 2-арный оператор, который возвращает TRUE, если один из параметров слева и справа вычисляется как TRUE. Если оба параметра FALSE, оператор OR возвращает FALSE.

NOT: Единичный оператор, результат инвертирования выражения. Если параметр TRUE, оператор возвращает FALSE; Если параметр FALSE, оператор возвращает TRUE.

Примеры:

mysql> select true and true;

+-------------------+
| (TRUE) AND (TRUE) | 
+-------------------+
|         1         | 
+-------------------+

1 row in set (0.00 sec)

mysql> select true and false;

+--------------------+
| (TRUE) AND (FALSE) | 
+--------------------+
|         0          | 
+--------------------+

1 row in set (0.01 sec)

mysql> select true or false;

+-------------------+
| (TRUE) OR (FALSE) | 
+-------------------+
|        1          | 
+-------------------+

1 row in set (0.01 sec)

mysql> select not true;

+----------+
| NOT TRUE | 
+----------+
|     0    | 
+----------+

1 row in set (0.01 sec)

Regular Expression Operator

Определяет, соответствует ли регулярное выражение. Используя стандартные регулярные выражения POSIX, '^' соответствует первой части строки, '$' соответствует концу строки.

"." соответствует любому одиночному символу, "*" соответствует нулю или более опциям, "+" соответствует одной или более опциям, "?" означает жадное представление и так далее. Регулярные выражения должны соответствовать полным значениям, а не только частям строк.

Если вы хотите соответствовать средней части, передняя часть регулярного выражения может быть написана как '^.' или '.'. '^' и '$' обычно опускаются. Оператор RLIKE и оператор REGEXP являются синонимами.

Оператор '|' является дополнительным оператором. Регулярные выражения с любой стороны '|' должны удовлетворять только одному условию стороны. Оператор '|' и регулярные выражения с обеих сторон обычно должны быть заключены в ().

Примеры:

mysql> select varchar_column from small_table where varchar_column regexp '(mi|MI).*';

+----------------+
| varchar_column | 
+----------------+
|     milan      |       
+----------------+

1 row in set (0.01 sec)

mysql> select varchar_column from small_table where varchar_column regexp 'm.*';

+----------------+
| varchar_column | 
+----------------+
|     milan      |  
+----------------+

1 row in set (0.01 sec)

Alias

Когда вы пишете имена таблиц, столбцов или выражений, которые содержат столбцы в запросе, вы можете назначить им псевдоним. Псевдонимы обычно короче и лучше запоминаются, чем оригинальные имена.

Когда нужен псевдоним, вы можете просто добавить предложение AS после имен таблиц, столбцов и выражений в списке select или списке from. Ключевое слово AS необязательно. Вы также можете указать псевдонимы непосредственно после оригинального имени без использования AS.

Если псевдоним или другой идентификатор имеет то же имя, что и внутреннее ключевое слово Selena, вам нужно заключить имя в пару обратных кавычек, например, rank.

Псевдонимы чувствительны к регистру, но псевдонимы столбцов и псевдонимы выражений не чувствительны к регистру.

Примеры:

select tiny_column as name, int_column as sex from big_table;

select sum(tiny_column) as total_count from big_table;

select one.tiny_column, two.int_column from small_table one, <br/> big_table two where one.tiny_column = two.tiny_column;

PIVOT

Эта функция поддерживается начиная с версии 1.5.0.

Операция PIVOT является продвинутой функцией в SQL, которая позволяет преобразовывать строки в столбцы в таблице, что особенно полезно для создания сводных таблиц. Это пригодится при работе с отчетами базы данных или аналитикой, особенно когда вам нужно суммировать или категоризировать данные для представления.

На самом деле, PIVOT является синтаксическим сахаром, который может упростить написание оператора запроса, такого как sum(case when ... then ... end).

Синтаксис

pivot:
SELECT ...
FROM ...
PIVOT (
  aggregate_function(<expr>) [[AS] alias] [, aggregate_function(<expr>) [[AS] alias] ...]
  FOR <pivot_column>
  IN (<pivot_value>)
)

pivot_column:
<column_name> 
| (<column_name> [, <column_name> ...])

pivot_value:
<literal> [, <literal> ...]
| (<literal>, <literal> ...) [, (<literal>, <literal> ...)]

Параметры

В операции PIVOT вам нужно указать несколько ключевых компонентов:

aggregate_function(): Агрегатная функция, такая как SUM, AVG, COUNT и т.д., используемая для суммирования данных.
alias: Псевдоним для агрегированного результата, делающий результат более понятным.
FOR pivot_column: Указывает имя столбца, на котором будет выполнено преобразование строк в столбцы.
IN (pivot_value): Указывает конкретные значения pivot_column, которые будут преобразованы в столбцы.

Примеры

create table t1 (c0 int, c1 int, c2 int, c3 int);
SELECT * FROM t1 PIVOT (SUM(c1) AS sum_c1, AVG(c2) AS avg_c2 FOR c3 IN (1, 2, 3, 4, 5));
-- The result is equivalent to the following query:
SELECT SUM(CASE WHEN c3 = 1 THEN c1 ELSE NULL END) AS sum_c1_1,
       AVG(CASE WHEN c3 = 1 THEN c2 ELSE NULL END) AS avg_c2_1,
       SUM(CASE WHEN c3 = 2 THEN c1 ELSE NULL END) AS sum_c1_2,
       AVG(CASE WHEN c3 = 2 THEN c2 ELSE NULL END) AS avg_c2_2,
       SUM(CASE WHEN c3 = 3 THEN c1 ELSE NULL END) AS sum_c1_3,
       AVG(CASE WHEN c3 = 3 THEN c2 ELSE NULL END) AS avg_c2_3,
       SUM(CASE WHEN c3 = 4 THEN c1 ELSE NULL END) AS sum_c1_4,
       AVG(CASE WHEN c3 = 4 THEN c2 ELSE NULL END) AS avg_c2_4,
       SUM(CASE WHEN c3 = 5 THEN c1 ELSE NULL END) AS sum_c1_5,
       AVG(CASE WHEN c3 = 5 THEN c2 ELSE NULL END) AS avg_c2_5
FROM t1
GROUP BY c0;

WITH​

Join​

Self Join​

Cross Join​

Inner Join​

Outer Join​

Equivalent and unequal join​

Semi Join​

Anti Join​

Equi-join and Non-equi-join​

ORDER BY​

GROUP BY​

Синтаксис​

Параметры​

Примечание​

Примеры​

HAVING​

LIMIT​

OFFSET​

UNION​

INTERSECT​

EXCEPT/MINUS​

DISTINCT​

Subquery​

Noncorrelated subquery​

Correlated subquery​

Where and Operators​

Arithmetic operator​

Between Operator​

Comparison operators​

In Operator​

Like Operator​

Logical Operator​

Regular Expression Operator​

Alias​

PIVOT​

Синтаксис​

Параметры​

Примеры​

WITH

Join

Self Join

Cross Join

Inner Join

Outer Join

Equivalent and unequal join

Semi Join

Anti Join

Equi-join and Non-equi-join

ORDER BY

GROUP BY

Синтаксис

Параметры

Примечание

Примеры

HAVING

LIMIT

OFFSET

UNION

INTERSECT

EXCEPT/MINUS

DISTINCT

Subquery

Noncorrelated subquery

Correlated subquery

Where and Operators

Arithmetic operator

Between Operator

Comparison operators

In Operator

Like Operator

Logical Operator

Regular Expression Operator

Alias

PIVOT

Синтаксис

Параметры

Примеры