字符串函数

最后更新时间：2024-08-07 17:33:02
字符串函数
最后更新时间： 2024-08-07 17:33:02
ASCII
函数语法：
ASCII(<str> string)
支持引擎：SparkSQL、Presto。
使用说明：返回 str 的第一个字符的数值。
返回类型：integer。
示例：
> SELECT ascii('222');
 50
BASE64
函数语法：
-- SparkSQL
BASE64(<str> string|binary)
-- Presto
BASE64(<str> binary)
支持引擎：SparkSQL、Presto。
使用说明：将参数转换为 base64 字符串。
返回类型：string。
示例：
> SELECT base64('tencent');
 dGVuY2VudA==
BIT_LENGTH
函数语法：
BIT_LENGTH(<expr> string|binary)
支持引擎：SparkSQL、Presto。
使用说明：返回字符串数据的位长度或二进制数据的位数。
返回类型：integer。
示例：
> select bit_length('tencent');
 56
> select bit_length(binary('tencent'));
 56
CHAR
函数语法：
CHAR(<expr> integer)
支持引擎：SparkSQL、Presto。
使用说明：返回 expr 的 ASCII 字符。如果 expr 大于256，则 expr=expr%256。
返回类型：string。
示例：
> SELECT char(65);
 A
CHR
函数语法：
CHR(<expr> integer)
支持引擎：SparkSQL。
使用说明：返回 expr 的 ASCII 字符。如果 expr 大于256，则 expr=expr%256。
返回类型：string。
示例：
> SELECT chr(65);
 A
CHAR_LENGTH
函数语法：
CHAR_LENGTH(<expr> string|binary)
支持引擎：SparkSQL、Presto。
使用说明：返回字符串数据的字符长度或二进制数据的字节数。字符串数据的长度包括末尾空格。二进制数据的长度包括二进制零。
返回类型：integer。
示例：
> select char_length(binary('tencent'));
 7
> select char_length('tencent');
 7
CHARACTER_LENGTH
函数语法：
CHARACTER_LENGTH(<expr> string|binary)
支持引擎：SparkSQL、Presto。
使用说明：返回字符串数据的字符长度或二进制数据的字节数。字符串数据的长度包括末尾空格。二进制数据的长度包括二进制零。
返回类型：integer。
示例：
> select character_length(binary('tencent'));
 7
> select character_length('tencent');
 7
CONCAT_WS
函数语法：
CONCAT_WS(<sep> string[, <s> string|array<string>}]+)
支持引擎：SparkSQL、Presto。
使用说明：返回由 sep 分隔的字符串。
返回类型：string。
示例：
> SELECT concat_ws(' ', 'tencent', 'dlc');
tencent dlc
DECODE
函数语法：
DECODE(<expr> binary|string, <charset>string)
支持引擎：SparkSQL、Presto。
使用说明：使用第二个参数字符集解码第一个参数。
返回类型：string。
示例：
> SELECT decode(encode('abc', 'utf-8'), 'utf-8');
 abc
ELT
函数语法：
ELT(<n> integer, <s1> string, <s2> string, ...)
支持引擎：SparkSQL、Presto。
使用说明：返回第 n 个元素。
返回类型：string。
示例：
> SELECT elt(1, 'scala', 'java');
 scala
ENCODE
函数语法：
ENCODE(<expr> binary|string, <charset> string)
支持引擎：SparkSQL、Presto。
使用说明：使用第二个参数字符集对第一个参数进行编码。
返回类型：string。
示例：
> SELECT encode('abc', 'utf-8');
 abc
> SELECT encode(x'616263', 'utf-8');
 abc
FIND_IN_SET
函数语法：
FIND_IN_SET(<str> string, <str_array> string)
支持引擎：SparkSQL、Presto。
使用说明：返回逗号分隔列表 atr_array 中给定字符串 str 的索引（从1开始计数）。如果未找到字符串或 str 包含逗号，则返回0。
返回类型：integer。
示例：
> SELECT find_in_set('ab','abc,b,ab,c,def');
 3
