MaxComputeSQL支持的字符串函数的命令格式,参数及示例_云原生大数据计算服务 MaxCompute-阿里云帮助中心

您可以在MaxCompute SQL中使用字符串函数对指定字符串进行灵活处理。本文为您提供MaxCompute SQL支持的字符串函数的命令格式、参数说明及示例，指导您使用字符串函数完成开发。

MaxCompute SQL支持的字符串函数如下。

函数	功能
ASCII	返回字符串的第一个字符的ASCII码。
CHAR_MATCHCOUNT	计算A字符串出现在B字符串中的字符个数。
CHR	将指定ASCII码转换成字符。
CONCAT	将字符串连接在一起。
CONCAT_WS	将参数中的所有字符串按照指定的分隔符连接在一起。
DECODE	将字符串按照指定编码格式解码。
ENCODE	将字符串按照指定编码格式编码。
FIND_IN_SET	在以逗号分隔的字符串中查找指定字符串的位置。
FORMAT_NUMBER	将数字转化为指定格式的字符串。
FROM_JSON	根据给定的JSON字符串和输出格式信息，返回ARRAY、MAP或STRUCT类型。
GET_JSON_OBJECT	在一个标准JSON字符串中，按照指定方式抽取指定的字符串。
INITCAP	将字符串转换为固定格式的字符串，单词之间以空格分隔。转换后的格式为：字符串中每个单词首字母大写，其余小写。
INSTR	计算A字符串在B字符串中的位置。
IS_ENCODING	判断字符串是否可以从指定的A字符集转换为B字符集。
JSON_TUPLE	在一个标准的JSON字符串中，按照输入的一组键抽取各个键指定的字符串。
KEYVALUE	将字符串拆分为Key-Value对，并将Key-Value对分开，返回Key对应的Value。
KEYVALUE_TUPLE	将字符串拆分为多个Key-Value对，并将Key-Value对分开，返回多个Key对应的Value。
LENGTH	计算字符串的长度。
LENGTHB	计算字符串以字节为单位的长度。
LOCATE	在字符串中查找另一指定字符串的位置。
LPAD	将字符串向左补足到指定位数。
LTRIM	去除字符串的左端字符。
MASK_HASH	返回基于字符串表达式计算的Hash值。
MD5	计算字符串的MD5值。
PARSE_URL	对URL进行解析返回指定部分的信息。
PARSE_URL_TUPLE	对URL进行解析返回多个部分的信息。
REGEXP_COUNT	计算字符串从指定位置开始，匹配指定规则的子串数。
REGEXP_EXTRACT	将字符串按照指定规则拆分为组后，返回指定组的字符串。
REGEXP_EXTRACT_ALL	在字符串中查找所有出现的正则表达式匹配的子字符串，并把找到的字符串以数组形式返回。
REGEXP_INSTR	返回字符串从指定位置开始，与指定规则匹配指定次数的子串的起始或结束位置。
REGEXP_REPLACE	将字符串中，与指定规则在指定次数匹配的子串替换为另一字符串。
REGEXP_SUBSTR	返回字符串中，从指定位置开始，与指定规则匹配指定次数的子串。
REPEAT	返回将字符串重复指定次数后的结果。
REPLACE	将字符串中与指定字符串匹配的子串替换为另一字符串。
REVERSE	返回倒序字符串。
RPAD	将字符串向右补足到指定位数。
RTRIM	去除字符串的右端字符。
SOUNDEX	将普通字符串替换为SOUNDEX字符串。
SPACE	生成空格字符串。
SPLIT_PART	按照分隔符拆分字符串，返回指定部分的子串。
SUBSTR	返回STRING类型字符串从指定位置开始，指定长度的子串。
SUBSTRING	返回STRING或BINARY类型字符串从指定位置开始，指定长度的子串。
SUBSTRING_INDEX	截取字符串指定分隔符前的字符串。
TO_CHAR	将BOOLEAN、BIGINT、DECIMAL或DOUBLE类型值转为对应的STRING类型表示。
TO_JSON	将指定的复杂类型输出为JSON字符串。
TOLOWER	将字符串中的英文字符转换为小写形式。
TOUPPER	将字符串中的英文字符转换为大写形式。
TRANSLATE	将A出现在B中的字符串替换为C字符串。
TRIM	去除字符串的左右两端字符。
URL_DECODE	将字符串从 `application/x-www-form-urlencoded MIME` 格式转为常规字符。
URL_ENCODE	将字符串编码为 `application/x-www-form-urlencoded MIME` 格式。

注意事项

升级到MaxCompute 2.0后，产品扩展了部分函数。如果您用到的函数涉及新数据类型（TINYINT、SMALLINT、INT、FLOAT、VARCHAR、TIMESTAMP或BINARY），在使用扩展函数时，需要执行如下语句开启新数据类型开关：

Session级别：如果使用新数据类型，您需要在SQL语句前加上语句 set odps.sql.type.system.odps2=true; ，并与SQL语句一起提交执行。
Project级别：Project Owner可根据需要对Project进行设置，等待10~15分钟后才会生效。命令如下。
```
setproject odps.sql.type.system.odps2=true;
```
对 setproject 的详细说明请参见项目空间操作。关于开启Project级别数据类型的注意事项，请参见数据类型版本说明。

使用限制

以下函数只支持英文字符的转换：

