
# 字符串函数
本文介绍字符串函数的语法规则，包括参数解释、函数示例等。
#### 函数列表
表1字符串函数 
| 函数                                                                                                                                                                                         | 描述                                                                        |
|:---|:---|
| [lpad函数]                 | 在字符串的开头填充指定字符，直到指定长度后返回结果字符串。如果未指定填充字符，则使用" "进行填充。                        |
| [rpad函数]                 | 在字符串的结尾填充指定字符，直到指定长度后返回结果字符串。如果未指定填充字符，则使用" "进行填充。                        |
| [replace函数]              | 将字符串中的匹配字符串替换成指定的字符串，如果未指定替换字符串，则将匹配的字符串从原来的字符串中删除。                       |
| [reverse函数]              | 将字符串转换成反向顺序的字符串。                                                          |
| [repeat函数]               | 将字符串重复指定次数。                                                               |
| [contains_string函数]      | 判断字符串是否包含指定字符串。                                                           |
| [icontains_string函数]     | 判断字符串是否包含指定字符串，字符串不区分大小写。                                                 |
| [textcat函数]              | 将两个字符串拼接起来，返回拼接后的结果。                                                      |
| [btrim函数]                | 删除字符串左右两侧的空格。                                                             |
| [parse_long函数]           | 将字符串转换成基于指定基数的Long型，如果未指定基数，则基于十进制对原始字符串进行转换。                             |
| [split函数]                | 使用指定的分隔符拆分字符串，并返回子字符串的集合。如果设置了limit，则使用limit限制拆分字符串的数量。                   |
| [split_part函数]           | 使用指定的分隔符拆分字符串，并返回指定位置的字符串。如果拆分后指定的位置超过数组的长度，则返回""。                        |
| [split_to_map函数]         | 使用指定的第一个分隔符拆分字符串，然后使用指定的第二个分隔符第二次拆分字符串，返回第二次拆分后的结果。                       |
| [string_format函数]        | 返回以Java的String.format方式格式化的字符串。                                           |
| [strpos函数]               | 查询目标子字符串初次出现在字符串中的位置，如果目标子字符串未出现在字符串中，则返回0。                               |
| [substr函数]              | 使用起始位置和长度返回子字符串。如果没有长度参数，则返回从起始位置开始的整个字符串，同substring。                     |
| [substring函数]            | 使用起始位置和长度返回子字符串。如果没有长度参数，则返回从起始位置开始的整个字符串。                                |
| [length函数]               | 如果字符串表达式是字符数据类型，则返回输入的字符长度；否则，返回字符串表达式的字节长度（不小于位数除以8的最小整数）。               |
| [char_length函数]          | 与length函数功能一致，如果字符串表达式是字符数据类型，则返回输入的字符长度；否则，返回字符串表达式的字节长度（不小于位数除以8的最小整数）。 |
| [character_length函数]     | 与length函数功能一致。                                                            |
| [strlen函数]               | 与length函数功能一致。                                                            |
| [levenshtein_distance函数] | 计算两个字符串str1和str2之间的最小编辑距离。                                                |
| [normalize函数]            | 格式化字符串。                                                                   |
| [to_utf8函数]              | 将字符串转换为UTF-8编码格式。                                                         |
| [chr函数]                  | 将ascii值转换成字符。                                                             |
| [concat函数]            | 用于将多个参数拼接成一个字符串。                                                          |
   
 #### lpad函数
在字符串的开头填充指定字符，直到指定长度后返回结果字符串。如果未指定填充字符，则使用" "进行填充。
语法：lpad(str, len, lpadStr)
表2参数说明 
| 参数名称    | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | 类型     | 是否必选 |
|:---|:---|:---|:---|
| str     | 原始字符串。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | String | 是    |
| len     | 结果字符串的长度。 - 如果原始字符串的长度小于len，那么在字符串的开头填充指定的字符。  - 如果原始字符串的长度大于len，那么只返回字符串的len个字符。   | int    | 是    |
| lpadStr | 填充字符。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | String | 否    |
   
返回值类型：String类型
示例：SELECT LPAD('hello world', 10), LPAD('hello', 10, 'e')
表3查询分析结果 
| 类型  | 查询语句                    | 返回结果       |
|:---|:---|:---|
| 场景1 | LPAD('hello world', 10) | hello worl |
| 场景2 | LPAD('hello', 10, 'e')  | eeeeehello |
   
 #### rpad函数