FORMAT_NUMBER
函数语法：
FORMAT_NUMBER(<expr1> integer|double|decimal, <expr2> string|integer)
支持引擎：SparkSQL、Presto。
使用说明：将 expr1 的格式设置为'#,####,####.##'，四舍五入到 expr2 小数位。如果 expr2 为0，则结果没有小数点或小数部分。
返回类型：string。
示例：
> SELECT format_number(12332.123456, 4);
 12,332.1235
> SELECT format_number(12332.123456, '##################.###');
 12332.123
FORMAT_STRING
函数语法：
FORMAT_STRING(<str> string, obj <T>, ...)
支持引擎：SparkSQL、Presto。
使用说明：返回 printf 样式格式字符串中的格式化字符串。
返回类型：string。
示例：
> SELECT format_string("Hello World %d %s", 100, "days");
 Hello World 100 days
INITCAP
函数语法：
INITCAP(<str> string)
支持引擎：SparkSQL、Presto。
使用说明：每个单词的第一个字母都改为大写，所有其他字母均为小写。
返回类型：string。
示例：
> SELECT initcap('sPark sql');
 Spark Sql
INSTR
函数语法：
INSTR(<str> string, <substr> string)
支持引擎：SparkSQL、Presto。
使用说明：返回 str 中第一次出现 substr 的索引（从1开始计数）。
返回类型：integer。
示例：
> SELECT instr('SparkSQL', 'SQL');
 6
LCASE
函数语法：
LCASE(<str> string)
支持引擎：SparkSQL、Presto。
使用说明：str 改为小写。
返回类型：string。
示例：
> SELECT lcase('SparkSQL');
 sparksql
LENGTH
函数语法：
LENGTH(<expr> string|binary)
支持引擎：SparkSQL、Presto。
使用说明：返回字符串数据的字符长度或二进制数据的字节数。字符串数据的长度包括最后的空格。二进制数据的长度包括二进制零。
返回类型：integer。
示例：
> SELECT length('Spark SQL ');
 10
LEVENSHTEIN
函数语法：
LEVENSHTEIN(<s1> string, <s2> string)
支持引擎：SparkSQL、Presto。
使用说明：返回两个给定字符串之间的 Levenshtein 距离。
返回类型：integer。
示例：
> SELECT levenshtein('kitten', 'sitting');
 3
LIKE
函数语法：
LIKE(<s1> str, <s2> pattern)
<str> like <pattern>[ ESCAPE <escape>]
支持引擎：SparkSQL、Presto。
使用说明：如果 str 匹配带转义 escape 的 pattern，则返回 true；如果任何参数为 null，则返回 null；否则返回 false。
返回类型：boolean。
示例：
> SELECT like('Spark', '_park');
true
> SET spark.sql.parser.escapedStringLiterals=true;
spark.sql.parser.escapedStringLiterals  true
> SELECT '%SystemDrive%\\Users\\John' like '\\%SystemDrive\\%\\\\Users%';
true
> SET spark.sql.parser.escapedStringLiterals=false;
spark.sql.parser.escapedStringLiterals  false
> SELECT '%SystemDrive%\\\\Users\\\\John' like '\\%SystemDrive\\%\\\\\\\\Users%';
false
> SELECT '%SystemDrive%/Users/John' like '/%SystemDrive/%//Users%' ESCAPE '/';
true
LOWER
函数语法：
LOWER(<str> string)
支持引擎：SparkSQL、Presto。
使用说明：返回所有字符都更改为小写的 str。
返回类型：string。
示例：
> SELECT lower('TENCENT');
 tencent
LOCATE
函数语法：
LOCATE(<substr> string, <str> string[, <pos> integer])
支持引擎：SparkSQL、Presto。
使用说明：返回在 str 中第 pos 位之后中第一次出现 substr 的位置。
返回类型：integer。
示例：
> SELECT locate('bar', 'foobarbar');
 4