TRIM/RTRIM/LTRIM：trimChars只支持英文字符。
REVERSE：在Hive模式下只支持英文字符。
SOUNDEX：仅转换英文字符。
TOLOWER：将字符串中的英文字符转换为小写形式。
TOUPPER：将字符串中的英文字符转换为大写形式。
INITCAP：将字符串中每个单词首字母（英文字符）转化为大写形式，其余为小写。

ASCII

命令格式
```
bigint ascii(string <str>)
```
命令说明

返回字符串 str 第一个字符的ASCII码。
参数说明

str ：必填。STRING类型。如果输入为BIGINT、DOUBLE、DECIMAL或DATETIME类型，则会隐式转换为STRING类型后参与运算。
返回值说明
返回BIGINT类型。返回规则如下：
- str 非STRING、BIGINT、DOUBLE、DECIMAL或DATETIME类型时，返回报错。
- str 值为NULL时，返回NULL。
示例
- 示例1：返回字符串 abcde 第一个字符的ASCII码。命令示例如下。
```
--返回97。
select ascii('abcde'); 
```
- 示例2：输入参数为NULL。命令示例如下。
```
--返回NULL。
select ascii(null);
```

CHAR_MATCHCOUNT

命令格式

bigint char_matchcount(string <str1>, string <str2>)

命令说明

计算 str1 中有多少个字符出现在 str2 中。
参数说明

str1 、 str2 ：必填。STRING类型，必须为有效的UTF-8字符串。如果对比过程中发现有无效字符（非UNICODE编码），则返回负值。
返回值说明

返回BIGINT类型。 str1 或 str2 值为NULL时，返回NULL。
示例
- 示例1：计算字符串 aabc 出现在 abcde 中的字符个数。命令示例如下。
```
--返回4。
select char_matchcount('aabc','abcde');
```
- 示例2：任一输入参数为NULL。命令示例如下。
```
--返回NULL。
select char_matchcount(null,'abcde');
```

CHR

命令格式
```
string chr(bigint <ascii>)
```
命令说明

将指定ASCII码转换为字符。
参数说明

ascii ：必填。BIGINT类型的ASCII值。取值范围为0~128。如果输入为STRING、DOUBLE或DECIMAL类型，则会隐式转换为BIGINT类型后参与运算。
返回值说明
返回STRING类型。返回规则如下：
- ascii 值不在取值范围内时，返回报错。
- ascii 非BIGINT、STRING、DOUBLE或DECIMAL类型时，返回报错。
- ascii 值为NULL时，返回NULL。
示例
- 示例1：将ASCII码 100 转换为字符。命令示例如下。
```
--返回d。
select chr(100);
```
- 示例2：输入参数为NULL。命令示例如下。
```
--返回NULL。
select chr(null);
```
- 示例3：输入为STRING类型字符。命令示例如下。
```
--隐式转换为BIGINT类型后参与运算，返回d。
select chr('100');
```

CONCAT

命令格式

array<T> concat(array<T> <a>, array<T> <b>[,...])
string concat(string <str1>, string <str2>[,...])

命令说明
- 输入为ARRAY数组：将多个ARRAY数组中的所有元素连接在一起，生成一个新的ARRAY数组。
- 输入为字符串：将多个字符串连接在一起，生成一个新的字符串。
参数说明
- a 、 b ：必填。ARRAY数组。 array<T> 中的 T 指代ARRAY数组元素的数据类型，数组中的元素可以为任意类型。 a 和 b 中元素的数据类型必须一致。数组中的元素为NULL值时会参与运算。
- str1 、 str2 ：必填。STRING类型。如果输入参数为BIGINT、DOUBLE、DECIMAL或DATETIME类型，则会隐式转换为STRING类型后参与运算，其他类型会返回报错。
返回值说明
- 返回ARRAY类型。如果任一输入ARRAY数组为NULL，返回结果为NULL。
- 返回STRING类型。如果没有参数或任一参数为NULL，返回结果为NULL。
示例
- 示例1：连接ARRAY数组 array(10, 20) 和 array(20, -20) 。命令示例如下。
```
--返回[10, 20, 20, -20]。
select concat(array(10, 20), array(20, -20));
```
- 示例2：ARRAY数组元素包含NULL。命令示例如下。
```
--返回[10, NULL, 20, -20]。
select concat(array(10, null), array(20, -20));
```
- 示例3：任一ARRAY数组为NULL。命令示例如下。
```
--返回NULL。
select concat(array(10, 20), null);
```
- 示例4：连接字符串 aabc 和 abcde 。命令示例如下。
```
--返回aabcabcde。
select concat('aabc','abcde');
```
- 示例5：输入为空。命令示例如下。
```
--返回NULL。
select concat();
```
- 示例6：任一字符串输入为NULL。命令示例如下。
```
--返回NULL。
select concat('aabc', 'abcde', null);
```

CONCAT_WS

命令格式

string concat_ws(string <separator>, string <str1>, string <str2>[,...])
string concat_ws(string <separator>, array<string> <a>)

命令说明