在字符串的结尾填充指定字符，直到指定长度后返回结果字符串。如果未指定填充字符，则使用" "进行填充。
语法：rpad(str, len, rpadStr)
表4参数说明 
| 参数名称    | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | 类型      | 是否必选 |
|:---|:---|:---|:---|
| str     | 原始字符串。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | String  | 是    |
| len     | 结果字符串的长度。 - 如果原始字符串的长度小于len，那么在字符串的结尾填充指定的字符。  - 如果原始字符串的长度大于len，那么只返回字符串的len个字符。   | Integer | 是    |
| rpadStr | 填充字符。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | String  | 否    |
   
返回值类型：String类型
示例：SELECT RPAD('hello world', 10), RPAD('hello', 10, 'e')
表5查询分析结果 
| 类型  | 查询语句                    | 返回结果       |
|:---|:---|:---|
| 场景1 | RPAD('hello world', 10) | hello worl |
| 场景2 | RPAD('hello', 10, 'e')  | helloeeeee |
   
 #### replace函数
将字符串中的匹配字符串替换成指定的字符串，如果未指定替换字符串，则将匹配的字符串从原来的字符串中删除。
语法：replace(str, subStr, replaceStr)
表6参数说明 
| 参数名称       | 描述        | 类型     | 是否必选 |
|:---|:---|:---|:---|
| str        | 原始字符串。    | String | 是    |
| subStr     | 目标子字符串。   | String | 是    |
| replaceStr | 用于替换的字符串。 | String | 否    |
   
返回值类型：String类型
示例：SELECT REPLACE('hello world', 'o'), REPLACE('hello world', 'w', 'new w')
表7查询分析结果 
| 类型  | 查询语句                                 | 返回结果            |
|:---|:---|:---|
| 场景1 | REPLACE('hello world', 'o')          | hell wrld       |
| 场景2 | REPLACE('hello world', 'w', 'new w') | hello new world |
   
 #### reverse函数
将字符串转换成反向顺序的字符串。
语法：reverse(str)
表8参数说明 
| 参数名称 | 描述     | 类型     | 是否必选 |
|:---|:---|:---|:---|
| str  | 原始字符串。 | String | 是    |
   
返回值类型：String类型
示例：SELECT REVERSE('hello world')
表9查询分析结果 
| 类型 | 查询语句                   | 返回结果        |
|:---|:---|:---|
| 场景 | REVERSE('hello world') | dlrow olleh |
   
 #### repeat函数
将字符串重复指定次数。
语法：repeat(str, num)
表10参数说明 
| 参数名称 | 描述     | 类型      | 是否必选 |
|:---|:---|:---|:---|
| str  | 原始字符串。 | String  | 是    |
| num  | 重复次数   | Integer | 是    |
   
返回值类型：String类型
示例：SELECT REPEAT('hello world', 2), REPEAT('hello world', 0)
表11查询分析结果 
| 类型  | 查询语句                     | 返回结果                   |
|:---|:---|:---|
| 场景1 | REPEAT('hello world', 2) | hello worldhello world |
| 场景2 | REPEAT('hello world', 0) |                        |
   
 #### contains_string函数
判断字符串是否包含指定字符串。
语法：contains_string(str, containsStr)
表12参数说明 
| 参数名称        | 描述     | 类型     | 是否必选 |
|:---|:---|:---|:---|
| str         | 原始字符串。 | String | 是    |
| containsStr | 指定字符串。 | String | 是    |
   
返回值类型：Boolean类型
示例：SELECT CONTAINS_STRING('hello world', 'llo')
表13查询分析结果 
| 类型 | 查询语句                                  | 返回结果 |
|:---|:---|:---|
| 场景 | CONTAINS_STRING('hello world', 'llo') | true |
   
 #### icontains_string函数
判断字符串是否包含指定字符串，字符串不区分大小写。
语法：icontains_string(str, containsStr)
表14参数说明 
| 参数名称        | 描述     | 类型     | 是否必选 |
|:---|:---|:---|:---|
| str         | 原始字符串。 | String | 是    |
| containsStr | 指定字符串。 | String | 是    |
   
返回值类型：Boolean类型
示例：SELECT ICONTAINS_STRING('hello world', 'llo')
表15查询分析结果 
| 类型 | 查询语句                                   | 返回结果 |
|:---|:---|:---|
| 场景 | ICONTAINS_STRING('hello world', 'llo') | true |
   
 #### textcat函数
将两个字符串拼接起来，返回拼接后的结果。
语法：textcat(str1, str2)
表16参数说明 
| 参数名称 | 描述       | 类型     | 是否必选 |
|:---|:---|:---|:---|
| str1 | 待拼接字符串1。 | String | 是    |
| str2 | 待拼接字符串2。 | String | 是    |
   