> SELECT locate('bar', 'foobarbar', 5);
 7
OCTET_LENGTH
函数语法：
OCTET_LENGTH(<expr> string|binary)
支持引擎：SparkSQL、Presto。
使用说明：返回字符串数据的字节长度或二进制数据的字节数。
返回类型：integer。
示例：
> SELECT octet_length('Spark SQL');
 9
LPAD
函数语法：
LPAD(<str> string, <len> integer[, <pad> string])
支持引擎：SparkSQL、Presto。
使用说明：返回 str，在左填充 pad 到长度 len。如果 str 长于 len，则返回值缩短为 len 个字符。如果未指定 pad，str 将用空格字符填充。
返回类型：string。
示例：
> SELECT lpad('hi', 5, '??');
 ???hi
> SELECT lpad('hi', 1, '??');
 h
> SELECT lpad('hi', 5);
  hi
LTRIM
函数语法：
LTRIM(<str> string)
支持引擎：SparkSQL、Presto。
使用说明：从 str 中删除前导空格字符。
返回类型：string。
示例：
> SELECT ltrim('    SparkSQL   ');
 SparkSQL   
PARSE_URL
函数语法：
PARSE_URL(<url> string, <path> string[, <key> string])
支持引擎：SparkSQL、Presto。
使用说明：从 url 中提取 path。
返回类型：string。
示例：
> SELECT parse_url('http://spark.apache.org/path?query=1', 'HOST');
 spark.apache.org
> SELECT parse_url('http://spark.apache.org/path?query=1', 'QUERY');
 query=1
> SELECT parse_url('http://spark.apache.org/path?query=1', 'QUERY', 'query');
 1
POSITION
函数语法：
POSITION(<substr> string, <str> string[, <pos> integer])
支持引擎：SparkSQL、Presto。
使用说明：返回在 str 中第 pos 位之后中第一次出现 substr 的位置。
返回类型：integer。
示例：
> SELECT position('bar', 'foobarbar');
 4
> SELECT position('bar', 'foobarbar', 5);
 7
> SELECT POSITION('bar' IN 'foobarbar');
 4
PRINTF
函数语法：
PRINTF(<str> string, obj <T>, ...)
支持引擎：SparkSQL、Presto。
使用说明：返回 printf 样式格式字符串中的格式化字符串。
返回类型：string。
示例：
> SELECT printf("Hello World %d %s", 100, "days");
 Hello World 100 days
REPEAT
函数语法：
REPEAT(<str> string, <n> integer)
支持引擎：SparkSQL、Presto。
使用说明：返回将给定字符串重复 n 次的字符串。
返回类型：string。
示例：
> SELECT repeat('123', 2);
 123123
REPLACE
函数语法：
REPLACE(<str> string, <search> string[, <replace> string])
支持引擎：SparkSQL、Presto。
使用说明：用 replace 替换 str 中所有出现的 search。
返回类型：string。
示例：
> SELECT replace('ABCabc', 'abc', 'DEF');
 ABCDEF
OVERLAY
函数语法：
OVERLAY(<input> string, <replace> string, <pos> integer[, <len> integer])
支持引擎：SparkSQL。
使用说明：将 input 替换为从 pos 开始、长度为 len 的 replace。
返回类型：string。
示例：
> SELECT overlay('Spark SQL' PLACING '_' FROM 6);
 Spark_SQL
> SELECT overlay('Spark SQL' PLACING 'CORE' FROM 7);
 Spark CORE
> SELECT overlay('Spark SQL' PLACING 'ANSI ' FROM 7 FOR 0);
 Spark ANSI SQL
> SELECT overlay('Spark SQL' PLACING 'tructured' FROM 2 FOR 4);
 Structured SQL
> SELECT overlay(encode('Spark SQL', 'utf-8') PLACING encode('_', 'utf-8') FROM 6);
 Spark_SQL