返回将参数中的所有字符串或ARRAY数组中的元素按照指定的分隔符连接在一起的结果。此函数为MaxCompute 2.0扩展函数。
参数说明
- separator ：必填。STRING类型的分隔符。
- str1 、 str2 ：至少要指定2个字符串。STRING类型。如果输入为BIGINT、DECIMAL、DOUBLE或DATETIME类型，则会隐式转换为STRING类型后参与运算。
- a ：必填。ARRAY数组。数组中的元素为STRING类型。
返回值说明
返回STRING类型或STRUCT类型。返回规则如下：
- str1 或 str2 非STRING、BIGINT、DECIMAL、DOUBLE或DATETIME类型时，返回报错。
- 如果没有输入参数或任一输入参数值为NULL，返回NULL。
示例
- 示例1：将字符串 name 和 hanmeimei 通过 : 连接。命令示例如下。
```
--返回name:hanmeimei。
select concat_ws(':','name','hanmeimei');
```
  -
- 示例2：任一输入参数为NULL。命令示例如下。
```
--返回NULL。
select concat_ws(':','avg',null,'34');
```
- 示例3：将ARRAY数组 array('name', 'hanmeimei') 中的元素通过 : 连接。命令示例如下。
```
--返回name:hanmeimei。
select concat_ws(':',array('name', 'hanmeimei'));
```

DECODE

命令格式

string decode(binary <str>, string <charset>)

命令说明

将 str 按照 charset 格式进行解码。
参数说明
- str ：必填。BINARY类型，待解码的字符串。
- charset ：必填。STRING类型，编码格式。取值范围为：UTF-8、UTF-16、UTF-16LE、UTF-16BE、ISO-8859-1、US-ASCII。
返回值说明

返回STRING类型。 str 或 charset 值为NULL时，返回NULL。

示例

示例1：将字符串“中文样例”按照UTF-8格式编码。命令示例如下。

--加解密
select decode(encode("中文样例","UTF-8"), "UTF-8");
+-----+
| _c0 |
+-----+
| 中文样例 |
+-----+

示例2：任一输入参数为NULL。命令示例如下。

--返回结果为NULL。
select decode(encode("中文样例","UTF-8"), null);
| _c0 |
+-----+
| NULL |
+-----+

ENCODE

命令格式

binary encode(string <str>, string <charset>)

命令说明

将 str 按照 charset 格式进行编码。
参数说明
- str ：必填。STRING类型。待重新编码的字符串。
- charset ：必填。STRING类型。编码格式。取值范围为：UTF-8、UTF-16、UTF-16LE、UTF-16BE、ISO-8859-1、US-ASCII。
返回值说明

返回BINARY类型。 str 或 charset 值为NULL时，返回NULL。
示例
- 示例1：将字符串 abc 按照 UTF-8 格式编码。命令示例如下。
```
--返回abc。
select encode("abc", "UTF-8");
```
- 示例2：将字符串 abc 按照 UTF-16BE 格式编码。命令示例如下。
```
--返回=00a=00b=00c。
select encode("abc", "UTF-16BE");
```
- 示例3：任一输入参数为NULL。命令示例如下。
```
--返回结果为NULL。
select encode("abc", null);
```

FIND_IN_SET

命令格式

bigint find_in_set(string <str1>, string <str2>)

命令说明

查找字符串 str1 在以逗号（,）分隔的字符串 str2 中的位置，从1开始计数。
参数说明
- str1 ：必填。STRING类型。待查找的字符串。
- str2 ：必填。STRING类型。以逗号（,）分隔的字符串。
返回值说明
返回BIGINT类型。返回规则如下：
- 当 str2 中无法匹配到 str1 或 str1 中包含逗号（,）时，返回0。
- 当 str1 或 str2 值为NULL时，返回NULL。
示例
- 示例1：查找字符串 ab 在字符串 abc,hello,ab,c 中的位置。命令示例如下。
```
--返回3。
select find_in_set('ab', 'abc,hello,ab,c');
```
- 示例2：查找字符串 hi 在字符串 abc,hello,ab,c 中的位置。命令示例如下。
```
--返回0。
select find_in_set('hi', 'abc,hello,ab,c');
```
- 示例3：任一输入参数为NULL。命令示例如下。
```
--返回NULL。
select find_in_set(null, 'abc,hello,ab,c');
```

FORMAT_NUMBER

命令格式

string format_number(float|double|decimal <expr1>, int <expr2>)

命令说明

将 expr1 转化为满足 expr2 格式的字符串。
参数说明
- expr1 ：必填。FLOAT、DOUBLE、DECIMAL类型。需要格式化的数据。
- expr2 ：必填。INT类型，取值范围为0~340。指代需要保留的小数位数。也可以为类似 #,###,###.## 格式的描述。不同取值返回的小数位数不同。
返回值说明
返回STRING类型。返回规则如下：
- 当 0<expr2≤340 时，四舍五入到小数点后指定位数。
- 当 expr2=0 时，只保留整数，无小数点或小数部分。
- 当 expr2<0 或 expr2>340 时，会返回报错。
- expr1 或 expr2 值为空或NULL时，返回NULL。

示例

示例1：对给定数字按照指定格式输出。命令示例如下。

--返回5.230。
select format_number(5.230134523424545456,3);
--返回12,332.123。
select format_number(12332.123456, '#,###,###,###.###');

示例2：任一输入参数为空或NULL。命令示例如下。

--返回NULL。
select format_number('',3);
--返回NULL。
select format_number(null,3);

FROM_JSON

命令格式
```
from_json(<jsonStr>, <schema>)
```
命令说明

根据JSON字符串 jsonStr 和 schema 信息，返回ARRAY、MAP或STRUCT类型。

参数说明

jsonStr ：必填。输入的JSON字符串。