返回值类型：String类型
示例：SELECT TEXTCAT('hello ', 'world')
表17查询分析结果 
| 类型 | 查询语句                       | 返回结果        |
|:---|:---|:---|
| 场景 | TEXTCAT('hello ', 'world') | hello world |
   
 #### btrim函数
删除字符串左右两侧的空格。
语法：btrim(str)
表18参数说明 
| 参数名称 | 描述     | 类型     | 是否必选 |
|:---|:---|:---|:---|
| str  | 原始字符串。 | String | 是    |
   
返回值类型：String类型
示例：SELECT BTRIM(' hello world ')
表19查询分析结果 
| 类型 | 查询语句                   | 返回结果        |
|:---|:---|:---|
| 场景 | BTRIM(' hello world ') | hello world |
   
 #### parse_long函数
将字符串转换成基于指定基数的Long型，如果未指定基数，则基于十进制对原始字符串进行转换。
语法：parse_long(str, radix)
表20参数说明 
| 参数名称  | 描述     | 类型      | 是否必选 |
|:---|:---|:---|:---|
| str   | 原始字符串。 | String  | 是    |
| radix | 基数。    | Integer | 否    |
   
返回值类型：Long类型
示例：SELECT PARSE_LONG('-1234', 8), PARSE_LONG('1234')
表21查询分析结果 
| 类型  | 查询语句                   | 返回结果 |
|:---|:---|:---|
| 场景1 | PARSE_LONG('-1234', 8) | -668 |
| 场景2 | PARSE_LONG('1234')     | 1234 |
   
 #### split函数
使用指定的分隔符拆分字符串，并返回子字符串的集合。如果设置了limit，则使用limit限制拆分字符串的数量。
语法：split(str, splitStr, limit)
表22参数说明 
| 参数名称     | 描述     | 类型      | 是否必选 |
|:---|:---|:---|:---|
| str      | 原始字符串。 | String  | 是    |
| splitStr | 分隔符。   | String  | 是    |
| limit    | 基数。    | Integer | 否    |
   
返回值类型：ARRAYS\<STRING\>类型
示例：SELECT SPLIT('helloworld', 'o'), SPLIT('helloworld', 'o', 2)
表23查询分析结果 
| 类型  | 查询语句                        | 返回结果                 |
|:---|:---|:---|
| 场景1 | SPLIT('helloworld','o' )    | \["hell","w","rld"\] |
| 场景2 | SPLIT('helloworld', 'o', 2) | \["hell","world"\]   |
   
 #### split_part函数
使用指定的分隔符拆分字符串，并返回指定位置的字符串。如果拆分后指定的位置超过数组的长度，则返回""。
语法：split_part(str, splitStr, position)
表24参数说明 
| 参数名称     | 描述           | 类型      | 是否必选 |
|:---|:---|:---|:---|
| str      | 原始字符串。       | String  | 是    |
| splitStr | 分隔符。         | String  | 是    |
| position | 需要返回的字符串的位置。 | Integer | 是    |
   
返回值类型：STRING类型
示例：SELECT SPLIT_PART('helloworld', 'o', 2), SPLIT_PART('helloworld', 'o', 4)
表25查询分析结果 
| 类型  | 查询语句                             | 返回结果 |
|:---|:---|:---|
| 场景1 | SPLIT_PART('helloworld','o', 2)  | w    |
| 场景2 | SPLIT_PART('helloworld', 'o', 4) |      |
   
 #### split_to_map函数
使用指定的第一个分隔符拆分字符串，然后使用指定的第二个分隔符第二次拆分字符串。返回第二次拆分后的结果。
语法：split_to_map(str, splitStr1, splitStr2)
表26参数说明 
| 参数名称      | 描述     | 类型     | 是否必选 |
|:---|:---|:---|:---|
| str       | 原始字符串。 | String | 是    |
| splitStr1 | 分隔符1。  | String | 是    |
| splitStr2 | 分隔符2。  | String | 是    |
   
返回值类型：ARRAY类型
示例：SELECT SPLIT_TO_MAP('upstream_response_time:123, request_time:456', ',', ':')
表27查询分析结果 
| 类型 | 查询语句                                                                   | 返回结果                                                   |
|:---|:---|:---|
| 场景 | SPLIT_TO_MAP('upstream_response_time:123, request_time:456', ',', ':') | {" request_time":"456","upstream_response_time":"123"} |
   
 #### string_format函数
