使用listDelimiter将text分隔成K-V对,然后使用keyValueDelimiter分隔每个K-V对,组装成MAP返回。默认listDelimiter为(,), keyValueDelimiter为(=)。
MAP STR_TO_MAP(VARCHAR text)
MAP STR_TO_MAP(VARCHAR text, VARCHAR listDelimiter, VARCHAR keyValueDelimiter)
参数 | 数据类型 | 说明 |
---|---|---|
text | VARCHAR | 输入文本。 |
listDelimiter | VARCHAR | 用来将text分隔成K-V对。默认为( ,)。 |
keyValueDelimiter | VARCHAR | 用来分隔每个key和value。默认为( =)。 |
这里的Delimiter使用的是Java的正则表达式,遇到特殊字符需要转义。
测试语句
SELECT
STR_TO_MAP('k1=v1,k2=v2')['k1'] as a
FROM T1;
测试结果
a(VARCHAR) |
---|
v1 |
返回目标字符串x在被查询字符串y里第一次出现的位置。如果目标字符串x在被查询字符串y中不存在,返回值为0。
INTEGER POSITION( x IN y)
参数 | 数据类型 |
---|---|
x | VARCHAR |
y | VARCHAR |
测试语句
POSITION('in' IN 'china') as result
FROM T1;
测试结果
result(INT) |
---|
3 |
除掉一个字串中的字头或字尾。最常见的用途是移除字首或字尾的空格。
VARCHAR TRIM( VARCHAR x )
参数 | 数据类型 |
---|---|
x | VARCHAR |
测试语句
SELECT TRIM(' Sample ') as result
FROM T1;
测试结果
result(VARCHAR) |
---|
Sample |
用y替换x的子串。从start_position开始,替换length+1个字符。
VARCHAR OVERLAY ( (VARCHAR x PLACING VARCHAR y FROM INT start_position [ FOR INT length ]) )
参数 | 数据类型 |
---|---|
x | VARCHAR |
y | VARCHAR |
start_position | INT |
length(可选) | INT |
测试语句
OVERLAY('abcdefg' PLACING 'hij' FROM 2 FOR 2) as result
FROM T1;
测试结果
result(VARCHAR) |
---|
ahijdefg |
返回字符串,每个字转换器的第一个字母大写,其余为小写。
VARCHAR INITCAP(A)
参数 | 数据类型 |
---|---|
A | VARCHAR |
测试数据
var1(VARCHAR) |
---|
aADvbn |
测试语句
SELECT INITCAP(var1)as aa
FROM T1;
测试结果
aa(VARCHAR) |
---|
Aadvbn |
字符串替换函数。
VARCHAR REPLACE(str1, str2, str3)
参数 | 数据类型 | 说明 |
---|---|---|
str1 | VARCHAR | 原字符 |
str2 | VARCHAR | 目标字符 |
str3 | VARCHAR | 替换字符 |
测试数据
str1(INT) | str2(INT) | str3(INT) |
---|---|---|
alibaba blink | blink | flink |
测试语句
SELECT REPLACE(str1, str2, str3) as `result`
FROM T1;
测试结果
result(VARCHAR) |
---|
alibaba flink |
从JSON字符串中提取指定path的值,不合法的JSON和null都统一返回null。
VARCHAR JSON_VALUE(VARCHAR content, VARCHAR path)
content
VARCHAR类型,需要解析的JSON对象,使用字符串表示。
path
VARCHAR类型,解析JSON的路径表达式。目前path支持如下表达式。
符号 | 功能 |
---|---|
$ | 根对象 |
[] | 数组下标 |
* | 数组通配符 |
. | 取子元素 |
测试数据
id(INT) | json(VARCHAR) | path1(VARCHAR) |
---|---|---|
1 | [10, 20, [30, 40]] | $[2][*] |
2 | {“aaa”:“bbb”,“ccc”:{“ddd”:“eee”,“fff”:“ggg”,“hhh”:[“h0”,“h1”,“h2”]},“iii”:“jjj”} | $.ccc.hhh[*] |
3 | {“aaa”:“bbb”,“ccc”:{“ddd”:“eee”,“fff”:“ggg”,“hhh”:[“h0”,“h1”,“h2”]},“iii”:“jjj”} | $.ccc.hhh[1] |
4 | [10, 20, [30, 40]] | NULL |
5 | NULL | $[2][*] |
6 | “{xx]” | “$[2][*]” |
测试语句
SELECT
id,
JSON_VALUE(json, path1) AS `value`
FROM
T1;
测试结果
id (INT) | value (VARCHAR) |
---|---|
1 | [30,40] |
2 | [“h0”,“h1”,“h2”] |
3 | h1 |
4 | NULL |
5 | NULL |
6 | NULL |
将ASCII码转换为字符。
VARCHAR CHR(INT ascii)
参数 | 数据类型 | 说明 |
---|---|---|
ascii | INT | 是0到255之间的整数。如果不在此范围内,则返回NULL。 |
测试数据
int1(INT) | int2(INT) | int3(INT) |
---|---|---|
255 | 97 | 65 |
测试语句
SELECT CHR(int1) as var1, CHR(int2) as var2, CHR(int3) as var3
FROM T1;
测试结果
var1(VARCHAR) | var2(VARCHAR) | var3(VARCHAR) |
---|---|---|
ÿ | a | A |
连接两个或多个字符串值从而组成一个新的字符串。如果任一参数为NULL时,则跳过该参数。
VARCHAR CONCAT(VARCHAR var1, VARCHAR var2, ...)
参数 | 数据类型 | 说明 |
---|---|---|
var1 | VARCHAR | 普通字符串值 |
var2 | VARCHAR | 普通字符串值 |
测试数据
var1(VARCHAR) | var2(VARCHAR) | var3(VARCHAR) |
---|---|---|
Hello | My | World |
Hello | null | World |
null | null | World |
null | null | null |
测试语句
SELECT CONCAT(var1, var2, var3) as var
FROM T1;
测试结果
var(VARCHAR) |
---|
HelloMyWorld |
HelloWorld |
World |
N/A |
将每个参数值和第一个参数separator指定的分隔符依次连接到一起组成新的字符串,长度和类型取决于输入值。
如果separator取值为null,则将separator视作与空串进行拼接。如果其它参数为NULL,在执行拼接过程中跳过取值为NULL的参数。
VARCHAR CONCAT_WS(VARCHAR separator, VARCHAR var1, VARCHAR var2, ...)
参数 | 数据类型 | 说明 |
---|---|---|
separator | VARCHAR | 分隔符 |
var1 | VARCHAR | - |
var2 | VARCHAR | - |
测试数据
sep(VARCHAR) | str1(VARCHAR) | str2(VARCHAR) | str3(VARCHAR) |
---|---|---|---|
| | Jack | Harry | John |
null | Jack | Harry | John |
| | null | Harry | John |
| | Jack | null | null |
测试语句
SELECT CONCAT_WS(sep, str1, str2, str3) as var FROM T1;
测试结果
var(VARCHAR) |
---|
Jack|Harry|John |
JackHarryJohn |
Harry|John |
Jack |
字符串str左端填充若干个字符串pad,直到新的字符串达到指定长度len为止。
任意参数为null时返回null。
len
为负数时返回为null。
pad
为空串时,如果len
不大于str
长度,返回str
裁剪后的结果。如果len
大于str
长度时,则返回null。
VARCHAR LPAD(VARCHAR str, INT len, VARCHAR pad)
参数 | 数据类型 | 说明 |
---|---|---|
str | VARCHAR | 启始的字符串。 |
len | INT | 新的字符串的长度。 |
pad | VARCHAR | 需要重复补充的字符串。 |
测试数据
str(VARCHAR) | len(INT) | pad(VARCHAR) |
---|---|---|
空 | -2 | 空 |
HelloWorld | 15 | John |
John | 2 | C |
C | 4 | HelloWorld |
null | 2 | C |
c | 2 | null |
asd | 2 | 空 |
空 | 2 | s |
asd | 4 | 空 |
空 | 0 | 空 |
测试语句
SELECT LPAD(str, len, pad) AS result
FROM T1;
测试结果
result(VARCHAR) |
---|
null |
JohnJHelloWorld |
Jo |
HelC |
null |
null |
as |
ss |
null |
空 |
字符串str右端填充若干个字符串pad,直到新的字符串达到指定长度len
为止。
len
长度为负数时,则返回null。pad
为空串,如果len
不大于str
长度时,则返回str
裁剪后的结果。len
大于str
长度,则返回null。VARCHAR RPAD(VARCHAR str, INT len, VARCHAR pad)
参数 | 数据类型 | 说明 |
---|---|---|
str | VARCHAR | 启始的字符串。 |
len | INT | 新的字符串的长度。 |
pad | VARCHAR | 需要重复补充的字符串。 |
测试数据
str(VARCHAR) | len(INT) | pad(VARCHAR) |
---|---|---|
空 | -2 | 空 |
HelloWorld | 15 | John |
John | 2 | C |
C | 4 | HelloWorld |
null | 2 | C |
c | 2 | null |
asd | 2 | 空 |
空 | 2 | s |
asd | 4 | 空 |
空 | 0 | 空 |
测试语句
SELECT RPAD(str, len, pad) as result
FROM T1;
测试结果
result(VARCHAR) |
---|
null |
HelloWorldJohnJ |
Jo |
CHel |
null |
null |
as |
ss |
null |
空 |
返回以字符串值为str,重复次数为N的新的字符串。如果参数为null时,则返回null。如果重复次数为0或负数,则返回空串。
VARCHAR REPEAT(VARCHAR str, INT n)
参数 | 数据类型 | 说明 |
---|---|---|
str | VARCHAR | 重复字符串值。 |
n | INT | 重复次数。 |
测试数据
str(VARCHAR) | n(INT) |
---|---|
J | 9 |
Hello | 2 |
Hello | -9 |
null | 9 |
测试语句
SELECT REPEAT(str,n) as var1
FROM T1;
测试结果
var1(VARCHAR) |
---|
JJJJJJJJJ |
HelloHello |
空 |
null |
获取字符串子串。截取从位置start开始,长度为len的子串。如果未指定len,则截取到字符串结尾。start从1开始,start为0当1看待,为负数时表示从字符串末尾倒序计算位置。
VARCHAR SUBSTRING(VARCHAR a, INT start)
VARCHAR SUBSTRING(VARCHAR a, INT start, INT len)
参数 | 数据类型 | 说明 |
---|---|---|
a | VARCHAR | 指定的字符串。 |
start | INT | 在字符串a中开始截取的位置。 |
len | INT | 截取的长度。 |
测试数据
str(VARCHAR) | nullstr(VARCHAR) |
---|---|
k1=v1;k2=v2 | null |
测试语句
SELECT SUBSTRING('', 222222222) as var1,
SUBSTRING(str, 2) as var2,
SUBSTRING(str, -2) as var3,
SUBSTRING(str, -2, 1) as var4,
SUBSTRING(str, 2, 1) as var5,
SUBSTRING(str, 22) as var6,
SUBSTRING(str, -22) as var7,
SUBSTRING(str, 1) as var8,
SUBSTRING(str, 0) as var9,
SUBSTRING(nullstr, 0) as var10
FROM T1;
测试结果
var1(VARCHAR) | var2(VARCHAR) | var3(VARCHAR) | var4(VARCHAR) | var5(VARCHAR) | var6(VARCHAR) | var7(VARCHAR) | var8(VARCHAR) | var9(VARCHAR) | var10(VARCHAR) |
---|---|---|---|---|---|---|---|---|---|
空 | 1=v1;k2=v2 | v2 | v | 1 | 空 | 空 | k1=v1;k2=v2 | k1=v1;k2=v2 | null |
反转字符串,返回字符串值的相反顺序。如果任一参数为null时,则返回null。
VARCHAR REVERSE(VARCHAR str)
参数 | 数据类型 | 说明 |
---|---|---|
str | VARCHAR | 普通字符串值。 |
测试数据
str1(VARCHAR) | str2(VARCHAR) | str3(VARCHAR) | str4(VARCHAR) |
---|---|---|---|
iPhoneX | Alibaba | World | null |
测试语句
SELECT REVERSE(str1) as var1,REVERSE(str2) as var2,
REVERSE(str3) as var3,REVERSE(str4) as var4
FROM T1;
测试结果
var1(VARCHAR) | var2(VARCHAR) | var3(VARCHAR) | var4(VARCHAR) |
---|---|---|---|
XenohPi | ababilA | dlroW | null |
以sep
作为分隔符,将字符串str
分隔成若干段,取其中的第index
段。index
从0开始,如果取不到字段,则返回null。如果任一参数为NULL,则返回null。
VARCHAR SPLIT_INDEX(VARCHAR str, VARCHAR sep, INT index)
参数 | 数据类型 | 说明 |
---|---|---|
str | VARCHAR | 被分隔的字符串。 |
sep | VARCHAR | 分隔符的字符串。 |
index | INT | 截取的字段位置。 |
测试数据
str(VARCHAR) | sep(VARCHAR) | index(INT) |
---|---|---|
Jack,John,Mary | , | 2 |
Jack,John,Mary | , | 3 |
Jack,John,Mary | null | 0 |
null | , | 0 |
测试语句
SELECT SPLIT_INDEX(str, sep, index) as var1
FROM T1;
测试结果
var1(VARCHAR) |
---|
Mary |
null |
null |
null |
用字符串replacement
替换字符串str
中正则模式为pattern
的部分,并返回新的字符串。如果参数为NULL或者正则不合法时,则返回NULL。
如果您的业务数据中存在特殊字符(即系统使用的字符或者SQL关键字),则需要对特殊字符进行转义处理。常见的特殊字符和转义方式如下表所示。
特殊字符 | 字符的转义方式 |
---|---|
’ | ’ |
\ | $ |
. | \. |
$ | \$ |
VARCHAR REGEXP_REPLACE(VARCHAR str, VARCHAR pattern, VARCHAR replacement)
参数 | 数据类型 | 说明 |
---|---|---|
str | VARCHAR | 指定的字符串。 |
pattern | VARCHAR | 被替换的字符串。 |
replacement | VARCHAR | 用于替换的字符串。 |
需要按照Java代码编写正则常量。Codegen会自动将SQL常量字符串转化为Java代码。描述一个数值
(\d)
的正则表达式和Java中一样,为'\d'
。
测试数据
str1(VARCHAR) | pattern1(VARCHAR) | replace1(VARCHAR) |
---|---|---|
2014-03-13 | - | 空 |
NULL | - | 空 |
2014-03-13 | - | NULL |
2014-03-13 | 空 | s |
2014-03-13 | ( | s |
100-200 | (\d+) | num |
测试语句
SELECT REGEXP_REPLACE(str1, pattern1, replace1) as result
FROM T1;
测试结果
result(VARCHAR) |
---|
20140313 |
null |
null |
2014-03-13 |
null |
num-num |
使用正则模式Pattern匹配抽取字符串Str中的第Index个子串,Index从1开始,正则匹配提取。当参数为NULL或者正则不合法时,则返回NULL。
VARCHAR REGEXP_EXTRACT(VARCHAR str, VARCHAR pattern, INT index)
参数 | 数据类型 | 说明 |
---|---|---|
str | VARCHAR | 指定的字符串。 |
pattern | VARCHAR | 匹配的字符串。 |
index | INT | 第几个被匹配的字符串。 |
正则常量请按照Java代码来写。CodeGen会将SQL常量字符串自动转化为Java代码。如果要描述一个数字**\d**,需要写成**‘\d’**,即和Java中正则相同。
测试数据
str1 (VARCHAR) | pattern1(VARCHAR) | index1 (INT) |
---|---|---|
foothebar | foo(.*?)(bar) | 2 |
100-200 | (\d+)-(\d+) | 1 |
null | foo(.*?)(bar) | 2 |
foothebar | null | 2 |
foothebar | 空 | 2 |
foothebar | ( | 2 |
测试语句
SELECT REGEXP_EXTRACT(str1, pattern1, index1) as result
FROM T1;
测试结果
result(VARCHAR) |
---|
bar |
100 |
null |
null |
null |
null |
解析str字符串中,匹配有split1(kv对的分隔符)和split2(kv的分隔符)的key-value对,根据key_name返回对应的数值。如果key_name值不存在或异常时,返回NULL。
VARCHAR KEYVALUE(VARCHAR str, VARCHAR split1, VARCHAR split2, VARCHAR key_name)
参数 | 数据类型 | 说明 |
---|---|---|
str | VARCHAR | 字符串中的key-value(kv)对。 |
split1 | VARCHAR | kv对的分隔符。 |
split2 | VARCHAR | kv的分隔符。 |
key_name | VARCHAR | 键的名称 |
测试数据
str(VARCHAR) | split1(VARCHAR) | split2(VARCHAR) | key1(VARCHAR) |
---|---|---|---|
k1=v1;k2=v2 | ; | = | k2 |
null | ; | | | : |
k1:v1|k2:v2 | null | = | : |
k1:v1|k2:v2 | | | = | null |
k1:v1|k2:v2 | | | = | : |
测试语句
SELECT KEYVALUE(str, split1, split2, key1) as `result`
FROM T1;
测试结果
result(VARCHAR) |
---|
v2 |
null |
null |
null |
null |
返回字符串中的字符的数量。
CHAR_LENGTH(A)
参数 | 数据类型 |
---|---|
A | VARCHAR |
测试数据
var1(INT) |
---|
ss |
231ee |
测试语句
SELECT CHAR_LENGTH(var1) as aa
FROM T1;
测试结果
aa(INT) |
---|
2 |
5 |
返回字符串的HASH_CODE()的绝对值。
INT HASH_CODE(VARCHAR str)
参数 | 数据类型 |
---|---|
str | VARCHAR |
测试数据
str1(VARCHAR) | str2(VARCHAR) | nullstr(VARCHAR) |
---|---|---|
k1=v1;k2=v2 | k1:v1,k2:v2 | null |
测试语句
SELECT HASH_CODE(str1) as var1, HASH_CODE(str2) as var2, HASH_CODE(nullstr) as var3
FROM T1;
测试结果
var1(INT) | var2(INT) | var3(INT) |
---|---|---|
1099348823 | 401392878 | null |
返回字符串的MD5值。如果参数为空串(即参数为")时,则返回空串。
VARCHAR MD5(VARCHAR str)
测试数据
str1(VARCHAR) | str2(VARCHAR) |
---|---|
k1=v1;k2=v2 | 空 |
测试语句
SELECT
MD5(str1) as var1,
MD5(str2) as var2
FROM T1;
测试结果
var1(VARCHAR) | var2(VARCHAR) |
---|---|
19c17f42b4d6a90f7f9ffc2ea9bdd775 | 空 |
对指定的字符串执行一个正则表达式搜索,并返回一个Boolean值表示是否找到指定的匹配模式。如果str或者pattern为空或为NULL时,则返回false。
BOOLEAN REGEXP(VARCHAR str, VARCHAR pattern)
参数 | 数据类型 | 说明 |
---|---|---|
str | VARCHAR | 指定的字符串。 |
pattern | VARCHAR | 指定的匹配模式。 |
测试数据
str1(VARCHAR) | pattern1(VARCHAR) |
---|---|
k1=v1;k2=v2 | k2* |
k1:v1|k2:v2 | k3 |
null | k3 |
k1:v1|k2:v2 | null |
k1:v1|k2:v2 | ( |
测试语句
SELECT REGEXP(str1, pattern1) AS result
FROM T1;
测试结果
result(BOOLEAN) |
---|
true |
false |
false |
false |
false |
将BINARY类型数据转换成对应base64编码的字符串输出。
VARCHAR TO_BASE64(bin)
参数 | 数据类型 |
---|---|
bin | BINARY |
测试数据
c(VARCHAR) |
---|
SGVsbG8gd29ybGQ= |
SGk= |
SGVsbG8= |
测试语句
SELECT TO_BASE64(FROM_BASE64(c)) as var1
FROM T1;
测试结果
var1(VARCHAR) |
---|
SGVsbG8gd29ybGQ= |
SGk= |
SGVsbG8= |
将base64编码的字符串str解析成对应的binary类型数据输出。
BINARY FROM_BASE64(str)
参数 | 数据类型 | 说明 |
---|---|---|
str | VARCHAR | base64编码的字符串。 |
测试数据
a(INT) | b(BIGINT) | c(VARCHAR) |
---|---|---|
1 | 1L | null |
测试语句
SELECT
from_base64(c) as var1,from_base64('SGVsbG8gd29ybGQ=') as var2
FROM T1;
测试结果
var1(BINARY) | var2(BINARY) |
---|---|
null | Byte Array: [72(‘H’), 101(‘e’), 108(‘l’), 108(‘l’), 111(‘o’), 32(’ '), 119(‘w’), 111(‘o’), 114(‘r’), 108(‘l’), 100(‘d’)] |
返回目标字符串在源字符串中的位置,如果在源字符串中未找到目标字符串,则返回0。
INT instr( string1, string2 )
INT instr( string1, string2 [, start_position [, nth_appearance ] ] )
参数 | 数据类型 | 说明 |
---|---|---|
string1 | VARCHAR | 源字符串,要在该字符串中查找string2。 |
string2 | VARCHAR | 目标字符串,string1中查找的字符串。 |
start_position | INT | 起始位置,表示在string1中开始查找的其实位置: 该参数省略(默认): 字符串索引从1开始。 该参数为正:从左到右开始检索。 该参数为负:从右到左开始检索。 |
nth_appearance | INT | 匹配序号代表要查找第几次出现的string2: 该参数省略(默认):第1次出现。 该参数为负:系统报错。 |
测试数据
string1(VARCHAR) |
---|
helloworld |
测试语句
SELECT
instr('helloworld','lo') as res1,
instr('helloworld','l',-1,1) as res2,
instr('helloworld','l',3,2) as res3
FROM T1;
测试结果
res1(INT) | res2(INT) | res3(INT) |
---|---|---|
4 | 9 | 4 |
返回转换为大写字符的字符串。
VARCHAR UPPER(A)
参数 | 数据类型 |
---|---|
A | VARCHAR |
测试数据
var1(VARCHAR) |
---|
ss |
ttee |
测试语句
SELECT UPPER(var1) as aa
FROM T1;
测试结果
aa(VARCHAR) |
---|
SS |
TTEE |
返回转换为小写字符的字符串。
VARCHAR LOWER(A)
参数 | 数据类型 |
---|---|
A | VARCHAR |
测试数据
var1(VARCHAR) |
---|
Ss |
yyT |
测试语句
SELECT LOWER(var1) as aa
FROM T1;
测试结果
aa(VARCHAR) |
---|
ss |
yyt |
返回urlStr中指定的部分解析后的值。如果urlStr参数值为null时,则返回值为null。
VARCHAR PARSE_URL(VARCHAR urlStr, VARCHAR partToExtract [, VARCHAR key])
参数 | 数据类型 | 说明 |
---|---|---|
urlStr | VARCHAR | 链接 |
partToExtract | VARCHAR | 指定链接中解析的部分。取值如下: HOST PATH QUERY REF PROTOCOL FILE AUTHORITY USERINFO |
key | VARCHAR | 可选,指定截取部分中,具体的键。 |
测试数据
url1(VARCHAR) | nullstr(VARCHAR) |
---|---|
http://facebook.com/path/p1.php?query=1 | null |
测试语句
SELECT PARSE_URL(url1, 'QUERY', 'query') as var1,
PARSE_URL(url1, 'QUERY') as var2,
PARSE_URL(url1, 'HOST') as var3,
PARSE_URL(url1, 'PATH') as var4,
PARSE_URL(url1, 'REF') as var5,
PARSE_URL(url1, 'PROTOCOL') as var6,
PARSE_URL(url1, 'FILE') as var7,
PARSE_URL(url1, 'AUTHORITY') as var8,
PARSE_URL(nullstr, 'QUERY') as var9,
PARSE_URL(url1, 'USERINFO') as var10,
PARSE_URL(nullstr, 'QUERY', 'query') as var11
FROM T1;
测试结果
var1(VARCHAR) | var2(VARCHAR) | var3(VARCHAR) | var4(VARCHAR) | var5(VARCHAR) | var6(VARCHAR) | var7(VARCHAR) | var8(VARCHAR) | var9(VARCHAR) | var10(VARCHAR) | var11(VARCHAR) |
---|---|---|---|---|---|---|---|---|---|---|
1 | query=1 | facebook.com | /path/p1.php | null | http | /path/p1.php?query=1 | facebook.com | null | null | null |
返回A加B的结果。
A + B
参数 | 数据类型 |
---|---|
A | INT |
B | INT |
测试数据
int1(INT) | int2(INT) | int3(INT) |
---|---|---|
10 | 20 | 30 |
测试语句
SELECT int1+int2+int3 as aa
FROM T1;
测试结果
aa(int) |
---|
60 |
返回A减B的结果。
A - B
参数 | 数据类型 |
---|---|
A | INT |
B | INT |
测试数据
int1(INT) | int2(INT) | int3(INT) |
---|---|---|
10 | 10 | 30 |
测试语句
SELECT int3 - int2 - int1 as aa
FROM T1;
测试结果
aa(int) |
---|
10 |
返回A乘以B的结果。
A * B
参数 | 数据类型 |
---|---|
A | INT |
B | INT |
测试数据
nt1(INT) | int2(INT) | int3(INT) |
---|---|---|
10 | 20 | 3 |
测试语句
SELECT int1*int2*int3 as aa
FROM T1;
测试结果
aa(int) |
---|
600 |
返回A除以B的结果。
A / B
参数 | 数据类型 |
---|---|
A | INT |
B | INT |
测试数据
int1(INT) | int2(INT) |
---|---|
8 | 4 |
测试语句
SELECT int1 / int2 as aa
FROM T1;
测试结果
aa(DOUBLE) |
---|
2.0 |
返回A的绝对值。
DOUBLE ABS(A)
参数 | 数据类型 |
---|---|
A | DOUBLE |
测试数据
in1(DOUBLE) |
---|
4.3 |
测试语句
SELECT ABS(in1) as aa
FROM T1;
测试结果
aa(DOUBLE) |
---|
4.3 |
返回A的反余弦值。
ACOS(A)
参数 | 数据类型 |
---|---|
A | DOUBLE |
测试数据
in1(DOUBLE) |
---|
0.7173560908995228 |
0.4 |
测试语句
SELECT ACOS(in1) as aa
FROM T1;
测试结果
aa(DOUBLE) |
---|
0.7707963267948966 |
1.1592794807274085 |
将长整型参数转换为二进制形式,返回类型为字符串。
VARCHAR BIN(BIGINT number)
参数 | 数据类型 |
---|---|
number | BIGINT |
测试数据
id(INT) | x(BIGINT) |
---|---|
1 | 12L |
2 | 10L |
3 | 0L |
4 | 10000000000L |
测试语句
SELECT id, bin(x) as var1
FROM T1;
测试结果
id(INT) | var1(VARCHAR) |
---|---|
1 | 1100 |
2 | 1010 |
3 | 0 |
4 | 1001010100000010111110010000000000 |
返回A的反正弦值。
DOUBLE ASIN(A)
参数 | 数据类型 |
---|---|
A | DOUBLE |
测试数据
in1(DOUBLE) |
---|
0.7173560908995228 |
0.4 |
测试语句
SELECT ASIN(in1) as aa
FROM T1;
测试结果
aa(DOUBLE) |
---|
0.8 |
0.41151684606748806 |
返回A的反正切值。
DOUBLE ATAN(A)
参数 | 数据类型 |
---|---|
A | DOUBLE |
测试数据
in1(DOUBLE) |
---|
0.7173560908995228 |
0.4 |
测试语句
SELECT ATAN(in1) as aa
FROM T1;
测试结果
aa(DOUBLE) |
---|
0.6222796222326533 |
0.3805063771123649 |
运算符按位“与”操作。输入和输出类型均为INT整型,且类型一致。
INT BITAND(INT number1,INT number2)
参数 | 数据类型 |
---|---|
number1 | INT |
number2 | INT |
测试数据
a(INT) | b(INT) |
---|---|
2 | 3 |
测试语句
SELECT BITAND(a, b) as intt
FROM T1;
测试结果
intt(INT) |
---|
2 |
按位取反。输入和输出类型均为整型,且类型一致。
INT BITNOT(INT number)
参数 | 数据类型 |
---|---|
number | INT |
测试数据
a(INT) |
---|
7 |
测试语句
SELECT BITNOT(a) as var1
FROM T1;
测试结果
var1(INT) |
---|
0xfff8 |
按位取“或”。输入和输出类型均为整型,且类型一致。
INT BITOR(INT number1, INT number2)
参数 | 数据类型 |
---|---|
number1 | INT |
number2 | INT |
测试数据
a(INT) | b(INT) |
---|---|
2 | 3 |
测试语句
SELECT BITOR(a, b) as var1
FROM T1
测试结果
var1(INT) |
---|
3 |
按位取“异或”。输入和输出类型均为整型,且类型一致。
INT BITXOR(INT number1, INT number2)
参数 | 数据类型 |
---|---|
number1 | INT |
number2 | INT |
测试数据
a(INT) | b(INT) |
---|---|
2 | 3 |
测试语句
SELECT BITXOR(a, b) as var1
FROM T1;
测试结果
var1(INT) |
---|
1 |
返回一个集合中的元素数量。
SELECT BITXOR(a, b) as var1
FROM T1;
参数 | 数据类型 |
---|---|
number1 | 数组 |
测试语句
SELECT cardinality(array[1,2,3]) AS `result`
FROM T1;
测试结果
result(INT) |
---|
3 |
返回A的余弦值。
DOUBLE COS(A)
参数 | 数据类型 |
---|---|
A | DOUBLE |
测试数据
in1(DOUBLE) |
---|
0.8 |
0.4 |
测试语句
SELECT COS(in1) as aa
FROM T1;
测试结果
aa(DOUBLE) |
---|
0.6967067093471654 |
0.9210609940028851 |
返回A的余切值。
DOUBLE COT(A)
参数 | 数据类型 |
---|---|
A | DOUBLE |
测试数据
in1(DOUBLE) |
---|
0.8 |
0.4 |
测试语句
SELECT COT(in1) as aa
FROM T1;
测试结果
aa(DOUBLE) |
---|
1.0296385570503641 |
0.4227932187381618 |
返回自然常数e的A次幂的DOUBLE类型数值。
DOUBLE EXP(A)
参数 | 数据类型 |
---|---|
A | DOUBLE |
测试数据
in1(DOUBLE) |
---|
8.0 |
10.0 |
测试语句
SELECT EXP(in1) as aa
FROM T1;
测试结果
aa(DOUBLE) |
---|
2980.9579870417283 |
22026.465794806718 |
返回自然常数e的DOUBLE类型值。
DOUBLE E()
参数 | 数据类型 |
---|---|
A | DOUBLE |
测试数据
in1(DOUBLE) |
---|
8.0 |
10.0 |
测试语句
SELECT e() as dou1, E() as dou2
FROM T1;
测试结果
dou1(DOUBLE) | dou2(DOUBLE) |
---|---|
2.718281828459045 | 2.718281828459045 |
向下取整。
B FLOOR(A)
参数 | 数据类型 |
---|---|
A | INT、BIGINT、FLOAT、DOUBLE |
测试数据
in1(DOUBLE) | in2(BIGINT) |
---|---|
8.123 | 3 |
测试语句
SELECT
FLOOR(in1) as out1,
FLOOR(in2) as out2
FROM T1;
测试结果
out1(DOUBLE) | out2(BIGINT) |
---|---|
8.0 | 3 |
返回number的自然对数。
DOUBLE ln(DOUBLE number)
参数 | 数据类型 |
number | DOUBLE |
测试数据
ID(INT) | X(DOUBLE) |
---|---|
1 | 100.0 |
2 | 8.0 |
测试语句
SELECT id, ln(x) as dou1, ln(e()) as dou2
FROM T1;
测试结果
ID(INT) | dou1(DOUBLE) | dou2(DOUBLE) |
---|---|---|
1 | 4.605170185988092 | 1.0 |
2 | 2.0794415416798357 | 1.0 |
返回以base为底的x的自然对数。如果是只有一个参数的,返回以x为底的自然对数。
DOUBLE LOG(DOUBLE base, DOUBLE x)
DOUBLE LOG(DOUBLE x)
参数 | 数据类型 |
---|---|
base | DOUBLE |
x | DOUBLE |
测试数据
ID(INT) | BASE(DOUBLE) | X(DOUBLE) |
---|---|---|
1 | 10.0 | 100.0 |
2 | 2.0 | 8.0 |
测试语句
SELECT id, LOG(base, x) as dou1, LOG(2) as dou2
FROM T1;
测试结果
ID(INT) | dou1(DOUBLE) | dou2(DOUBLE) |
---|---|---|
1 | 2.0 | 0.6931471805599453 |
2 | 3.0 | 0.6931471805599453 |
返回以10为底的自然对数。若x为NULL,则返回NULL。若x为负数会引发异常。
DOUBLE LOG10(DOUBLE x)
参数 | 数据类型 |
---|---|
x | DOUBLE |
测试数据
id(INT) | X(INT) |
---|---|
1 | 100 |
2 | 10 |
测试语句
SELECT id, log10(x) as dou1
FROM T1;
测试结果
id(INT) | dou1(DOUBLE) |
---|---|
1 | 2.0 |
2 | 1.0 |
返回以2为底的自然对数。若x为NULL,则返回NULL。若x为负数,会引发异常。
DOUBLE LOG2(DOUBLE x)
参数 | 数据类型 |
---|---|
x | DOUBLE |
测试数据
id(INT) | X(INT) |
---|---|
1 | 8 |
2 | 2 |
测试语句
SELECT id, log2(x) as dou1
FROM T1;
测试结果
id(INT) | dou1(DOUBLE) |
---|---|
1 | 3.0 |
2 | 1.0 |
获取圆周率常量PI值。
DOUBLE PI()
无。
测试数据
ID(INT) | X(INT) |
---|---|
1 | 8 |
测试语句
SELECT id, PI() as dou1
FROM T1;
测试结果
ID(INT) | dou1(DOUBLE) |
---|---|
1 | 3.141592653589793 |
返回A的B次幂。
DOUBLE POWER(A, B)
参数 | 数据类型 |
---|---|
A | DOUBLE |
B | DOUBLE |
测试数据
in1(DOUBLE) | in2(DOUBLE) |
---|---|
2.0 | 4.0 |
测试语句
SELECT POWER(in1, in2) as aa
FROM T1;
测试结果
aa(DOUBLE) |
---|
16.0 |
返回大于等于0小于1的DOUBLE类型随机数。
DOUBLE RAND([BIGINT seed])
参数 | 数据类型 | 说明 |
---|---|---|
seed | BIGINT | Seed取值为随机数,决定随机数序列的起始值。 |
测试数据
id(INT) | X(INT) |
---|---|
1 | 8 |
测试语句
SELECT id, rand(1) as dou1, rand(3) as dou2
FROM T1;
测试结果
id(INT) | dou1(DOUBLE) | dou2(DOUBLE) |
---|---|---|
1 | 0.7308781907032909 | 0.731057369148862 |
返回A的正弦值。
DOUBLE SIN(A)
参数 | 数据类型 |
---|---|
A | DOUBLE |
测试数据
in1(DOUBLE) |
---|
8.0 |
0.4 |
测试语句
SELECT SIN(in1) as aa
FROM T1;
测试结果
aa(DOUBLE) |
---|
0.9893582466233818 |
0.3894183423086505 |
返回A的平方根。
DOUBLE SQRT(A)
参数 | 数据类型 |
---|---|
A | DOUBLE |
测试数据
in1(DOUBLE) |
---|
8.0 |
测试语句
SELECT SQRT(in1) as aa
FROM T1;
测试结果
aa(DOUBLE) |
---|
2.8284271247461903 |
计算A的正切值。
DOUBLE TAN(A)
参数 | 数据类型 |
---|---|
A | DOUBLE |
测试数据
in1(DOUBLE) |
---|
0.8 |
0.4 |
测试语句
SELECT TAN(in1) as aa
FROM T1;
测试结果
aa(DOUBLE) |
---|
1.0296385570503641 |
0.4227932187381618 |
将弧度x转换为数值。
DOUBLE DEGREES( double x )
参数 | 数据类型 |
---|---|
x | DOUBLE |
测试语句
SELECT DEGREES (PI()) as result
FROM T1;
测试结果
result(DOUBLE) |
---|
180.0 |
返回字符串x中的字符数。
INTEGER CHARACTER_LENGTH( VARCHAR x )
参数 | 数据类型 |
---|---|
x | VARCHAR |
测试数据
ID(INT) | X(VARCHAR) |
---|---|
1 | StreamCompute |
测试语句
SELECT CHARACTER_LENGTH( x ) as result
FROM T1;
测试结果
ID(INT) | result(INT) |
---|---|
1 | 13 |
将数值按照指定的小数位四舍五入。
T ROUND( T x, INT n)
参数 | 数据类型 |
---|---|
x | T参数类型,支持DECIMAL、TINYINT、SMALLINT、INT、BIGINT、FLOAT、DOUBLE |
n | INT |
测试数据
in1(DECIMAL) |
---|
0.7173560908995228 |
0.4 |
测试语句
SELECT ROUND(in1,2) as `result`
FROM T1;
测试结果
result(DECIMAL) |
---|
0.72 |
0.40 |
求整数x除以整数y的余数。当x为负值时,或者x、y均为负值时,结果为负值。
INTEGER MOD(INTEGER x,INTEGER y)
参数 | 数据类型 |
---|---|
x | INTEGER |
y | INTEGER |
测试数据
X(INT) | Y(INT) |
---|---|
29 | 3 |
-29 | 3 |
-29 | -3 |
测试语句
SELECT MOD(x,y) as result
FROM T1;
测试结果
ID(INT) | result(INT) |
---|---|
1 | 2 |
2 | -2 |
3 | -2 |
将长整型数字或字符串形式数字从一种进制转换为另一种进制,CONV()
精度为64位。当number是null或非法字符时,结果返回为NULL。
VARCHAR CONV(BIGINT number, INT FROM_BASE, INT TO_BASE)
or
VARCHAR CONV(VARCHAR number, INT FROM_BASE, INT TO_BASE)
参数 | 数据类型 |
---|---|
number | BIGINT、VARCHAR。 |
FROM_BASE | INT,非负数, 取值范围**[2, 36]**。 |
TO_BASE | INT,可以为正数(无符号整数)、负数(有符号整数)、ABS(TO_BASE) ,取值范围**[2, 36]**。 |
测试数据
id(INT) | x(BIGINT) | y (VARCHAR) |
---|---|---|
1 | 12L | ‘12’ |
2 | 10L | ‘10’ |
3 | 0L | ‘test’ |
4 | NULL | NULL |
测试语句
SELECT id, conv(x, 10, 16) as var1, conv(y, 10, 2) as var2
FROM T1;
测试结果
id(INT) | var1(VARCHAR) | var2(VARCHAR) |
---|---|---|
1 | C | 1100 |
2 | A | 1010 |
3 | O | NULL |
4 | NULL | NULL |
向上取整。
B CEIL(A)
参数 | 数据类型 |
---|---|
A | INT、BIGINT、FLOAT或DOUBLE |
B | INT、BIGINT、FLOAT或DOUBLE |
测试数据
in1(INT) | in2(DOUBLE) |
---|---|
1 | 2.3 |
测试语句
SELECT
CEIL (in1) as out1
CEIL (in2) as out2
FROM T1;
测试结果
out1(INT) | out2(DOUBLE) |
---|---|
1 | 3.0 |
将BIGINT类型或VARCHAR类型的日期转换成TIMESTAMP类型。
TIMESTAMP TO_TIMESTAMP(BIGINT time)
TIMESTAMP TO_TIMESTAMP(VARCHAR date)
TIMESTAMP TO_TIMESTAMP(VARCHAR date, VARCHAR format)
参数 | 数据类型 |
---|---|
time | BIGINT。 单位为毫秒。 |
date | VARCHAR。默认格式为yyyy-MM-dd HH:mm:ss 。 |
format | VARCHAR |
测试数据
timestamp1(BIGINT) | timestamp2(VARCHAR) | timestamp3(VARCHAR) |
---|---|---|
1513135677000 | 2017-09-15 00:00:00 | 20170915000000 |
测试语句
SELECT TO_TIMESTAMP(timestamp1) as var1,
TO_TIMESTAMP(timestamp2) as var2,
TO_TIMESTAMP(timestamp3, 'yyyyMMddHHmmss') as var3
FROM T1;
测试结果
var1(TIMESTAMP) | var2(TIMESTAMP) | var3(TIMESTAMP) |
---|---|---|
2017-12-13 03:27:57.0 | 2017-09-15 00:00:00.0 | 2017-09-15 00:00:00.0 |
返回当前系统的时间戳。
timestamp LOCALTIMESTAMP
无
测试语句
SELECT
LOCALTIMESTAMP as `result`
FROM T1;
测试结果
result (TIMESTAMP) |
---|
2018-07-27 14:04:38.998 |
返回当前UTC(GMT+0)时间戳,时间戳单位为毫秒。
TIMESTAMP CURRENT_TIMESTAMP
无
测试语句
SELECT CURRENT_TIMESTAMP as var1
FROM T1;
测试结果
var1(TIMESTAMP) |
---|
2007-04-30 13:10:02.047 |
now(100)
返回当前时间戳加100秒的时间戳。偏移值为NULL时,返回值为NULL。BIGINT NOW()
BIGINT NOW(a)
参数 | 数据类型 |
---|---|
a | INT |
测试数据
a(INT) |
---|
null |
测试语句
SELECT
NOW() as now,
NOW(100) as now_100,
NOW(a) as now_null
FROM T1;
测试结果
now(BIGINT) | now_100(BIGINT) | now_null(BIGINT) |
---|---|---|
1403006911 | 1403007011 | null |
将字符串类型的日期从源格式转换至目标格式。
VARCHAR DATE_FORMAT(TIMESTAMP time, VARCHAR to_format)
VARCHAR DATE_FORMAT(VARCHAR date, VARCHAR to_format)
VARCHAR DATE_FORMAT(VARCHAR date, VARCHAR from_format, VARCHAR to_format)
第一个参数(time 或 date)为源字符串。
第二个参数from_format可选,为源字符串的格式,默认为yyyy-MM-dd hh:mm:ss。
第三个参数为返回日期的格式,返回值为转换格式后的字符串类型日期。
如果有参数为NULL或解析错误,则返回NULL。
参数 | 数据类型 |
---|---|
date | VARCHAR。默认格式:yyyy-MM-dd HH:mm:ss。 |
time | TIMESTAMP |
from_format | VARCHAR |
to_format | VARCHAR |
测试数据
date1(VARCHAR) | datetime1(VARCHAR) | nullstr(VARCHAR) |
---|---|---|
0915-2017 | 2017-09-15 00:00:00 | NULL |
测试语句
SELECT DATE_FORMAT(datetime1, 'yyMMdd') as var1,
DATE_FORMAT(nullstr, 'yyMMdd') as var2,
DATE_FORMAT(datetime1, nullstr) as var3,
DATE_FORMAT(date1, 'MMdd-yyyy', nullstr) as var4,
DATE_FORMAT(date1, 'MMdd-yyyy', 'yyyyMMdd') as var5,
DATE_FORMAT(TIMESTAMP '2017-09-15 23:00:00', 'yyMMdd') as var6
FROM T1;
测试结果
var1(VARCHAR) | var2(VARCHAR) | var3(VARCHAR) | var4(VARCHAR) | var5(VARCHAR) | var6(VARCHAR) |
---|---|---|---|---|---|
170915 | null | null | null | 20170915 | 170915 |
返回date转换成的长整型时间戳,单位为秒。无参数时返回当前时间戳,单位为秒,与now语义相同。如果有参数为null或解析错误,返回null。
BIGINT UNIX_TIMESTAMP()
BIGINT UNIX_TIMESTAMP(VARCHAR date)
BIGINT UNIX_TIMESTAMP(TIMESTAMP timestamp)
BIGINT UNIX_TIMESTAMP(VARCHAR date, VARCHAR format)
参数 | 数据类型 |
---|---|
timestamp | TIMESTAMP |
date | VARCHAR。 默认格式为yyyy-MM-dd HH:mm:ss 。 |
format | VARCHAR。 默认格式为yyyy-MM-dd hh:mm:ss 。 |
测试数据
nullstr(VARCHAR) |
---|
null |
测试语句
SELECT UNIX_TIMESTAMP() as big1,
UNIX_TIMESTAMP(nullstr) as big2
FROM T1;
测试结果
big1(BIGINT) | big2(BIGINT) |
---|---|
1403006911 | null |
将INT类型或VARCHAR类型的日期转换成DATE类型。
Date TO_DATE(INT time)
Date TO_DATE(VARCHAR date)
Date TO_DATE(VARCHAR date,VARCHAR format)
参数 | 数据类型 |
---|---|
time | INT。表示从1970-1-1到所表示时间之间天数。 |
date | VARCHAR。默认格式为yyyy-MM-dd。 |
format | VARCHAR |
测试数据
date1(INT) | date2(VARCHAR) | date3(VARCHAR) |
---|---|---|
100 | 2017-09-15 | 20170915 |
测试语句
SELECT TO_DATE(date1) as var1,
TO_DATE(date2) as var2,
TO_DATE(date3,'yyyyMMdd') as var3
FROM T1;
测试结果
var1(DATE) | var2(DATE) | var3(DATE) |
---|---|---|
1970-04-11 | 2017-09-15 | 2017-09-15 |
返回为VARCHAR类型的日期值,默认格式:yyyy-MM-dd HH:mm:ss,若指定日期格式按指定格式输出任一输入参数是NULL,返回NULL。
VARCHAR FROM_UNIXTIME(BIGINT unixtime[, VARCHAR format])
参数 | 数据类型 |
---|---|
unixtime | BIGINT。以秒为单位的时间戳。 |
format | VARCHAR |
参数format可选,日期格式,默认格式为yyyy-MM-dd HH:mm:ss,表示返回符合指定格式的日期,如果有参数为null或解析错误,则返回null。
测试数据
unixtime1(BIGINT) | nullstr(VARCHAR) |
---|---|
1505404800 | null |
测试语句
SELECT FROM_UNIXTIME(unixtime1) as var1,
FROM_UNIXTIME(unixtime1,'MMdd-yyyy') as var2,
FROM_UNIXTIME(unixtime1,nullstr) as var3
FROM T1;
测试结果
var1(VARCHAR) | var2(VARCHAR) | var3(VARCHAR) |
---|---|---|
2017-09-15 00:00:00 | 0915-2017 | null |
计算从enddate到startdate两个时间的天数差值,返回整数。若有参数为NULL或解析错误,返回NULL。
INT DATEDIFF(VARCHAR enddate, VARCHAR startdate)
INT DATEDIFF(TIMESTAMP enddate, VARCHAR startdate)
INT DATEDIFF(VARCHAR enddate, TIMESTAMP startdate)
INT DATEDIFF(TIMESTAMP enddate, TIMESTAMP startdate)
参数 | 数据类型 |
---|---|
startdate | TIMESTAMP或VARCHAR |
enddate | TIMESTAMP或VARCHAR |
VARCHAR日期格式:yyyy-MM-dd或yyyy-MM-dd HH:mm:ss。
测试数据
datetime1(VARCHAR) | datetime2(VARCHAR) | nullstr(VARCHAR) |
---|---|---|
2017-10-15 00:00:00 | 2017-09-15 00:00:00 | null |
测试语句
SELECT DATEDIFF(datetime1, datetime2) as int1,
DATEDIFF(TIMESTAMP '2017-10-15 23:00:00',datetime2) as int2,
DATEDIFF(datetime2,TIMESTAMP '2017-10-15 23:00:00') as int3,
DATEDIFF(datetime2,nullstr) as int4,
DATEDIFF(nullstr,TIMESTAMP '2017-10-15 23:00:00') as int5,
DATEDIFF(nullstr,datetime2) as int6,
DATEDIFF(TIMESTAMP '2017-10-15 23:00:00',TIMESTAMP '2017-9-15 00:00:00')as int7
FROM T1;
测试结果
int1(INT) | int2(INT) | int3(INT) | int4(INT) | int5(INT) | int6(INT) | int7(INT) |
---|---|---|---|---|---|---|
30 | 31 | -31 | null | null | null | 31 |
返回startdate减去days天数的日期。返回VARCHAR类型的yyyy-MM-dd日期格式。如果有参数为null或解析错误,返回null。
VARCHAR DATE_SUB(VARCHAR startdate, INT days)
VARCHAR DATE_SUB(TIMESTAMP time, INT days)
参数 | 数据类型 |
---|---|
startdate | VARCHAR |
time | TIMESTAMP |
days | INT |
VARCHAR类型日期格式:yyyy-MM-dd或yyyy-MM-dd HH:mm:ss。
测试数据
date1(VARCHAR) | nullstr(VARCHAR) |
---|---|
2017-10-15 | null |
测试语句
SELECT DATE_SUB(date1, 30) as var1,
DATE_SUB(TIMESTAMP '2017-10-15 23:00:00',30) as var2,
DATE_SUB(nullstr,30) as var3
FROM T1;
测试结果
var1(VARCHAR) | var2(VARCHAR) | var3(VARCHAR) |
---|---|---|
2017-09-15 | 2017-09-15 | null |
返回指定startdate日期days天数后的VARCHAR类型日期,返回string格式的日期为yyyy-MM-dd
。如果有参数为null或解析错误,返回null。
VARCHAR DATE_ADD(VARCHAR startdate, INT days)
VARCHAR DATE_ADD(TIMESTAMP time, INT days)
参数 | 数据类型 |
---|---|
startdate | VARCHAR |
time | TIMESTAMP |
days | INT |
VARCHAR类型日期格式:yyyy-MM-dd或yyyy-MM-dd HH:mm:ss。
测试数据
datetime1(VATCHAR) | nullstr(VATCHAR) |
---|---|
2017-09-15 00:00:00 | null |
测试语句
SELECT DATE_ADD(datetime1, 30) as var1,
DATE_ADD(TIMESTAMP '2017-09-15 23:00:00',30) as var2,
DATE_ADD(nullstr,30) as var3
FROM T1;
测试结果
var1(VARCHAR) | var2(VARCHAR) | var3(VARCHAR) |
---|---|---|
2017-10-15 | 2017-10-15 | null |
计算指定日期在一年中的第几周,周数取值区间1~53。
BIGINT WEEK(DATE date)
BIGINT WEEK(TIMESTAMP timestamp)
参数 | 数据类型 |
---|---|
date | DATE |
timestamp | TIMESTAMP |
测试数据
dateStr(VARCHAR) | date1(DATE) | ts1(TIMESTAMP) |
---|---|---|
2017-09-15 | 2017-11-10 | 2017-10-15 00:00:00 |
测试语句
SELECT WEEK(TIMESTAMP '2017-09-15 00:00:00') as int1,
WEEK(date1) as int2,
WEEK(ts1) as int3,
WEEK(CAST(dateStr AS DATE)) as int4
FROM T1;
测试结果
int1(BIGINT) | int2(BIGINT) | int3(BIGINT) | int4(BIGINT) |
---|---|---|---|
37 | 45 | 41 | 37 |
返回输入时间的年份。
BIGINT YEAR(TIMESTAMP timestamp)
BIGINT YEAR(DATE date)
参数 | 数据类型 |
---|---|
date | DATE |
timestamp | TIMESTAMP |
测试数据
tsStr(VARCHAR) | dateStr(VARCHAR) | tdate(DATE) | ts(TIMESTAMP) |
---|---|---|---|
2017-10-15 00:00:00 | 2017-09-15 | 2017-11-10 | 2017-10-15 00:00:00 |
测试语句
SELECT YEAR(TIMESTAMP '2016-09-15 00:00:00') as int1,
YEAR(DATE '2017-09-22') as int2,
YEAR(tdate) as int3,
YEAR(ts) as int4,
YEAR(CAST(dateStr AS DATE)) as int5,
YEAR(CAST(tsStr AS TIMESTAMP)) as int6
FROM T1;
测试结果
int1(BIGINT) | int2(BIGINT) | int3(BIGINT) | int4(BIGINT) | int5(BIGINT) | int6(BIGINT) |
---|---|---|---|---|---|
2016 | 2017 | 2017 | 2017 | 2015 | 2017 |
返回输入时间参数中的月,范围1~12。
BIGINT MONTH(TIMESTAMP timestamp)
BIGINT MONTH(DATE date)
参数 | 数据类型 |
---|---|
time | TIME |
timestamp | TIMESTAMP |
测试数据
a(TIMESTAMP) | b(DATE) |
---|---|
2016-09-15 00:00:00 | 2017-10-15 |
测试语句
SELECT
MONTH(cast( a as TIMESTAMP)) as int1,
MONTH(cast( b as DATE)) as int2
FROM T1;
测试结果
int1(BIGINT) | int2(BIGINT) |
---|---|
9 | 10 |
返回输入时间参数time或timestamp中的24小时制的小时数,范围0~23。
BIGINT HOUR(TIME time)
BIGINT HOUR(TIMESTAMP timestamp)
参数 | 数据类型 |
---|---|
time | TIME |
timestamp | TIMESTAMP |
测试数据
datetime1(VARCHAR) | time1(VARCHAR) | time2(TIME) | timestamp1(TIMESTAMP) |
---|---|---|---|
2017-10-15 11:12:13 | 22:23:24 | 22:23:24 | 2017-10-15 11:12:13 |
测试语句
SELECT HOUR(TIMESTAMP '2016-09-20 23:33:33') AS int1,
HOUR(TIME '23:30:33') AS int2,
HOUR(time2) AS int3,
HOUR(timestamp1) AS int4,
HOUR(CAST(time1 AS TIME)) AS int5,
HOUR(TO_TIMESTAMP(datetime1)) AS int6
FROM T1;
测试结果
int1(BIGINT) | int2(BIGINT) | int3(BIGINT) | int4(BIGINT) | int5(BIGINT) | int6(BIGINT) |
---|---|---|---|---|---|
23 | 23 | 22 | 11 | 22 | 11 |
返回输入时间参数date或time中所指代的“日”。返回值范围为1~31。
BIGINT DAYOFMONTH(TIMESTAMP time)
BIGINT DAYOFMONTH(DATE date)
参数 | 数据类型 |
---|---|
date | DATE |
time | TIMESTAMP |
测试数据
tsStr(VARCHAR) | dateStr(VARCHAR) | tdate(DATE) | ts(TIMESTAMP) |
---|---|---|---|
2017-10-15 00:00:00 | 2017-09-15 | 2017-11-10 | 2017-10-15 00:00:00 |
测试语句
SELECT DAYOFMONTH(TIMESTAMP '2016-09-15 00:00:00') as int1,
DAYOFMONTH(DATE '2017-09-22') as int2,
DAYOFMONTH(tdate) as int3,
DAYOFMONTH(ts) as int4,
DAYOFMONTH(CAST(dateStr AS DATE)) as int5,
DAYOFMONTH(CAST(tsStr AS TIMESTAMP)) as int6
FROM T1;
测试结果
int1(BIGINT) | int2(BIGINT) | int3(BIGINT) | int4(BIGINT) | int5(BIGINT) | int6(BIGINT) |
---|---|---|---|---|---|
15 | 22 | 10 | 15 | 15 | 15 |
返回输入时间参数中time或timestamp中的“分钟”部分。取值范围0~59。
BIGINT MINUTE(TIME time)
BIGINT MINUTE(TIMESTAMP timestamp)
参数 | 数据类型 |
---|---|
time | TIME |
timestamp | TIMESTAMP |
测试数据
datetime1(VARCHAR) | time1(VARCHAR) | time2(TIME) | timestamp1(TIMESTAMP) |
---|---|---|---|
2017-10-15 11:12:13 | 22:23:24 | 22:23:24 | 2017-10-15 11:12:13 |
测试语句
SELECT MINUTE(TIMESTAMP '2016-09-20 23:33:33') as int1,
MINUTE(TIME '23:30:33') as int2,
MINUTE(time2) as int3,
MINUTE(timestamp1) as int4,
MINUTE(CAST(time1 AS TIME)) as int5,
MINUTE(CAST(datetime1 AS TIMESTAMP)) as int6
FROM T1;
测试结果
int1(BIGINT) | int2(BIGINT) | int3(BIGINT) | int4(BIGINT) | int5(BIGINT) | int6(BIGINT) |
---|---|---|---|---|---|
33 | 30 | 23 | 12 | 23 | 12 |
返回输入时间参数中的“秒”部分,范围0~59。
BIGINT SECOND(TIMESTAMP timestamp)
BIGINT SECOND(TIME time)
参数 | 数据类型 |
---|---|
time | TIME |
timestamp | TIMESTAMP |
测试数据
datetime1(VARCHAR) | time1(VARCHAR) | time2(TIME) | timestamp1(TIMESTAMP) |
---|---|---|---|
2017-10-15 11:12:13 | 22:23:24 | 22:23:24 | 2017-10-15 11:12:13 |
测试语句
SELECT SECOND(TIMESTAMP '2016-09-20 23:33:33') as int1,
SECOND(TIME '23:30:33') as int2,
SECOND(time2) as int3,
SECOND(timestamp1) as int4,
SECOND(CAST(time1 AS TIME)) as int5,
SECOND(CAST(datetime1 AS TIMESTAMP)) as int6
FROM T1;
测试结果
int1(BIGINT) | int2(BIGINT) | int3(BIGINT) | int4(BIGINT) | int5(BIGINT) | int6(BIGINT) |
---|---|---|---|---|---|
33 | 33 | 24 | 13 | 24 | 13 |
返回时间间隔单位计算后的时间。
TIMESTAMP TIMESTAMPADD(interval,INT int_expr,TIMESTAMP datetime_expr)
DATE TIMESTAMPADD(interval,INT int_expr,DATE datetime_expr)
参数 | 数据类型 |
---|---|
interval | VARCHAR |
int_expr | INT |
datetime_expr | TIMESTAMP或DATE |
interval可取值如下。
nterval参数 | 时间间隔单位 |
---|---|
FRAC_SECOND | 毫秒 |
SECOND | 秒 |
MINUTE | 分钟 |
HOUR | 小时 |
DAY | 天 |
WEEK | 星期 |
MONTH | 月 |
QUARTER | 季度 |
YEAR | 年 |
测试数据
a(TIMESTAMP) | b(DATE) |
---|---|
2018-07-09 10:23:56 | 1990-02-20 |
测试语句
SELECT
TIMESTAMPADD(HOUR,3,a) AS `result1`
TIMESTAMPADD(DAY,3,b) AS `result2`
FROM T1;
测试结果
result1(TIMESTAMP) | result2(DATE) |
---|---|
2018-07-09 13:23:56.0 | 1990-02-23 |
返回日期/时间的单独部分,例如年、月、日、小时、分钟、周数等。
BIGINT EXTRACT(unit FROM time)
time:任意日期表达式。
unit:日期单元,可取值如下:
测试语句
EXTRACT(YEAR FROM CURRENT_TIMESTAMP) AS OrderYear,
EXTRACT(MONTH FROM CURRENT_TIMESTAMP) AS OrderMonth,
EXTRACT(DAY FROM CURRENT_TIMESTAMP) AS OrderDay,
EXTRACT(WEEK FROM CURRENT_TIMESTAMP) AS OrderWeek
测试结果
OrderYear(BIGINT) | OrderMonth(BIGINT) | OrderDay(BIGINT) | OrderWeek(BIGINT) |
---|---|---|---|
2018 | 10 | 11 | 41 |
以数据类型TIME的值返回会话时区中的当前时间。LOCALTIME可当变量直接使用。
TIME LOCALTIME
无
测试语句
SELECT LOCALTIME as `result`
FROM T1;
测试结果
result(TIME) |
---|
19:00:47 |
返回当前系统日期。
CURRENT_DATE
无
测试语句
SELECT CURRENT_DATE as res
FROM T1;
测试结果
res(DATE) |
---|
2018-09-20 |
如果A等于B,返回TRUE,否则返回FALSE。
A = B
参数 | 数据类型 |
---|---|
A | INT |
B | INT |
测试数据
int1(INT) | int2(INT) | int3(INT) |
---|---|---|
97 | 65 | 65 |
测试语句
SELECT int1 as aa
FROM T1
WHERE int3 = int2;
测试结果
aa(int) |
---|
97 |
如果A大于B,返回TRUE,否则返回FALSE。
A > B
参数 | 数据类型 |
---|---|
A | INT |
B | INT |
测试数据
int1(INT) | int2(INT) | int3(INT) |
---|---|---|
97 | 65 | 100 |
测试语句
SELECT int1 as aa
FROM T1
WHERE int3 > int2;
测试结果
aa(int) |
---|
97 |
如果A大于等于B,返回TRUE,否则返回FALSE。
A >= B
参数 | 数据类型 |
---|---|
A | INT |
B | INT |
测试数据
int1(INT) | int2(INT) | int3(INT) |
---|---|---|
97 | 65 | 65 |
9 | 6 | 61 |
测试语句
SELECT int1 as aa
FROM T1
WHERE int3 >= int2;
测试结果
aa(int) |
---|
97 |
9 |
如果A小于等于B,返回TRUE,否则返回FALSE。
A <= B
参数 | 数据类型 |
---|---|
A | INT |
B | INT |
测试数据
int1(INT) | int2(INT) | int3(INT) |
---|---|---|
97 | 66 | 65 |
9 | 6 | 5 |
测试语句
SELECT int1 as aa
FROM T1
WHERE int3 <= int2;
测试结果
aa(int) |
---|
97 |
9 |
如果A小于B,返回TRUE,否则返回FALSE。
A < B
参数 | 数据类型 |
---|---|
A | INT |
B | INT |
测试数据
int1(INT) | int2(INT) | int3(INT) |
---|---|---|
97 | 66 | 65 |
9 | 6 | 5 |
测试语句
SELECT int1 as aa
FROM T1
WHERE int3 < int2;
测试结果
aa(int) |
---|
97 |
9 |
如果A不等于B,则返回TRUE,否则返回FALSE。
A <> B
参数 | 数据类型 |
---|---|
A | TIMESTAMP、BIGINT、INT、VARCHAR、DECIMAL |
B | TIMESTAMP、BIGINT、INT、VARCHAR、DECIMAL |
测试数据
int1(INT) | int2(INT) | int3(INT) |
---|---|---|
97 | 66 | 6 |
测试语句
SELECT int1 as aa
FROM T1
WHERE int3 <> int2;
测试结果
aa(int) |
---|
97 |
如果A和B均为TRUE,则为TRUE,否则为FALSE。
A AND B
参数 | 数据类型 |
---|---|
A | BOOLEAN |
B | BOOLEAN |
测试数据
int1(INT) | int2(INT) | int3(INT) |
---|---|---|
255 | 97 | 65 |
测试语句
SELECT int2 as aa
FROM T1
WHERE int1=255 AND int3=65;
测试结果
aa(int) |
---|
97 |
BETWEEN操作符用于选取介于两个值之间的数据范围内的值。
A BETWEEN B AND C
参数 | 数据类型 |
---|---|
A | DOUBLE,BIGINT,INT,VARCHAR,DATE,TIMESTAMP,TIME |
B | DOUBLE,BIGINT,INT,VARCHAR,DATE,TIMESTAMP,TIME |
C | DOUBLE,BIGINT,INT,VARCHAR,DATE,TIMESTAMP,TIME |
测试数据
int1(INT) | int2(INT) | int3(INT) |
---|---|---|
90 | 80 | 100 |
11 | 10 | 7 |
测试语句
SELECT int1 as aa
FROM T1
WHERE int1 BETWEEN int2 AND int3;
测试结果
aa(int) |
---|
90 |
如果A是TRUE,返回TRUE。如果A是FALSE,返回FALSE。
A IS NOT FALSE
参数 | 数据类型 |
---|---|
A | BOOLEAN |
测试数据
int1(INT) | int2(INT) |
---|---|
255 | 97 |
测试语句
SELECT int2 as aa
FROM T1
WHERE int1=255 IS NOT FALSE;
测试结果
aa(int) |
---|
97 |
如果A是TRUE,返回FALSE。如果A是FALSE,返回TRUE。
A IS NOT TRUE
参数 | 数据类型 |
---|---|
A | BOOLEAN |
测试数据
int1(INT) | int2(INT) |
---|---|
255 | 97 |
测试语句
SELECT int1 as aa
FROM T1
WHERE int1=25 IS NOT TRUE;
测试结果
aa(int) |
---|
97 |
如果value为NULL
时,则返回FALSE
,否则返回TRUE
。
value IS NOT NULL
参数 | 数据类型 |
---|---|
value | 任意数据类型 |
测试数据
int1(INT) | int2(VARCHAR) |
---|---|
97 | NULL |
9 | ww123 |
测试语句
SELECT int1 as aa
FROM T1
WHERE int2 IS NOT NULL;
测试结果
aa(int) |
---|
9 |
当两边无法进行正常的逻辑判断时,即A值既不是TRUE
也不是FALSE
,返回 FALSE
。可正常逻辑判断时,即A值为TRUE
或者FALSE
,返回 TRUE
。
A IS NOT UNKNOWN
参数 | 数据类型 |
---|---|
A | BOOLEAN |
A为逻辑比较表达式,例如: 6<8。
正常情况下数值型与数值型作逻辑比较时,A值为TRUE或者FALSE。当其中一个不为数值型数据类型时,就会出现无法比较的情况。
测试数据
int1(INT) | int2(INT) |
---|---|
255 | 97 |
测试语句
SELECT int2 as aa
FROM T1
WHERE int1=25 IS NOT UNKNOWN;
测试结果
aa(int) |
---|
97 |
如果value为NULL
时,则返回TRUE
,否则返回FALSE
。
value IS NULL
参数 | 数据类型 |
---|---|
value | 任意数据类型 |
测试数据
int1(INT) | int2(VARCHAR) |
---|---|
97 | 无 |
9 | www |
测试语句
SELECT int1 as aa
FROM T1
WHERE int2 IS NULL;
测试结果
aa(int) |
---|
97 |
如果A是TRUE时,则返回TRUE。如果A是FALSE时,则返回FALSE。
A IS TRUE
参数 | 数据类型 |
---|---|
A | BOOLEAN |
测试数据
int1(INT) | int2(INT) |
---|---|
255 | 97 |
测试语句
SELECT int2 as aa
FROM T1
WHERE int1=255 IS TRUE;
测试结果
aa(int) |
---|
97 |
IS UNKNOWN通过逻辑判断关系,返回结果:
TRUE
也不是FALSE
,即无法进行正常的逻辑判断,返回 TRUE
。TRUE
或者FALSE
,即可以进行正常逻辑判断,返回 FALSE
。正常情况下数值型与数值型进行逻辑比较时(例如6<>8
),A值为TRUE或者FALSE。但是,当其中一个不为数值型数据类型时,就会出现无法比较的情况。IS UNKNOWN
用于判断这种情况是否存在
A IS UNKNOWN
参数 | 数据类型 |
---|---|
A | BOOLEAN |
测试数据
int1(INT) | int2(INT) |
---|---|
255 | 97 |
测试语句
SELECT int2 as aa
FROM T1
WHERE int1 > null IS UNKNOWN;
测试结果
aa(int) |
---|
97 |
如果匹配,返回TRUE,否则返回FALSE。
A LIKE B
参数 | 数据类型 |
---|---|
A | VARCHAR |
B | VARCHAR |
测试数据
int1(INT) | VARCHAR2(VARCHAR) | VARCHAR3(VARCHAR) |
---|---|---|
90 | ss97 | 97ss |
99 | ss10 | 7ho7 |
测试语句
SELECT int1 as aa
FROM T1
WHERE VARCHAR2 LIKE 'ss%';
测试结果
aa(int) |
---|
90 |
99 |
如果A是TRUE
,返回FALSE
。如果A是FALSE
,返回TRUE
。
NOT
测试数据
int2(INT) | int3(INT) |
---|---|
97 | 65 |
测试语句
SELECT int2 as aa
FROM T1
WHERE NOT int3=62;
测试结果
aa(int) |
---|
97 |
NOT BETWEEN AND
操作符用于选取不存在与两个值之间的数据范围内的值。
A NOT BETWEEN B AND C
参数 | 数据类型 |
---|---|
A | DOUBLE、BIGINT、INT、VARCHAR、DATE、TIMESTAMP、TIME |
B | DOUBLE、BIGINT、INT、VARCHAR、DATE、TIMESTAMP、TIME |
C | DOUBLE、BIGINT、INT、VARCHAR、DATE、TIMESTAMP、TIME |
测试数据
int1(INT) | int2(INT) | int3(INT) |
---|---|---|
90 | 97 | 80 |
11 | 10 | 7 |
测试语句
SELECT int1 as aa
FROM T1
WHERE int1 NOT BETWEEN int2 AND int3;
测试结果
aa(int) |
---|
11 |
用来查找在参数中的记录。
SELECT column_name(s)
FROM table_name
WHERE column_name IN (value1,value2,...)
参数 | 数据类型 |
---|---|
value1 | 常数 |
value2 | 常数 |
测试数据
id(Int) | LastName(Varchar) |
---|---|
1 | Adams |
2 | Bush |
3 | Carter |
测试语句
SELECT column_name(s)
FROM table_name
WHERE column_name IN (value1,value2,...)
测试结果
id(Int) | LastName(Varchar) |
---|---|
1 | Adams |
3 | Carter |
如果A和B中至少有一个为TRUE,则为TRUE,否则为FALSE。
A OR B
int1(INT) | int2(INT) | int3(INT) |
---|---|---|
255 | 97 | 65 |
测试数据
测试语句
SELECT int2 as aa
FROM T1
WHERE int1=255 OR int3=65;
测试结果
aa(int) |
---|
97 |
TRUE
。FALSE
。A IS DISTINCT FROM B
参数 | 数据类型 |
---|---|
A | 任意数据类型 |
B | 任意数据类型 |
测试数据
A(int) | B(varchar) |
---|---|
97 | 97 |
null | sss |
null | null |
测试语句
SELECT
A IS DISTINCT FROM B as 'result'
FROM T1;
测试结果
result(BOOLEAN) |
---|
true |
true |
false |
跟IS DISTINCT FROM
相反。
FALSE
。TRUE
。A IS NOT DISTINCT FROM B
参数 | 数据类型 |
---|---|
A | 任意数据类型 |
B | 任意数据类型 |
测试数据
A(int) | B(varchar) |
---|---|
97 | 97 |
null | sss |
null | null |
测试语句
SELECT
A IS NOT DISTINCT FROM B as `result`
FROM T1;
测试结果
result(BOOLEAN) |
---|
false |
false |
true |
用来查找在不在参数中的记录。
SELECT column_name(s)
FROM table_name
WHERE column_name NOT IN (value1,value2,...)
参数 | 数据类型 |
---|---|
value1 | 常数 |
value2 | 常数 |
测试数据
id(Int) | LastName(Varchar) |
---|---|
1 | Adams |
2 | Bush |
3 | Carter |
测试语句
SELECT *
FROM T1
WHERE LastName NOT IN ('Adams','Carter')
测试结果
id(Int) | LastName(Varchar) |
---|---|
2 | Bush |
str字符串如果可以转换为十进制数值返回TRUE;否则返回FALSE。
BOOLEAN IS_DECIMAL(VARCHAR str)
参数 | 数据类型 |
---|---|
str | VARCHAR |
测试数据
a(VARCHAR) | b(VARCHAR) | c(VARCHAR) | d(VARCHAR) | e(VARCHAR) | f(VARCHAR) | g(VARCHAR) |
---|---|---|---|---|---|---|
1 | 123 | 2 | 11.4445 | 3 | asd | null |
测试语句
SELECT
IS_DECIMAL(a) as boo1,
IS_DECIMAL(b) as boo2,
IS_DECIMAL(c) as boo3,
IS_DECIMAL(d) as boo4,
IS_DECIMAL(e) as boo5,
IS_DECIMAL(f) as boo6,
IS_DECIMAL(g) as boo7
FROM T1
测试结果
boo1(BOOLEAN) | boo2(BOOLEAN) | boo3(BOOLEAN) | boo4(BOOLEAN) | boo5(BOOLEAN) | boo6(BOOLEAN) | boo7(BOOLEAN) |
---|---|---|---|---|---|---|
true | true | true | true | true | false | false |
str中只包含数字则返回true,否则返回false。返回值为BOOLEAN类型。
BOOLEAN IS_DIGIT(VARCHAR str)
参数 | 数据类型 |
---|---|
str | VARCHAR |
测试数据
e(VARCHAR) | f(VARCHAR) | g(VARCHAR) |
---|---|---|
3 | asd | null |
测试语句
SELECT
IS_DIGIT(e) as boo1,
IS_DIGIT(f) as boo2,
IS_DIGIT(g) as boo3
FROM T1
测试结果
boo1(BOOLEAN) | boo2(BOOLEAN) | boo3(BOOLEAN) |
---|---|---|
true | false | false |
如果str中只包含字母,则返回true,否则返回false。
BOOLEAN IS_ALPHA(VARCHAR str)
参数 | 数据类型 |
---|---|
str | VARCHAR |
测试数据
e(VARCHAR) | f(VARCHAR) | g(VARCHAR) |
---|---|---|
3 | asd | null |
测试语句
SELECT IS_ALPHA(e) as boo1,IS_ALPHA(f) as boo2,IS_ALPHA(g) as boo3
FROM T1;
测试结果
boo1(BOOLEAN) | boo2(BOOLEAN) | boo3(BOOLEAN) |
---|---|---|
false | true | false |
以testCondition的布尔值为判断标准,返回对应的参数值:
testCondition为null时,判定结果为false。
T if (BOOLEAN testCondition, T valueTrue, T valueFalseOrNull)
T代表任意类型的返回值。
参数 | 数据类型 |
---|---|
testCondition | BOOLEAN |
valueTrue | 可以为任意类型,但valueTrue和valueFalseOrNull类型需保持一致。 |
valueFalseOrNull | 可以为任意类型,但valueTrue和valueFalseOrNull类型需保持一致。 |
测试数据
int1(INT) | int2(INT) | str1(VARCHAR) | str2(VARCHAR) |
---|---|---|---|
1 | 2 | Jack | Harry |
1 | 2 | Jack | null |
1 | 2 | null | Harry |
测试语句
SELECT IF(int1 < int2,str1, str2) as int1
FROM T1
测试结果
int1(VARCHAR) |
---|
Jack |
Jack |
null |
如果表达式a为TRUE,则返回b;如果表达式a为FALSE、c为TRUE,则返回d;如果表达式a和c都为FALSE,则返回e。
CASE WHEN a THEN b [WHEN c THEN d]* [ELSE e] END
CASE WHEN返回常量字符串时,会在字符串后面补全空格。例如,当满足else条件时,返回值ios
后面会多几个空格。
case when device_type = 'android'
then 'android'
else 'ios'
end as os
解决方法:
os
的字段都改为TRIM(os)
。测试数据
device_type(VARCHAR) |
---|
android |
ios |
win |
测试语句
-- 用TRIM函数
SELECT
trim(os), --添加trim。
CHAR_LENGTH(trim(os)) --添加trim。
from(
SELECT
case when device_type = 'android'
then 'android'
else 'ios'
end as os
FROM T1
);
-- 用CAST函数
SELECT
os,
CHAR_LENGTH(os)
from
(SELECT
case when device_type = 'android'
then cast('android' as varchar) --添加cast。
else cast('ios' as varchar) --添加cast。
end as os
FROM T1
);
测试结果
os(VARCHAR) | length(INT) |
---|---|
android | 7 |
ios | 3 |
ios | 3 |
返回列表中第一个非null的值,返回值类型和参数类型相同。如果列表中所有的值都是null,则返回null。
COALESCE(A,B,...)
参数 | 数据类型 |
---|---|
A | 任意数据类型 |
B | 任意数据类型 |
测试数据
var1(VARCHAR) | var2(VARCHAR) |
---|---|
null | 30 |
测试语句
SELECT COALESCE(var1,var2) as aa
FROM T1
测试结果
aa(VARCHAR) |
---|
30 |
两个参数的值相同,则返回null,值不同则返回第一个参数的值。
NULLIF(A,B)
参数 | 数据类型 |
---|---|
A | INT |
B | INT |
测试数据
var1(INT) | var2(INT) |
---|---|
30 | 30 |
测试语句
SELECT NULLIF(var1,var2) as aa
FROM T1
测试结果
aa(INT) |
---|
null |
根据指定的分隔符将目标字符串拆分为子字符串行,返回子字符串的单列的表。需要注意以下几点:
string_split(string, separator)
参数 | 数据类型 | 说明 |
---|---|---|
string | VARCHAR | 目标字符串 |
separator | VARCHAR | 指定的分隔符 |
分隔符separator暂不支持多字符串形式,只支持单个字符串形式。
测试数据
d(varchar) | s(varchar) |
---|---|
abc-bcd | - |
hhh | - |
测试语句
select d,v
from T1,
lateral table(string_split(d, s)) as T(v);
测试结果
d(varchar) | v(varchar) |
---|---|
abc-bcd | abc |
abc-bcd | bcd |
hhh | hhh |
生成一串连续的数值,分别为 from, from+1, from+2, … , to-1。
GENERATE_SERIES(INT from, INT to)
参数 | 数据类型 |
---|---|
from | INT类型,指定下界,包含下界值。 |
to | INT类型,指定上界,不包含上界值。 |
测试数据
s(INT) | e(INT) |
---|---|
1 | 3 |
-2 | 1 |
测试语句
SELECT s, e, v
FROM T1, lateral table(GENERATE_SERIES(s, e))
as T(v)
测试结果
s(INT) | e(INT) | v(INT) |
---|---|---|
1 | 3 | 1 |
1 | 3 | 2 |
-2 | 1 | -2 |
-2 | 1 | -1 |
-2 | 1 | -0 |
从JSON字符串中取出各路径字符串所表示的值。
JSON_TUPLE(str, path1, path2 ..., pathN)
参数 | 数据类型 | 说明 |
---|---|---|
str | VARCHAR | JSON字符串 |
path1~pathN | VARCHAR | 表示路径的字符串,前面不需要$ 。 |
测试数据
d(VARCHAR) | s(VARCHAR) |
---|---|
{“qwe”:“asd”,“qwe2”:“asd2”,“qwe3”:“asd3”} | qwe3 |
{“qwe”:“asd4”,“qwe2”:“asd5”,“qwe3”:“asd3”} | qwe2 |
测试语句
SELECT d, v
FROM T1, lateral table(JSON_TUPLE(d, 'qwe', s))
AS T(v);
测试结果
d(VARCHAR) | v(VARCHAR) |
---|---|
{“qwe”:“asd”,“qwe2”:“asd2”,“qwe3”:“asd3”} | asd |
{“qwe”:“asd”,“qwe2”:“asd2”,“qwe3”:“asd3”} | asd3 |
{“qwe”:“asd4”,“qwe2”:“asd5”,“qwe3”:“asd3”} | asd4 |
{“qwe”:“asd4”,“qwe2”:“asd5”,“qwe3”:“asd3”} | asd5 |
解析str字符串中的key-value对,匹配有split1和split2的key-value对,并返回参数列表里key_name1,key_name2等对应的value值列表。key_name值不存在时,对应的value值是null。
MULTI_KEYVALUE(VARCHAR str, VARCHAR split1, VARCHAR split2, VARCHAR key_name1, VARCHAR key_name2, ...)
参数 | 数据类型 | 说明 |
---|---|---|
str | VARCHAR | 字符串中的key-value(kv)对。 |
split1 | VARCHAR | kv对的分隔符。当split1为null,表示按照whitespace作为kv对的分割符。当split1的长度>1时,split1仅表示分隔符的集合,每个字符都表示一个有效的分隔符。 |
split2 | VARCHAR | kv的分隔符。当split2为null,表示按照whitespace作为kv的分割符。当split2的长度>1时,split2仅表示分隔符的集合,每个字符都表示一个有效的分隔符。 |
key_name1, key_name2, … | VARCHAR | 需要获取value的key值列表。 |
测试数据
str(VARCHAR) | split1(VARCHAR) | split2(VARCHAR) | key1(VARCHAR) | key2(VARCHAR) |
---|---|---|---|---|
k1=v1;k2=v2 | ; | = | k1 | k2 |
null | ; | = | k1 | k2 |
k1:v1;k2:v2 | ; | : | k1 | k3 |
k1:v1;k2:v2 | ; | = | k1 | k2 |
k1:v1;k2:v2 | , | : | k1 | k2 |
k1:v1;k2=v2 | ; | : | k1 | k2 |
k1:v1abck2:v2 | cab | : | k1 | k2 |
k1:v1;k2=v2 | ; | := | k1 | k2 |
k1:v1 k2:v2 | null | : | k1 | k2 |
k1 v1;k2 v2 | ; | null | k1 | k2 |
测试语句
SELECT c1, c2
FROM T1, lateral table(MULTI_KEYVALUE(str, split1, split2, key1, key2))
as T(c1, c2)
测试结果
c1(VARCHAR) | c2(VARCHAR) |
---|---|
v1 | v2 |
null | null |
v1 | null |
null | null |
null | null |
v1 | null |
v1 | v2 |
v1 | v2 |
v1 | v2 |
v1 | v2 |
将A值转换为给定类型。如果转换后的类型和目标表字段类型不匹配时,会出现类似Insert into: Query result and target table 'test_result' field type(s) not match.
的报错。
CAST(A AS type)
A:任意类型数据。
测试数据
var1(VARCHAR) | var2(INT) |
---|---|
1000 | 30 |
测试语句
SELECT CAST(var1 AS INT) as aa
FROM T1;
测试结果
aa(INT) |
---|
1000 |
返回指定表达式中所有值的平均值。返回值默认为DOUBLE类型,如果您的结果表字段为非DOUBLE类型,您需要使用CAST进行转化。
AVG(A)
参数 | 数据类型 |
---|---|
A | TINYINT、SMALLINT、INT、BIGINT、FLOAT、DECIMAL和DOUBLE。 |
测试数据
var1(INT) | var2(INT) |
---|---|
4 | 30 |
6 | 30 |
测试语句
SELECT AVG(var1) as aa
FROM T1;
测试结果
aa(INT) |
---|
5 |
连接对应字段的字符串,默认连接符\n
,连接完成后新生成的字符串。返回值VARCHAR类型。
CONCAT_AGG([linedelimiter,] value )
参数 | 数据类型 |
---|---|
linedelimiter | 目前只支持字符串常量。可选。 |
测试数据
b(VARCHAR) | c(VARCHAR) |
---|---|
Hi | milk |
Hi | milk |
Hi | milk |
Hi | milk |
Hi | milk |
Hi | milk |
Hello | cola |
Hello | cola |
Happy | suda |
Happy | suda |
测试语句
SELECT
b,
concat_agg(c) as var1,
concat_agg('-', c) as var2
FROM MyTable
GROUP BY b;
测试结果
b (VARCHAR) | var1(VARCHAR) | var2(VARCHAR) |
---|---|---|
Hi | milk milk milk milk milk milk | milk-milk-milk-milk-milk-milk |
Hello | cola cola | cola-cola |
Happy | suda suda | suda-suda |
返回输入列的数量。
COUNT(A)
参数 | 数据类型 |
---|---|
A | 支持TINYINT、SMALLINT、INT、BIGINT、FLOAT、DECIMAL、DOUBLE、BOOLEAN和VARCHAR类型。 不支持DATE、TIME、TIMESTAMP和VARBINARY类型。 |
测试数据
var1(VARCHAR) |
---|
1000 |
100 |
10 |
1 |
测试语句
SELECT COUNT(var1) as aa
FROM T1;
测试结果
aa(BIGINT) |
---|
4 |
获取数据流的第1条非null数据。根据order判定FIRST_VALUE所在的行,取order值最小的记录作为FIRST_VALUE。
T FIRST_VALUE( T value )
T FIRST_VALUE( T value, BIGINT order )
参数 | 数据类型 |
---|---|
value | 任意参数类型,但输入参数只能为同一种类型。 |
order | BIGINT |
测试数据
a(BIGINT) | b(INT) | c(VARCHAR) |
---|---|---|
1L | 1 | “Hello” |
2L | 2 | “Hello” |
3L | 3 | “Hello” |
4L | 4 | “Hello” |
5L | 5 | “Hello” |
6L | 6 | “Hello” |
7L | 7 | “Hello World” |
8L | 8 | “Hello World” |
20L | 20 | “Hello World” |
测试语句
SELECT c,
FIRST_VALUE(b)
OVER (
PARTITION BY c
ORDER BY PROCTIME() RANGE UNBOUNDED PRECEDING
) AS var1
FROM T1;
测试结果
c(VARCHAR) | var1(BIGINT) |
---|---|
“Hello” | 1 |
“Hello” | 1 |
“Hello” | 1 |
“Hello” | 1 |
“Hello” | 1 |
“Hello” | 1 |
“Hello World” | 7 |
“Hello World” | 7 |
“Hello World” | 7 |
获取数据流的最后1条非NULL数据。根据ORDER判定LAST_VALUE所在的行,取ORDER值最大的记录作为LAST_VALUE。
T LAST_VALUE(T value)
T LAST_VALUE(T value,BIGINT order)
参数 | 数据类型 |
---|---|
value | 任意参数类型 |
order | BIGINT |
所有输入参数需要为相同的数据类型。
测试数据
a(BIGINT) | b(INT) | c(VARCHAR) |
---|---|---|
1L | 1 | “Hello” |
2L | 2 | “Hello” |
3L | 3 | “Hello” |
4L | 4 | “Hello” |
5L | 5 | “Hello” |
6L | 6 | “Hello” |
7L | 7 | “Hello World” |
8L | 8 | “Hello World” |
20L | 20 | “Hello World” |
测试语句
SELECT c,
LAST_VALUE(b)
OVER (
PARTITION BY c
ORDER BY PROCTIME() RANGE UNBOUNDED PRECEDING
) AS var1
FROM T1;
测试结果
c(VARCHAR) | var1(INT) |
---|---|
“Hello” | 1 |
“Hello” | 2 |
“Hello” | 3 |
“Hello” | 4 |
“Hello” | 5 |
“Hello” | 6 |
“Hello World” | 7 |
“Hello World” | 8 |
“Hello World” | 20 |
返回所有输入值的最大值。
MAX(A)
参数 | 数据类型 |
---|---|
A | 支持TINYINT,SMALLINT、INT、BIGINT、FLOAT、DECIMAL、DOUBLE、BOOLEAN和VARCHAR类型。 不支持DATE、TIME、TIMESTAMP和VARBINARY类型。 |
测试数据
var1(INT) |
---|
4 |
8 |
测试语句
SELECT MAX(var1) as aa
FROM T1;
测试结果
aa(INT) |
---|
8 |
返回所有输入值的最小值。
MIN(A)
参数 | 数据类型 |
---|---|
A | 支持TINYINT、SMALLINT、INT、BIGINT、FLOAT、DECIMAL、DOUBLE、BOOLEAN和VARCHAR类型。 不支持DATE、TIME、TIMESTAMP和VARBINARY类型。 |
测试数据
var1(INT) |
---|
4 |
8 |
测试语句
SELECT MIN(var1) as aa
FROM T1;
测试结果
aa(INT) |
---|
4 |
返回所有输入值的数值之和。
SUM(A)
参数 | 数据类型 |
---|---|
A | TINYINT、SMALLINT、INT、BIGINT、FLOAT、DECIMAL和DOUBLE。 |
测试数据
var1(INT) |
---|
4 |
4 |
测试语句
SELECT sum(var1) as aa
FROM T1;
测试结果
aa(INT) |
---|
8 |
返回所有输入值的方差。
T VAR_POP(T value)
参数 | 数据类型 |
---|---|
value | 数值型,可以为BIGINT和DOUBLE等类型。 |
测试数据
a(BIGINT) | c(VARCHAR) |
---|---|
2900 | Hi |
2500 | Hi |
2600 | Hi |
3100 | Hello |
11000 | Hello |
测试语句
SELECT
VAR_POP(a) as `result`,
c
FROM MyTable
GROUP BY c;
测试结果
result(BIGINT) | c |
---|---|
28889 | Hi |
15602500 | Hello |
返回数值的总体标准差。
T STDDEV_POP(T value)
参数 | 数据类型 |
---|---|
value | BIGINT或DOUBLE |
测试数据
a(DOUBLE) | c(VARCHAR) |
---|---|
0 | Hi |
1 | Hi |
2 | Hi |
3 | Hi |
4 | Hi |
5 | Hi |
6 | Hi |
7 | Hi |
8 | Hi |
9 | Hi |
测试语句
SELECT c, STDDEV_POP(a) as dou1
FROM MyTable
GROUP BY c;
测试结果
c(VARCHAR) | dou1(DOUBLE) |
---|---|
Hi | 2.8722813232690143 |
返回通用唯一标识字符。
VARCHAR UUID()
无
测试语句
SELECT uuid() as `result`
FROM T1
测试结果
result(VARCHAR) |
---|
a364e414-e68b-4e5c-9166-65b3a153e257 |
DISTINCT用于SELECT语句中,可以对查询结果进行去重。
SELECT DISTINCT expressions
FROM tables;
DISTINCT
必须放到开始位置。和其他函数一起使用时,DISTINCT
也必须放到开始位置,例如,concat_agg(DISTINCT ',' ,device_id)
。expressions
是一个或多个expression,可以是具体的column,也可以是function等任何合法表达式。测试数据
FirstName | LastName |
---|---|
SUNS | HENGRAN |
SUN | JINCHENG |
SUN | SHENGRAN |
SUN | SHENGRAN |
测试语句
CREATE TABLE distinct_tab_source(
FirstName VARCHAR,
LastName VARCHAR
)WITH(
type='random'
) ;
CREATE TABLE distinct_tab_sink(
FirstName VARCHAR,
LastName VARCHAR
)WITH(
type = 'print'
) ;
INSERT INTO distinct_tab_sink
SELECT DISTINCT FirstName, LastName --按照FirstName和LastName两个列进行去重。
FROM distinct_tab_source;
测试结果
SUNS,HENGRAN
和SUN,SHENGRAN
两条记录并没有被去重,说明DISTINCT FirstName, LastName
是对两个字段分别处理的,而不是Concat到一起再进行去重。
在SQL中利用GROUP BY
语句也可以到达和DISTINCT
类似的去重效果。GROUP BY
语法如下。
SELECT expressions
FROM tables
GROUP BY expressions
;
通过多路输出的方式编写的和DISTINCT示例等效的SQL,示例如下。
CREATE TABLE distinct_tab_source(
FirstName VARCHAR,
LastName VARCHAR
)WITH(
type='random'
);
CREATE TABLE distinct_tab_sink(
FirstName VARCHAR,
LastName VARCHAR
)WITH(
type = 'print'
);
CREATE TABLE distinct_tab_sink2(
FirstName VARCHAR,
LastName VARCHAR
)WITH(
type = 'print'
);
INSERT INTO distinct_tab_sink
SELECT DISTINCT FirstName, LastName --按照FirstName和LastName两个列进行去重。
FROM distinct_tab_source;
INSERT INTO distinct_tab_sink2
SELECT FirstName, LastName
FROM distinct_tab_source
GROUP BY FirstName, LastName; --按照FirstName和LastName两个列进行去重。
DISTINCT
能使聚合函数COUNT
统计去重后的计数。
COUNT(DISTINCT expression)
expression
目前只支持一个表达式。
CREATE TABLE distinct_tab_source(
FirstName VARCHAR,
LastName VARCHAR
)WITH(
type='random'
);
CREATE TABLE distinct_tab_sink(
cnt BIGINT,
distinct_cnt BIGINT
)WITH(
type = 'print'
) ;
INSERT INTO distinct_tab_sink
SELECT
COUNT(FirstName), --不去重。
COUNT(DISTINCT FirstName) --按照FirstName去重。
FROM distinct_tab_source;