schema ：必填。写法与建表语句的类型一致。例如 array<bigint> 、 map<string, array<string>> 或 struct<a:int, b:double, `C`:map<string,string>> 。

JSON数据类型	MaxCompute数据类型
OBJECT	STRUCT、MAP、STRING
ARRAY	ARRAY、STRING
NUMBER	TINYINT、SMALLINT、INT、BIGINT、FLOAT、DOUBLE、DECIMAL、STRING
BOOLEAN	BOOLEAN、STRING
STRING	STRING、CHAR、VARCHAR、BINARY、DATE、DATETIME
NULL	所有类型

--返回{"a":1,"b":0.8}。
select from_json('{"a":1, "b":0.8}', 'a int, b double');
--返回{"time":"26/08/2015"}。
select from_json('{"time":"26/08/2015"}', 'time string');
--返回{"a":1,"b":0.8}。
select from_json('{"a":1, "b":0.8}', 'a int, b double, c string');
--返回[1,2,3]。
select from_json('[1, 2, 3, "a"]', 'array<bigint>');
--返回{"d":"v","a":"1","b":"[1,2,3]","c":"{}"}。
select from_json('{"a":1,"b":[1,2,3],"c":{},"d":"v"}', 'map<string, string>');

```
--返回["a","b"]。
select map_keys(from_json('{"a":1,"b":2}','map<string,string>'));
```

json get_json_object(json <json>, string <json_path>)

select get_json_object(json '{"a":1, "b":2}', '$.a');

+-----+
| _c0 |
+-----+
| 1   |
+-----+

select get_json_object(json '{"a":1, "b":2}', '$.c');

+-----+
| _c0 |
+-----+
| NULL |
+-----+

select get_json_object(json '{"a":1, "b":2}', '$invalid_json_path');

+-----+
| _c0 |
+-----+
| NULL |
+-----+

string get_json_object(string <json>, string <path>)

- - - ```
    --返回NULL。
    select get_json_object('{"a":"1","a":"2"}', '$.a');
```
- ```
--返回NULL。
select get_json_object('{"a":"<Emoji符号>"}', '$.a');
```
    - ```
    --返回{"a":"2","b":"1"}。
    select get_json_object('{"b":"1","a":"2"}', '$');
```