> SELECT overlay(encode('Spark SQL', 'utf-8') PLACING encode('CORE', 'utf-8') FROM 7);
 Spark CORE
> SELECT overlay(encode('Spark SQL', 'utf-8') PLACING encode('ANSI ', 'utf-8') FROM 7 FOR 0);
 Spark ANSI SQL
> SELECT overlay(encode('Spark SQL', 'utf-8') PLACING encode('tructured', 'utf-8') FROM 2 FOR 4);
 Structured SQL
RPAD
函数语法：
RPAD(<str> string, <len> integer[, <pad> string])
支持引擎：SparkSQL、Presto。
使用说明：返回 str，在右填充 pa d到长度 len。如果 str 长于 len，则返回值缩短为 len 个字符。如果未指定 pad，str 将用空格字符填充。
返回类型：string。
示例：
> SELECT rpad('hi', 5, '??');
 hi???
> SELECT rpad('hi', 1, '??');
 h
> SELECT rpad('hi', 5);
 hi
RTRIM
函数语法：
RTRIM(<str> string)
支持引擎：SparkSQL、Presto。
使用说明：从 str 中删除尾部空格字符。
返回类型：string。
示例：
> SELECT rtrim('    SparkSQL   ');
   SparkSQL
SENTENCES
函数语法：
SENTENCES(<str> string[, <lang> string, <country> string])
支持引擎：SparkSQL、Presto。
使用说明：将 str 拆分为一个单词数组。
返回类型：array <string>。
示例：
> SELECT sentences('Hi there! Good morning.');
 [["Hi","there"],["Good","morning"]]
SOUNDEX
函数语法：
SOUNDEX(<str> string)
支持引擎：SparkSQL、Presto。
使用说明：返回字符串的 Soundex 编码。
返回类型：string。
示例：
> SELECT soundex('Miller');
 M460
SPACE
函数语法：
SPACE(<n> integer)
支持引擎：SparkSQL、Presto。
使用说明：返回由 n 个空格组成的字符串。
返回类型：string。
示例：
> SELECT concat(space(2), '1');
 1
SPLIT
函数语法：
SPLIT(<str> string, <regex> string, <limit> integer)
支持引擎：SparkSQL、Presto。
使用说明：以与regex匹配的字符串作为分隔符，拆分str，并返回长度最大为limit的数组。
返回类型：array <string>。
示例：
> SELECT split('oneAtwoBthreeC', '[ABC]');
 ["one","two","three",""]
> SELECT split('oneAtwoBthreeC', '[ABC]', -1);
 ["one","two","three",""]
> SELECT split('oneAtwoBthreeC', '[ABC]', 2);
 ["one","twoBthreeC"]
SUBSTRING
函数语法：
SUBSTRING(<str> string, <pos> integer[, <len> integer])
SUBSTRING(<str> FROM <pos>[ FOR <len>])
支持引擎：SparkSQL、Presto。
使用说明：返回从 pos 开始且长度为 len 的 str 子字符串，或从 pos 开始且长度为 len 的字节数组切片。
返回类型：string。
示例：
> SELECT substring('Spark SQL', 5);
 k SQL
> SELECT substring('Spark SQL', -3);
 SQL
> SELECT substring('Spark SQL', 5, 1);
 k
> SELECT substring('Spark SQL' FROM 5);
 k SQL
> SELECT substring('Spark SQL' FROM -3);
 SQL
> SELECT substring('Spark SQL' FROM 5 FOR 1);
 k
SUBSTR
函数语法：
SUBSTR(<str> string, <pos> integer[, <len> integer])
SUBSTR(<str> FROM <pos>[ FOR <len>])
支持引擎：SparkSQL、Presto。
使用说明：返回从pos开始且长度为len的str子字符串，或从pos开始且长度为len的字节数组切片。
返回类型：string。
示例：
> SELECT substr('Spark SQL', 5);
 k SQL