返回以Java的String.format方式格式化的字符串。
语法：string_format(str, Object... args)
表28参数说明 
| 参数名称 | 描述       | 类型                                 | 是否必选 |
|:---|:---|:---|:---|
| str  | 原始字符串。   | String                             | 是    |
| args | 输出的时间格式。 | String/Integer/Long/Boolean/Double | 是    |
   
返回值类型：String类型
示例：SELECT STRING_FORMAT('My name is %s and I am %d years old.', 'name', age)
表29查询分析结果 
| 类型 | 查询语句                                                             | 返回结果                                  |
|:---|:---|:---|
| 场景 | STRING_FORMAT('My name is %s and I am %d years old.', 'Tom', 25) | My name is Tom and I am 25 years old. |
   
- %d：Output integer.
- %f：Output floating point number.
- %s：Output character string.
- %n：Output newline character.
- %c：Output Characters.
- %b：Output bool type.
- %e：Output Exponential Type.
- %tc：Output Date and time information.
- %tF：Output format is YYYY-MM-DD.
- %tr：Output in HH:MM:SS PM format.
 
 #### strpos函数
查询目标子字符串初次出现在字符串中的位置，如果目标子字符串未出现在字符串中，则返回0。
语法：strpos(str, subStr)
表30参数说明 
| 参数名称   | 描述      | 类型     | 是否必选 |
|:---|:---|:---|:---|
| str    | 原始字符串。  | String | 是    |
| subStr | 目标子字符串。 | String | 是    |
   
返回值类型：Integer类型
示例：SELECT STRPOS('hello world', 'llo'), STRPOS('llo', 'hello world')
表31查询分析结果 
| 类型  | 查询语句                         | 返回结果 |
|:---|:---|:---|
| 场景1 | STRPOS('hello world', 'llo') | 3    |
| 场景2 | STRPOS('llo', 'hello world') | 0    |
   
 #### substr函数
使用起始位置和长度返回子字符串。如果没有长度参数，则返回从起始位置开始的整个字符串，同substring。
语法：substr(str, start, length)
表32参数说明 
| 参数名称   | 描述                  | 类型      | 是否必选 |
|:---|:---|:---|:---|
| str    | 原始字符串               | String  | 是    |
| start  | 函数用于返回字符串中指定位置的子字符串 | Integer | 是    |
| length | 子字符串的长度             | Integer | 否    |
   
返回值类型：String类型
示例：SELECT SUBSTR('helloworld', 5), SUBSTR('helloworld', 5, 3)
表33查询分析结果 
| 类型  | 查询语句                        | 返回结果   |
|:---|:---|:---|
| 场景1 | SUBSTR ('helloworld', 5)    | oworld |
| 场景2 | SUBSTR ('helloworld', 5, 3) | owo    |
   
 #### substring函数
使用起始位置和长度返回子字符串。如果没有长度参数，则返回从起始位置开始的整个字符串。
语法：substring(str, start, length)
表34参数说明 
| 参数名称   | 描述                | 类型      | 是否必选 |
|:---|:---|:---|:---|
| str    | 原始字符串。            | String  | 是    |
| start  | 开始提取子字符串的位置，从1开始。 | Integer | 是    |
| length | 子字符串的长度。          | Integer | 否    |
   
返回值类型：String类型
示例：SELECT SUBSTRING('helloworld', 5), SUBSTRING('helloworld', 5, 3)
表35查询分析结果 
| 类型  | 查询语句                          | 返回结果   |
|:---|:---|:---|
| 场景1 | SUBSTRING('helloworld', 5)    | oworld |
| 场景2 | SUBSTRING('helloworld', 5, 3) | owo    |
   
 #### length函数
如果字符串表达式是字符数据类型，则返回输入的字符长度；否则，返回字符串表达式的字节长度（不小于位数除以8的最小整数）。
语法：length(str)
表36参数说明 
| 参数名称 | 描述     | 类型     | 是否必选 |
|:---|:---|:---|:---|
| str  | 原始字符串。 | String | 是    |
   
返回值类型：Integer类型
示例：SELECT LENGTH('HELLO WORLD')
表37查询分析结果 
| 类型 | 查询语句                  | 返回结果 |
|:---|:---|:---|
| 场景 | LENGTH('HELLO WORLD') | 11   |
   
 #### char_length函数
与length函数功能一致，如果字符串表达式是字符数据类型，则返回输入的字符长度；否则，返回字符串表达式的字节长度（不小于位数除以8的最小整数）。
语法：char_length(str)
表38参数说明 
| 参数名称 | 描述    | 类型     | 是否必选 |
|:---|:---|:---|:---|
| str  | 原始字符串 | String | 是    |
   