--JSON对象src_json.json的内容。
+----+
+----+
{"store":
{"fruit":[{"weight":8,"type":"apple"},{"weight":9,"type":"pear"}],
"bicycle":{"price":19.95,"color":"red"}
"email":"amy@only_for_json_udf_test.net",
"owner":"amy"
--提取owner字段信息，返回amy。
select get_json_object(src_json.json, '$.owner') from src_json;
--提取store.fruit字段第一个数组信息，返回{"weight":8,"type":"apple"}。
select get_json_object(src_json.json, '$.store.fruit[0]') from src_json;
--提取不存在的字段信息，返回NULL。
select get_json_object(src_json.json, '$.non_exist_key') from src_json;

--返回2222。
select get_json_object('{"array":[["aaaa",1111],["bbbb",2222],["cccc",3333]]}','$.array[1][1]');
--返回["h0","h1","h2"]。
set odps.sql.udf.getjsonobj.new=true;
select get_json_object('{"aaa":"bbb","ccc":{"ddd":"eee","fff":"ggg","hhh":["h0","h1","h2"]},"iii":"jjj"}','$.ccc.hhh[*]');
--返回["h0","h1","h2"]。
set odps.sql.udf.getjsonobj.new=false;
select get_json_object('{"aaa":"bbb","ccc":{"ddd":"eee","fff":"ggg","hhh":["h0","h1","h2"]},"iii":"jjj"}','$.ccc.hhh');
--返回h1。
select get_json_object('{"aaa":"bbb","ccc":{"ddd":"eee","fff":"ggg","hhh":["h0","h1","h2"]},"iii":"jjj"}','$.ccc.hhh[1]');

--创建一张表。
create table mf_json (id string, json string);
--向表中插入数据，Key带.。
insert into table mf_json (id, json) values ("1", "{
\"China.beijing\":{\"school\":{\"id\":0,\"book\":[{\"title\": \"A\",
\"price\": 8.95},{\"title\": \"B\",\"price\": 10.2}]}}}");
--向表中插入数据，Key不带.。
insert into table mf_json (id, json) values ("2", "{
\"China_beijing\":{\"school\":{\"id\":0,\"book\":[{\"title\": \"A\",
\"price\": 8.95},{\"title\": \"B\",\"price\": 10.2}]}}}");
--取id的值，查询key为China.beijing，返回0。由于包含.，只能用['']来解析。
select get_json_object(json, "$['China.beijing'].school['id']") from mf_json where id =1;
--取id的值，查询key为China_beijing，返回0。查询方法有如下两种。
select get_json_object(json, "$['China_beijing'].school['id']") from mf_json where id =2;
select get_json_object(json, "$.China_beijing.school['id']") from mf_json where id =2;

--返回NULL。
select get_json_object('','$.array[1][1]');
--返回NULL。
select get_json_object('"array":["aaaa",1111],"bbbb":["cccc",3333]','$.array[1][1]');

set odps.sql.udf.getjsonobj.new=true;
--返回"1"。
select get_json_object('{"a":"\\"1\\"","b":"2"}', '$.a'); 
--返回'1'。
select get_json_object('{"a":"\'1\'","b":"2"}', '$.a');

```
string initcap(<str>)
```

--返回Odps Sql。
SELECT initcap("oDps sql");

bigint instr(string <str1>, string <str2>[, bigint <start_position>[, bigint <nth_appearance>]])

- ```
--返回2。
select instr('Tech on the net', 'e');
```
- ```
--返回6。
select instr('Tech on the net', 'on');
```
- ```
--返回14。
select instr('Tech on the net', 'e', 3, 2);
```
- ```
--返回NULL。
select instr('Tech on the net', null);
```

boolean is_encoding(string <str>, string <from_encoding>, string <to_encoding>)

--返回true。
select is_encoding('测试', 'utf-8', 'gbk');
--返回true。
select is_encoding('測試', 'utf-8', 'gbk');

--GB2312字库中不包括这两个字，返回false。
select is_encoding('測試', 'utf-8', 'gb2312');

```
--返回NULL。
select is_encoding('测试', null, 'gbk');
```

string json_tuple(string <json>, string <key1>, string <key2>,...)

--创建一张表school。
create table school (id string, json string);
--向表中插入数据。
insert into school (id, json) values ("1", "{
\"school\": \"湖畔大学\", \"地址\":\"杭州\", \"SchoolRank\": \"00\", 
\"Class1\":{\"Student\":[{\"studentId\":1,\"scoreRankIn3Year\":[1,2,[3,2,6]]}, 
{\"studentId\":2,\"scoreRankIn3Year\":[2,3,[4,3,1]]}]}}");

select json_tuple(school.json,"SchoolRank","Class1") as (item0, item1) from school;
--等效于如下语句。
select get_json_object(school.json,"$.SchoolRank") item0,get_json_object(school.json,"$.Class1") item1 from school;
--返回结果如下。
+-------+-------+
| item0 | item1 |
+-------+-------+
| 00    | {"Student":[{"studentId":1,"scoreRankIn3Year":[1,2,[3,2,6]]},{"studentId":2,"scoreRankIn3Year":[2,3,[4,3,1]]}]} |
+-------+-------+

select json_tuple(school.json,"school","['Class1'].Student") as (item0, item2) from school where id=1;
--返回结果如下。
+-------+-------+
| item0 | item2 |
+-------+-------+
| 湖畔大学 | [{"studentId":1,"scoreRankIn3Year":[1,2,[3,2,6]]},{"studentId":2,"scoreRankIn3Year":[2,3,[4,3,1]]}] |

select json_tuple(school.json,"校名","地址") as (item0,item1) from school;
--返回结果如下。
+-------+-------+
| item0 | item1 |
+-------+-------+
| 湖畔大学 | 杭州 |
+-------+-------+

select sc.Id, q.item0, q.item1 
from school sc lateral view json_tuple(sc.json,"Class1.Student[*].studentId","Class1.Student[0].scoreRankIn3Year") q as item0,item1;
--返回结果如下。
+------------+-------+-------+
| id         | item0 | item1 |
+------------+-------+-------+
| 1          | [1,2] | [1,2,[3,2,6]] |
+------------+-------+-------+

select sc.Id, q.item0, q.item1
from school sc lateral view json_tuple(sc.json,"Class1.Student[0].scoreRankIn3Year[2]","Class1.Student[0].scoreRankIn3Year[2][1]") q as item0,item1;
--返回结果如下。
+------------+-------+-------+
| id         | item0 | item1 |
+------------+-------+-------+
| 1          | [3,2,6] | 2     |
+------------+-------+-------+

keyvalue(string <str>,[string <split1>,string <split2>,] string <key>)
keyvalue(string <str>,string <key>)

- ```
--返回2。
select keyvalue('0:1\;1:2', 1);
```
```
0 1/  
1 2
```
- ```
--返回21910。
select keyvalue("\;decreaseStore:1\;xcard:1\;isB2C:1\;tf:21910\;cart:1\;shipping:2\;pf:0\;market:shoes\;instPayAmount:0\;","\;",":","tf");
```
```
decreaseStore:1，xcard:1，isB2C:1，tf:21910，cart:1，shipping:2，pf:0，market:shoes，instPayAmount:0 
```
```
decreaseStore 1  
xcard 1  
isB2C 1  
tf 21910  
cart 1  
shipping 2  
market shoes  
instPayAmount 0
```

KEYVALUE_TUPLE(str, split1, split2, key1, key2, ..., keyN)

--创建表
create table mf_user (
user_id string,
user_info string
--插入数据
insert into mf_user values('1','age:18;genda:f;address:abc'),('2','age:20;genda:m;address:bcd');
SELECT user_id,
KEYVALUE(user_info,';',':','age') as age,
KEYVALUE(user_info,';',':','genda') as genda,
KEYVALUE(user_info,';',':','address') as address
FROM mf_user;
--等同于使用KEYVALUE查询
SELECT user_id,
genda,
address
FROM mf_user LATERAL VIEW KEYVALUE_TUPLE(user_info,';', ':','age','genda','address') ui AS age,genda,address;

+------------+------------+------------+------------+
| user_id    | age        | genda      | address    |
+------------+------------+------------+------------+
| 1          | 18         | f          | abc        |
| 2          | 20         | m          | bcd        |
+------------+------------+------------+------------+

```
bigint length(string <str>)
```
- ```
--返回15。
select length('Tech on the net');
```
- ```
--返回NULL。
select length(null);
```

```
bigint lengthb(string <str>)
```
- ```
--返回15。
select lengthb('Tech on the net');
```
- ```
--返回NULL。
select lengthb(null);
```

bigint locate(string <substr>, string <str>[, bigint <start_pos>])

- ```
--返回1。
select locate('ab', 'abchelloabc');
```
- ```
--返回0。
select locate('hi', 'abc,hello,ab,c');
```
- ```
--返回0。
select locate('ab', 'abhelloabc', null);
```

string lpad(string <str1>, int <length>, string <str2>)

- ```
--返回12abcdefgh。
select lpad('abcdefgh', 10, '12');
```
- ```
--返回abcde。
select lpad('abcdefgh', 5, '12');
```
- ```
--返回空串。
select lpad('abcdefgh' ,0, '12'); 
```
- ```
--返回NULL。
select lpad(null ,0, '12');
```

string ltrim(string <str>[, <trimChars>])
string trim(leading [<trimChars>] from <str>)

--返回字符串yxTxyomxx 。
select ltrim(' yxTxyomxx ');
--等效于如下语句。
select trim(leading from ' yxTxyomxx ');

--返回Txyomxx，只要左端遇到x或者y就会被去掉。
select ltrim('yxTxyomxx', 'xy');
--等效于如下语句。
select trim(leading 'xy' from 'yxTxyomxx');

--返回NULL。
select ltrim(null);
select ltrim('yxTxyomxx', null);

```
mask_hash(<expr>)
```

--对abc返回hash值
select mask_hash("abc");
+------------+
| _c0        |
+------------+
| ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad |
+------------+
--对其他类型输入值，返回NULL
select mask_hash(100);
+------------+
| _c0        |
+------------+
| NULL       |
+------------+

```
string md5(string <str>)
```
- ```
--返回ddc4c4796880633333d77a60fcda9af6。
select md5('Tech on the net');
```
- ```
--返回NULL。
select md5(null);
```

string parse_url(string <url>, string <part>[, string <key>])

--返回example.com。
select parse_url('file://username:password@example.com:8042/over/there/index.dtb?type=animal&name=narwhal#nose', 'HOST');
--返回/over/there/index.dtb。
select parse_url('file://username:password@example.com:8042/over/there/index.dtb?type=animal&name=narwhal#nose', 'PATH');
--返回animal。
select parse_url('file://username:password@example.com:8042/over/there/index.dtb?type=animal&name=narwhal#nose', 'QUERY', 'type');
--返回nose。
select parse_url('file://username:password@example.com:8042/over/there/index.dtb?type=animal&name=narwhal#nose', 'REF');
--返回file。
select parse_url('file://username:password@example.com:8042/over/there/index.dtb?type=animal&name=narwhal#nose', 'PROTOCOL');
--返回 username:password@example.com:8042。
select parse_url('file://username:password@example.com:8042/over/there/index.dtb?type=animal&name=narwhal#nose', 'AUTHORITY');
--返回username:password。
select parse_url('file://username:password@example.com:8042/over/there/index.dtb?type=animal&name=narwhal#nose', 'USERINFO');

string parse_url_tuple(string <url>, string <key1>, string <key2>,...)

select parse_url_tuple('file://username:password@example.com:8042/over/there/index.dtb?type=animal&name=narwhal#nose', 'HOST', 'PATH', 'QUERY', 'REF', 'PROTOCOL', 'AUTHORITY', 'FILE', 'USERINFO', 'QUERY:type', 'QUERY:name') as (item0, item1, item2, item3, item4, item5, item6, item7, item8, item9);

+------------+------------+------------+------------+------------+------------+------------+------------+------------+------------+
| item0      | item1      | item2      | item3      | item4      | item5      | item6      | item7      | item8      | item9      |
+------------+------------+------------+------------+------------+------------+------------+------------+------------+------------+
| example.com | /over/there/index.dtb | type=animal&name=narwhal | nose       | file       | username:password@example.com:8042 | /over/there/index.dtb?type=animal&name=narwhal | username:password | animal     | narwhal    |
+------------+------------+------------+------------+------------+------------+------------+------------+------------+------------+

bigint regexp_count(string <source>, string <pattern>[, bigint <start_position>])

- ```
--返回1。
select regexp_count('abababc', 'a.c');
--返回2。
select regexp_count('abababc', '[[:alpha:]]{2}', 3);
```
- ```
--返回NULL。
select regexp_count('abababc', null);
```
- ```
--返回4。
select regexp_count('{"account_id":123456789,"account_name":"allen","location":"hangzhou","bill":100}',':');
```

string regexp_extract(string <source>, string <pattern>[, bigint <groupid>])

--返回the。
select regexp_extract('foothebar', 'foo(.*?)(bar)');
--返回foothebar。
select regexp_extract('foothebar', 'foo(.*?)(bar)', 0);

--返回99。在MaxCompute客户端上提交正则计算的SQL，需要使用两个"\"作为转义字符。
select regexp_extract('8d99d8', '8d(\\d+)d8');

--返回【阿里云】。
select regexp_extract('【阿里云】aliyun', '([^\\x{00}-\\x{ff}]+)');

--返回阿里云。
select regexp_extract('【阿里云】aliyun', '([\\x{4e00}-\\x{9fa5}]+)');

```
--返回【阿里云】阿里云。
select regexp_replace('【阿里云】aliyun阿里云','([\\x{00}-\\x{ff}])', '');
```
```
select regexp_extract('foothebar', 'foothebar');
```

array<T> regexp_extract_all(string <source>, string <pattern>[,bigint <group_id>])

SELECT regexp_extract_all('100-200, 300-400', '(\\d+)-(\\d+)');

+------------+
| _c0        |
+------------+
| [100,300] |
+------------+

SELECT regexp_extract_all('100-200, 300-400', '(\\d+)-(\\d+)',2);

+------------+
| _c0        |
+------------+
| [200,400] |
+------------+

bigint regexp_instr(string <source>, string <pattern>[,bigint <start_position>[, bigint <occurrence>[, bigint <return_option>]]])

- ```
--返回14。
select regexp_instr('i love www.taobao.com', 'o[[:alpha:]]{1}', 3, 2);
```
- ```
--返回16。
select regexp_instr('i love www.taobao.com', 'o[[:alpha:]]{1}', 3, 2, 1);
```
- ```
--返回NULL。
select regexp_instr('i love www.taobao.com', null, 3, 2);
```

string regexp_replace(string <source>, string <pattern>, string <replace_string>[, bigint <occurrence>])

```
--返回(123)456-7890。
select regexp_replace('123.456.7890', '([[:digit:]]{3})\\.([[:digit:]]{3})\\.([[:digit:]]{4})',
'(\\1)\\2-\\3', 0);
```

--返回a b c d。
select regexp_replace('abcd', '(.)', '\\1 ', 0);
--返回a bcd。
select regexp_replace('abcd', '(.)', '\\1 ', 1);
--返回abcd。
select regexp_replace('abcd', '(.)', '\\2', 1);

```
--返回结果为wwwtest。
select regexp_replace(url,'(www)(.*)','wwwtest',0) from url_set;
```

--返回NULL。
select regexp_replace('abcd', '(.)', null, 0);

--因为pattern中只定义了一个组，引用的第二个组不存在。
--请避免这样使用，引用不存在的组的结果未定义。
regexp_replace("abcd", "(.*)(.)$", "\\2", 0) = "d"
--因为在pattern中没有组的定义，所以\1引用了不存在的组，
--请避免这样使用，引用不存在的组的结果未定义。
regexp_replace("abcd", "a", "\\1", 0) = "bcd"

string regexp_substr(string <source>, string <pattern>[, bigint <start_position>[, bigint <occurrence>]])

--返回aliyun。
select regexp_substr('I love aliyun very much', 'a[[:alpha:]]{5}');
--返回have。
select regexp_substr('I have 2 apples and 100 bucks!', '[[:blank:]][[:alnum:]]*', 1, 1);
--返回2。
select regexp_substr('I have 2 apples and 100 bucks!', '[[:blank:]][[:alnum:]]*', 1, 2);

--返回NULL。
select regexp_substr('I love aliyun very much', null);

```
string repeat(string <str>, bigint <n>)
```
- ```
--返回abcabcabcabcabc。
select repeat('abc', 5); 
```
- ```
--返回NULL。
select repeat('abc', null);
```

string replace(string <str>, string <old>, string <new>)

- ```
--返回12ab。
select replace('ababab','abab','12');
```
- ```
--返回NULL。
select replace('123abab456ab',null,'abab');
```

```
string reverse(string <str>)
```
- ```
--返回字符串hcum yrev nuyila evol I。
select reverse('I love aliyun very much');
```
- ```
--返回NULL。
select reverse(null);
```

string rpad(string <str1>, int <length>, string <str2>)

- ```
--返回abcdefgh12。
select rpad('abcdefgh', 10, '12');
```
- ```
--返回abcde。
select rpad('abcdefgh', 5, '12');
```
- ```
--返回空串。
select rpad('abcdefgh' ,0, '12'); 
```
- ```
--返回NULL。
select rpad(null ,0, '12');
```

string rtrim(string <str>[, <trimChars>])
string trim(trailing [<trimChars>] from <str>)

--返回字符串 yxTxyomxx。
select rtrim(' yxTxyomxx ');
--等效于如下语句。
select trim(trailing from ' yxTxyomxx ');

--返回yxTxyom，只要右端遇到x或者y就会被去掉。
select rtrim('yxTxyomxx', 'xy');
--等效于如下语句。
select trim(trailing 'xy' from 'yxTxyomxx');

--返回NULL。
select rtrim(null);
select ltrim('yxTxyomxx', 'null');

```
string soundex(string <str>)
```
- ```
--返回H400。
select soundex('hello');
```
- ```
--返回NULL。
select soundex(null);
```

```
string space(bigint <n>)
```
```
--返回10。
select length(space(10));
```

string split_part(string <str>, string <separator>, bigint <start>[, bigint <end>])

- ```
--返回a。
select split_part('a,b,c,d', ',', 1);
--返回a,b。
select split_part('a,b,c,d', ',', 1, 2);
```
- ```
--返回空串。
select split_part('a,b,c,d', ',', 10);
```
- ```
--返回a,b,c,d。
select split_part('a,b,c,d', ':', 1);
--返回空串。
select split_part('a,b,c,d', ':', 2);
```
- ```
--返回a,b,c,d。
select split_part('a,b,c,d', '', 1);
```
- ```
--返回b,c,d。
select split_part('a,b,c,d', ',', 2, 6);
```
- ```
--返回NULL。
select split_part('a,b,c,d', ',', null);
```

string substr(string <str>, bigint <start_position>[, bigint <length>])

--返回bc。
select substr('abc', 2);
--返回b。
select substr('abc', 2, 1);
--返回bc。
select substr('abc',-2 , 2);

```
--返回NULL。
select substr('abc', null);
```

string substring(string|binary <str>, int <start_position>[, int <length>])

--返回bc。
select substring('abc', 2);
--返回b。
select substring('abc', 2, 1);
--返回bc。
select substring('abc',-2,2);
--返回ab。
select substring('abc',-3,2);
--返回001。
substring(bin(2345), 2, 3);

```
--返回NULL。
select substring('abc', null, null);
```

string substring_index(string <str>, string <separator>, int <count>)

--返回https://help.aliyun。
select substring_index('https://help.aliyun.com', '.', 2);
--返回aliyun.com。
select substring_index('https://help.aliyun.com', '.', -2);

--返回NULL。
select substring_index('https://help.aliyun.com', null, 2);

string to_char(boolean <value>)
string to_char(bigint <value>)
string to_char(double <value>)
string to_char(decimal <value>)

--返回字符串123。
select to_char(123);
--返回字符串TRUE。
select to_char(true);
--返回字符串1.23。
select to_char(1.23);

```
--返回NULL。
select to_char(null);
```

```
to_json(<expr>)
```

--返回{"a":1,"b":2}。
select to_json(named_struct('a', 1, 'b', 2));
--返回{"time":"26/08/2015"}。
select to_json(named_struct('time', "26/08/2015"));
--返回[{"a":1,"b":2}]。
select to_json(array(named_struct('a', 1, 'b', 2)));
--返回{"a":{"b":1}}。
select to_json(map('a', named_struct('b', 1)));
--返回{"a":1}。
select to_json(map('a', 1));
--返回[{"a":1}]。
select to_json(array((map('a', 1))));

--返回{"a":"B"}。STRUCT类型转换为JSON字符串时，key会全部转为小写。
select to_json(named_struct("A", "B"));
--返回{"k2":"v2"}。NULL值所在组的数据，不会输出到JSON字符串。
select to_json(named_struct("k1", cast(null as string), "k2", "v2"));

```
string tolower(string <source>)
```
- ```
--返回abcd。
select tolower('aBcd');
--返回中国fighting。
select tolower('中国Fighting');
```
- ```
--返回NULL。
select tolower(null);
```

```
string toupper(string <source>)
```
- ```
--返回ABCD。
select toupper('aBcd');
--返回中国FIGHTING。
select toupper('中国Fighting');
```
- ```
--返回NULL。
select toupper(null);
```

string translate(string|varchar <str1>, string|varchar <str2>, string|varchar <str3>)

- ```
--返回cdcdcd。
select translate('ababab','abab','cd');
```
- ```
--返回cdcdcd。
select translate('ababab','abab','cdefg');
```
- ```
--返回NULL。
select translate('ababab','cd',null);
```

string trim(string <str>[,<trimChars>])
string trim([BOTH] [<trimChars>] from <str>)

--返回字符串yxTxyomxx。
select trim(' yxTxyomxx ');
--等效于如下语句。
select trim(both from ' yxTxyomxx ');
select trim(from ' yxTxyomxx ');

--返回Txyom，只要左右两端遇到x或者y就会被去掉。
select trim('yxTxyomxx', 'xy');
--等效于如下语句。
select trim(both 'xy' from 'yxTxyomxx');
select trim('xy' from 'yxTxyomxx');

--返回NULL。
select trim(null);
select trim('yxTxyomxx', null);

string url_decode(string <input>[, string <encoding>])

--返回示例for url_decode:// (fdsf)。
select url_decode('%E7%A4%BA%E4%BE%8Bfor+url_decode%3A%2F%2F+%28fdsf%29');
--返回Example for URL_DECODE:// dsf(fasfs)。
select url_decode('Example+for+url_decode+%3A%2F%2F+dsf%28fasfs%29', 'GBK');

string url_encode(string <input>[, string <encoding>])

--返回%E7%A4%BA%E4%BE%8Bfor+url_encode%3A%2F%2F+%28fdsf%29。
select url_encode('示例for url_encode:// (fdsf)');
--返回Example+for+url_encode+%3A%2F%2F+dsf%28fasfs%29。
select url_encode('Example for url_encode:// dsf(fasfs)', 'GBK');

注意事项

使用限制

ASCII

CHAR_MATCHCOUNT

CHR

CONCAT

CONCAT_WS

DECODE

ENCODE

FIND_IN_SET

FORMAT_NUMBER

FROM_JSON

GET_JSON_OBJECT

使用说明

入参为JSON类型

入参为STRING类型

INITCAP

INSTR

IS_ENCODING

JSON_TUPLE

KEYVALUE

KEYVALUE_TUPLE

LENGTH

LENGTHB

LOCATE

LPAD

LTRIM

MASK_HASH

MD5

PARSE_URL

PARSE_URL_TUPLE

REGEXP_COUNT

REGEXP_EXTRACT

REGEXP_EXTRACT_ALL

REGEXP_INSTR

REGEXP_REPLACE

REGEXP_SUBSTR

REPEAT

REPLACE

REVERSE

RPAD

RTRIM

SOUNDEX

SPACE

SPLIT_PART

SUBSTR

SUBSTRING

SUBSTRING_INDEX

TO_CHAR

TO_JSON

TOLOWER

TOUPPER

TRANSLATE

TRIM

URL_DECODE

URL_ENCODE