> SELECT substr('Spark SQL', -3);
 SQL
> SELECT substr('Spark SQL', 5, 1);
 k
> SELECT substr('Spark SQL' FROM 5);
 k SQL
> SELECT substr('Spark SQL' FROM -3);
 SQL
> SELECT substr('Spark SQL' FROM 5 FOR 1);
 k
LEFT
函数语法：
LEFT(<str> string, <len> integer)
支持引擎：SparkSQL、Presto。
使用说明：返回字符串str中最左边的len字符，如果len小于或等于0，则结果为空字符串。
返回类型：string。
示例：
> SELECT left('tencent', 3);
 ten
RIGHT
函数语法：
RIGHT(<str> string, <len> integer)
支持引擎：SparkSQL、Presto。
使用说明：返回字符串str中最左边的len字符，如果len小于或等于0，则结果为空字符串。
返回类型：string。
示例：
> SELECT left('tencent', 3);
 ten
SUBSTRING_INDEX
函数语法：
SUBSTRING_INDEX(<str> string, <delim> string, <count> integer)
支持引擎：SparkSQL、Presto。
使用说明：在delim的出现count之前，从str返回子字符串。如果count为正数，则返回最后定界符左侧的所有内容（从左侧计数）。如果计数为负数，则返回最终定界符右侧的所有内容（从右侧计数）。该函数在匹配delim时区分大小写。
返回类型：string。
示例：
> SELECT substring_index('cloud.tencent.com', '.', 2);
 cloud.tencent
TRANSLATE
函数语法：
TRANSLATE(<input> string, <from> string, <to> string)
支持引擎：SparkSQL。
使用说明：通过将from字符串中的字符替换为to字符串中的相应字符来转换input字符串。
返回类型：string。
示例：
> SELECT translate('AaBbCc', 'abc', '123');
 A1B2C3
TRIM
函数语法：
TRIM(<str> string)
trim(BOTH FROM str)
trim(LEADING FROM str)
trim(TRAILING FROM str)
trim(trimStr FROM str)
trim(BOTH trimStr FROM str)
trim(LEADING trimStr FROM str)
trim(TRAILING trimStr FROM str)
支持引擎：SparkSQL、Presto
使用说明：
trim(str) - 从str中删除前导和末尾空格字符。
trim(BOTH FROM str) ：从str中删除前导和末尾空格字符。
trim(LEADING FROM str) ：从str中删除前导空格字符。
trim(TRAILING FROM str) ：从str中删除末尾空格字符。
trim(trimStr FROM str) ：从str中删除开头和结尾的trimStr字符。
trim(BOTH trimStr FROM str) ：从str中删除开头和结尾的trimStr字符。
trim(LEADING trimStr FROM str) ：从str中删除前导trimStr字符。
trim(TRAILING trimStr FROM str)：从str中删除尾部trimStr字符。
返回类型：string
示例：
> SELECT trim('    SparkSQL   ');
 SparkSQL
> SELECT trim(BOTH FROM '    SparkSQL   ');
 SparkSQL
> SELECT trim(LEADING FROM '    SparkSQL   ');
 SparkSQL
> SELECT trim(TRAILING FROM '    SparkSQL   ');
   SparkSQL
> SELECT trim('SL' FROM 'SSparkSQLS');
 parkSQ
> SELECT trim(BOTH 'SL' FROM 'SSparkSQLS');
 parkSQ
> SELECT trim(LEADING 'SL' FROM 'SSparkSQLS');
 parkSQLS
> SELECT trim(TRAILING 'SL' FROM 'SSparkSQLS');
 SSparkSQ
BTRIM
函数语法：
BTRIM(<str> string[, <trimStr> string])
支持引擎：SparkSQL、Presto
使用说明：从str中删除开头和结尾trimStr（默认为空格）字符。
返回类型：string
示例：
> SELECT btrim('    SparkSQL   ');
 SparkSQL
