SELECT
SELECT 语句从一个或多个表、视图或物化视图中查询数据。SELECT 语句通常由以下子句组成
- WITH
- WHERE 和运算符
- GROUP BY
- HAVING
- UNION
- INTERSECT
- EXCEPT/MINUS
- ORDER BY
- LIMIT
- OFFSET
- Joins
- Subqueries
- DISTINCT
- Alias
SELECT 可以作为独立的语句，也可以作为嵌套在其他语句中的子句。SELECT 子句的输出可以作为其他语句的输入。
StarRocks 的查询语句基本符合 SQL92 标准。以下简要介绍支持的 SELECT 用法。
注意
要从 StarRocks 内部表中的表、视图或物化视图查询数据，您必须对这些对象具有 SELECT 权限。要从外部数据源中的表、视图或物化视图查询数据，您必须对相应的外部 Catalog 具有 USAGE 权限。
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
Join 操作组合来自两个或多个表的数据，然后返回其中一些表的一些列的结果集。
StarRocks 支持自连接、交叉连接、内连接、外连接、半连接和反连接。外连接包括左连接、右连接和全连接。
语法
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
StarRocks 支持自连接，即自身连接和自身连接。例如，连接同一表的不同列。
实际上没有特殊的语法来标识自连接。自连接中连接两侧的条件来自同一张表。
我们需要为它们分配不同的别名。
示例
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
StarRocks 支持的各种连接可以根据连接中指定的连接条件分类为等值连接和非等值连接。
| 等值连接 | 自连接、交叉连接、内连接、外连接、半连接和反连接 |
|---|---|
| 非等值连接 | 交叉连接、内连接、左半连接、左反连接和外连接 |
-
等值连接
等值连接使用一个连接条件，其中两个连接项由
=运算符组合。示例：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
SELECT 语句的 ORDER BY 子句通过比较来自一个或多个列的值对结果集进行排序。
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 列表中的列、别名或表达式。
注意
StarRocks 支持 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 子句中实现多个集合组的聚合。结果等同于多个对应的 GROUP BY 子句的 UNION 操作。
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 子句用于限制返回的最大行数。设置返回的最大行数可以帮助 StarRocks 优化内存使用。
此子句主要用于以下场景
返回 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 行开始，因此偏移量为 0 和无偏移量返回相同的结果。
一般来说，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)
注意：允许使用没有 order by 的 offset 语法，但是此时 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 中的两个表。
返回 select1 中无法在 select2 中找到的不同 (id, price) 组合。
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;
StarRocks 支持同时使用 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);
从 v3.0 开始，您可以在 SELECT... FROM... WHERE... [NOT] IN 的 WHERE 子句中指定多个字段，例如，第二个 SELECT 语句中的 WHERE (x,y)。
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 运算符是一系列用于比较的函数，广泛用于 select 语句的 where 子句中。
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 子句中，表达式可以与上限和下限进行比较。如果表达式大于或等于下限且小于或等于上限，则比较结果为 true。
语法
expression BETWEEN lower_bound AND upper_bound
数据类型：通常表达式计算为数字类型，它也支持其他数据类型。如果必须确保下限和上限都是可比较的字符，则可以使用 cast() 函数。
使用说明：如果操作数的类型为字符串，请注意，以大于上限的上限开头的长字符串将不匹配上限。例如，“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 的语法更简单、更精确，并且更容易让 StarRocks 进行优化。
示例
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 元运算符，如果左右两侧的参数都被计算为 TRUE，则 AND 运算符返回 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
当您在查询中编写包含列的表、列或表达式的名称时，您可以为它们分配别名。别名通常比原始名称更短且更容易记住。
当需要别名时，您只需在 select 列表或 from 列表中的表名、列名和表达式名称之后添加一个 AS 子句。AS 关键字是可选的。您也可以直接在原始名称之后指定别名，而无需使用 AS。
如果别名或其他标识符与内部 StarRocks 关键字同名，则需要将名称用一对反引号括起来，例如，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
此功能从 v3.3 开始支持。
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;