返回值类型：Integer类型
示例：SELECT CHAR_LENGTH('HELLO WORLD')
表39查询分析结果 
| 类型 | 查询语句                       | 返回结果 |
|:---|:---|:---|
| 场景 | CHAR_LENGTH('HELLO WORLD') | 11   |
   
 #### character_length函数
与length函数功能一致。
语法：character_length(str)
表40参数说明 
| 参数名称 | 描述     | 类型     | 是否必选 |
|:---|:---|:---|:---|
| str  | 原始字符串。 | String | 是    |
   
返回值类型：Integer类型
示例：SELECT CHARACTER_LENGTH('HELLO WORLD')
表41查询分析结果 
| 类型 | 查询语句                            | 返回结果 |
|:---|:---|:---|
| 场景 | CHARACTER_LENGTH('HELLO WORLD') | 11   |
   
 #### strlen函数
与length函数功能一致。
语法：strlen(str)
表42参数说明 
| 参数名称 | 描述     | 类型     | 是否必选 |
|:---|:---|:---|:---|
| str  | 原始字符串。 | String | 是    |
   
返回值类型：Integer类型
示例：SELECT STRLEN('HELLO WORLD')
表43查询分析结果 
| 类型 | 查询语句                  | 返回结果 |
|:---|:---|:---|
| 场景 | STRLEN('HELLO WORLD') | 11   |
   
 #### levenshtein_distance函数
计算两个字符串str1和str2之间的最小编辑距离。
语法：levenshtein_distance(str1, str2)
表44参数说明 
| 参数名称 | 描述      | 类型     | 是否必选 |
|:---|:---|:---|:---|
| str1 | 原始字符串1。 | String | 是    |
| str2 | 原始字符串2。 | String | 是    |
   
返回值类型：Integer类型
示例：SELECT LEVENSHTEIN_DISTANCE('horse', 'ros')
表45查询分析结果 
| 类型 | 查询语句                                 | 返回结果 |
|:---|:---|:---|
| 场景 | LEVENSHTEIN_DISTANCE('horse', 'ros') | 3    |
   
 #### normalize函数
格式化字符串str。
- 使用NFC格式来格式化字符串str。 语法：normalize(str)
  

- 使用给定格式来格式化字符串str，支持的格式有NFC，NFD，NFKC，NFKD。 语法：normalize(str, form)
  
表46参数说明 
| 参数名称 | 描述     | 类型     | 是否必选 |
|:---|:---|:---|:---|
| str  | 原始字符串。 | String | 是    |
| form | 格式化类型。 | String | 否    |
   
返回值类型：String类型
示例：SELECT NORMALIZE('schön'), NORMALIZE('Henry \\u2163', 'nfd')
表47查询分析结果 
| 类型  | 查询语句                              | 返回结果    |
|:---|:---|:---|
| 场景1 | NORMALIZE('schön')                | schön   |
| 场景2 | NORMALIZE('Henry \\u2163', 'nfd') | Henry Ⅳ |
   
 #### to_utf8函数
将字符串转换为UTF-8编码格式。
语法：to_utf8(str)
表48参数说明 
| 参数名称 | 描述     | 类型     | 是否必选 |
|:---|:---|:---|:---|
| str1 | 原始字符串1 | String | 是    |
| str2 | 原始字符串2 | String | 是    |
   
返回值类型：Integer类型
示例：SELECT TO_UTF8('%')
表49查询分析结果 
| 类型 | 查询语句         | 返回结果 |
|:---|:---|:---|
| 场景 | TO_UTF8('%') | JQ== |
   
 #### chr函数
将ascii值转换成字符。
语法：chr(ascii)
表50参数说明 
| 参数名称  | 描述     | 类型      | 是否必选 |
|:---|:---|:---|:---|
| ascii | ascii码 | Integer | 是    |
   
返回值类型：String类型
示例：SELECT CHR(99)
表51查询分析结果 
| 类型 | 查询语句    | 返回结果 |
|:---|:---|:---|
| 场景 | CHR(99) | c    |
   
 #### concat函数
用于将多个参数拼接成一个字符串。
语法：concat(x, y...)
表52参数说明 
| 参数名称   | 描述    | 类型     | 是否必选 |
|:---|:---|:---|:---|
| x,y... | 原始字段。 | string | 是    |
   
返回值类型：String类型
示例：select concat('1','+','1')
表53查询分析结果 
| 类型 | 查询语句                | 返回结果 |
|:---|:---|:---|
| 场景 | concat('1','+','1') | 1+1  |
   