> SELECT btrim(encode('    SparkSQL   ', 'utf-8'));
 SparkSQL
> SELECT btrim('SSparkSQLS', 'SL');
 parkSQ
> SELECT btrim(encode('SSparkSQLS', 'utf-8'), encode('SL', 'utf-8'));
 parkSQ
UCASE
函数语法：
UCASE(<str> string)
支持引擎：SparkSQL、Presto
使用说明：返回所有字符都改为大写的str。
返回类型：string
示例：
> SELECT ucase('SparkSQL');
 SPARKSQL
UNBASE64
函数语法：
UNBASE64(<str> string)
支持引擎：SparkSQL、Presto
使用说明：将str从base64字符串转换为二进制。
返回类型：binary
示例：
> SELECT unbase64('U3BhcmsgU1FM');
 Spark SQL
UNHEX
函数语法：
UNHEX(<str> string)
支持引擎：SparkSQL、Presto
使用说明：将十六进制的str转换为二进制。
返回类型：binary
示例：
> select unhex('74656E63656E74');
 tencent
UPPER
函数语法：
UPPER(<str> string)
支持引擎：SparkSQL、Presto
使用说明：返回所有字符都改为大写的str。
返回类型：string
示例：
> SELECT upper('tencent');
TENCENT
UUID
函数语法：
UUID()
支持引擎：SparkSQL、Presto
使用说明：返回一个36字符的UUID
返回类型：string
示例：
> SELECT uuid();
 46707d92-02f4-4817-8116-a4c3b23e6266
XPATH
函数语法：
XPATH(<xml> string, <xpath> string)
支持引擎：SparkSQL、Presto
使用说明：返回xml节点中与XPath表达式匹配的字符串数组。
返回类型：array <string>
示例：
> SELECT xpath('<a><b>b1</b><b>b2</b><b>b3</b><c>c1</c><c>c2</c></a>','a/b/text()');
 ["b1","b2","b3"]
XPATH_BOOLEAN
函数语法：
XPATH_BOOLEAN(<xml> string, <xpath> string)
支持引擎：SparkSQL、Presto
使用说明：如果XPath表达式的计算结果为true，或者如果找到匹配的节点，则返回true。
返回类型：boolean
示例：
> SELECT xpath_boolean('<a><b>1</b></a>','a/b');
 true
XPATH_DOUBLE
函数语法：
XPATH_DOUBLE(<xml> string, <xpath> string)
支持引擎：SparkSQL、Presto
使用说明：返回一个double类型的值，如果未找到匹配项，则返回零；如果找到匹配项但该值不是数字，则返回NaN。
返回类型：double
示例：
> SELECT xpath_double('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
 3.0
XPATH_NUMBER
函数语法：
XPATH_NUMBER(<xml> string, <xpath> string)
支持引擎：SparkSQL、Presto
使用说明：返回一个double类型的值，如果未找到匹配项，则返回零；如果找到匹配项但该值不是数字，则返回NaN。
返回类型：double
示例：
> SELECT xpath_number('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
 3.0
XPATH_FLOAT
函数语法：
XPATH_FLOAT(<xml> string, <xpath> string)
支持引擎：SparkSQL、Presto
使用说明：返回float类型的值，如果未找到匹配项，则返回零；如果找到匹配项但该值为非数字，则返回NaN。
返回类型：float
示例：
> SELECT xpath_float('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
 3.0
XPATH_INT
函数语法：
XPATH_INT(<xml> string, <xpath> string)
支持引擎：SparkSQL、Presto
使用说明：返回int类型的值，如果未找到匹配项，则返回零；如果找到匹配项但该值为非数字，则返回NaN。
返回类型：integer
示例：
> SELECT xpath_int('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
 3
XPATH_LONG
函数语法：
XPATH_LONG(<xml> string, <xpath> string)
支持引擎：SparkSQL、Presto
使用说明：返回bigint类型的值，如果未找到匹配项，则返回零；如果找到匹配项但该值为非数字，则返回NaN。
返回类型：bigint
示例：
> SELECT xpath_long('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
 3
XPATH_SHORT
函数语法：
XPATH_SHORT(<xml> string, <xpath> string)
支持引擎：SparkSQL、Presto
使用说明：返回short类型的值，如果未找到匹配项，则返回零；如果找到匹配项但该值为非数字，则返回NaN。
返回类型：short
示例：
> SELECT xpath_short('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
 3
XPATH_STRING
函数语法：
XPATH_STRING(<xml> string, <xpath> string)
支持引擎：SparkSQL、Presto
使用说明：返回与XPath表达式匹配的第一个xml节点的文本内容。
返回类型：string
示例：
> SELECT xpath_string('<a><b>b</b><c>cc</c></a>','a/c');
 cc
REGEXP_EXTRACT
函数语法：
REGEXP_EXTRACT(<str> string, <regexp> string[, <idx> integer])
支持引擎：SparkSQL、Presto
使用说明：提取str中与regexp表达式匹配并对应于regex组索引idx的第一个字符串。
返回类型：string
示例：
> SELECT regexp_extract('100-200', '(\\\\d+)-(\\\\d+)', 1);
 100
REGEXP_EXTRACT_ALL
函数语法：
REGEXP_EXTRACT_ALL(<str> string, <regexp> string[, <idx> integer])
支持引擎：SparkSQL、Presto
使用说明：提取str中与regexp表达式匹配并对应于regex组索引的所有字符串。
返回类型：array <string>
示例：
> SELECT regexp_extract_all('100-200, 300-400', '(\\\\d+)-(\\\\d+)', 1);
 ["100","300"]
REGEXP_REPLACE
函数语法：
REGEXP_REPLACE(<str> string, <regexp> string, <rep> string[, <position> integer])
支持引擎：SparkSQL、Presto
使用说明：用rep替换str中与regexp匹配的所有子字符串。
返回类型：string
示例：
> SELECT regexp_replace('100-200', '(\\\\d+)', 'num');
 num-num
REGEXP_LIKE
函数语法：
REGEXP_LIKE(<str> string, <regexp> string)
支持引擎：SparkSQL
使用说明：如果字符串匹配正则表达式，则返回 true，否则返回 false
返回类型：boolean
示例：
> SELECT regexp_like('%SystemDrive%\\Users\\John', '%SystemDrive%\\Users.*');
 true
REGEXP
函数语法：
REGEXP(<str> string, <regexp> string)
支持引擎：SparkSQL
使用说明：如果字符串匹配正则表达式，则返回 true，否则返回 false
返回类型：boolean
示例：
> SELECT regexp('%SystemDrive%\\Users\\John', '%SystemDrive%\\Users.*');
true
CONCAT
函数语法：
CONCAT(<s1> string, <s2> string, ...)
支持引擎：SparkSQL、Presto
使用说明：连接s1, s2, ...
返回类型：string
示例：
> SELECT concat('Spark', 'SQL');
 SparkSQL
STR_TO_MAP
函数语法：
str_to_map(<text> string[, <pairDelim> string[, <keyValueDelim> string]])
支持引擎：SparkSQL、Presto
使用说明：使用分隔符将text拆分为键/值对后创建map。 对于pairDelim，默认分隔符是','，对于 keyValueDelim，默认分隔符是':'。pairDelim和keyValueDelim都被视为正则表达式。
返回类型：map <string, string>
示例：
> SELECT str_to_map('a:1,b:2,c:3', ',', ':');
 {"a":"1","b":"2","c":"3"}
> SELECT str_to_map('a');
 {"a":null}
REVERSE
函数语法：
REVERSE(<str> string)
支持引擎：SparkSQL、Presto
使用说明：返回一个反转的字符串。
返回类型：string
示例：
> SELECT reverse('Spark SQL');
 LQS krapS
RLIKE
函数语法：
RLIKE(<str> string, <regexp> string)
支持引擎：SparkSQL、Presto
使用说明：如果str匹配regexp，则返回true，否则返回false。
返回类型：boolean
示例：
> SELECT rlike('%SystemDrive%\\Users\\John', '%SystemDrive%\\Users.*');
true
FROM_CSV
函数语法：
FROM_CSV(<cvsStr> string, <schema> string, <options> map<string, string>)
支持引擎：SparkSQL
使用说明：返回具有给定csvStr和schema的结构值。
返回类型：struct
示例：
> SELECT from_csv('1, 0.8', 'a INT, b DOUBLE');
 {"a":1,"b":0.8}
> SELECT from_csv('26/08/2015', 'time Timestamp', map('timestampFormat', 'dd/MM/yyyy'));
 {"time":2015-08-26 00:00:00}
SCHEMA_OF_CSV
函数语法：
SCHEMA_OF_CSV(<csvStr> string[, options map<string, string>])
支持引擎：SparkSQL
使用说明：返回csv字符串的schema。
返回类型：string
示例：
> SELECT schema_of_csv('1,abc');
 STRUCT<`_c0`: INT, `_c1`: STRING>
TO_CSV
函数语法：
TO_CSV(<expr> struct[, <options> map<string, string>])
支持引擎：SparkSQL
使用说明：返回具有给定结构值的csv字符串
返回类型：string
示例：
> SELECT to_csv(named_struct('a', 1, 'b', 2));
 1,2
> SELECT to_csv(named_struct('time', to_timestamp('2015-08-26', 'yyyy-MM-dd')), map('timestampFormat', 'dd/MM/yyyy'));
 26/08/2015
NGRAMS
函数语法：
NGRAMS(<a> array<array<string>>, <N> integer, <K> integer, <pf> integer)
支持引擎：Presto。
使用说明：返回一组标记化句子中的前 k 个 N-grams。
返回类型：array <struct <string,double>>。
CONTEXT_NGRAMS
函数语法：
CONTEXT_NGRAMS((array &lt;array &lt;string>>, array &lt;string>, int, int))
支持引擎：Presto
使用说明：给定一个contextual N-grams，从一组标记化的句子中返回前 k 个上下文 N-gram。
返回类型：array <struct <string, double>>
本页内容是否解决了您的问题？
您也可以联系销售或提交工单以寻求帮助。
是
否
文档反馈
tencent cloud

ASCII

BASE64

BIT_LENGTH

CHAR

CHR

CHAR_LENGTH

CHARACTER_LENGTH

CONCAT_WS

DECODE

ELT

ENCODE

FIND_IN_SET

FORMAT_NUMBER

FORMAT_STRING

INITCAP

INSTR

LCASE

LENGTH

LEVENSHTEIN

LIKE

LOWER

LOCATE

OCTET_LENGTH

LPAD

LTRIM

PARSE_URL

POSITION

PRINTF

REPEAT

REPLACE

OVERLAY

RPAD

RTRIM

SENTENCES

SOUNDEX

SPACE

SPLIT

SUBSTRING

SUBSTR

LEFT

RIGHT

SUBSTRING_INDEX

TRANSLATE

TRIM

BTRIM

UCASE

UNBASE64

UNHEX

UPPER

UUID

XPATH

XPATH_BOOLEAN

XPATH_DOUBLE

XPATH_NUMBER

XPATH_FLOAT

XPATH_INT

XPATH_LONG

XPATH_SHORT

XPATH_STRING

REGEXP_EXTRACT

REGEXP_EXTRACT_ALL

REGEXP_REPLACE

REGEXP_LIKE

REGEXP

CONCAT

STR_TO_MAP

REVERSE

RLIKE

FROM_CSV

SCHEMA_OF_CSV

TO_CSV

NGRAMS

CONTEXT_NGRAMS
