
# 字符串函数概览
DLI所支持的字符函数如[字符串函数]所示。
 表1字符串函数 
| 函数                                                                                                   | 命令格式                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | 返回值          | 功能简介                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|:---|:---|:---|:---|
| [ascii](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_ascii.html)                       | ascii(string \<str\>)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | BIGINT       | 返回字符串中首字符的数字值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| [concat](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_concat.html)                     | concat(array\<T\> \<a\>, array\<T\> \<b\>\[,...\])，concat(string \<str1\>, string \<str2\>\[,...\])                                                                                                                                                                                                                                                                                                                                                                                                                                      | ARRAY或STRING | 连接多个字符串，合并为一个字符串，可以接受任意数量的输入字符串。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| [concat_ws](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_concat_ws.html)               | concat_ws(string \<separator\>, string \<str1\>, string \<str2\>\[,...\])，concat_ws(string \<separator\>, array\<string\> \<a\>)                                                                                                                                                                                                                                                                                                                                                                                                         | ARRAY或STRUCT | 连接多个字符串，字符串之间以指定的分隔符分隔。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [char_matchcount](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_char_matchcount.html)   | char_matchcount(string \<str1\>, string \<str2\>)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | BIGINT       | 计算str1中有多少个字符出现在str2中。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| [encode](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_encode.html)                     | encode(string \<str\>, string \<charset\>)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | BINARY       | 将str按照charset格式进行编码。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [find_in_set](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_find_in_set.html)           | find_in_set(string \<str1\>, string \<str2\>)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | BIGINT       | 查找字符串str1在以逗号（,）分隔的字符串str2中的位置，从1开始计数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| [get_json_object](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_get_json_object.html)   | get_json_object(string \<json\>, string \<path\>)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | STRING       | 根据所给路径对json对象进行解析，当json对象非法时将返回NULL。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [instr](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_instr.html)                       | instr(string \<str\>, string \<substr\>)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | INT          | 返回substr在str中最早出现的下标。当参数中出现NULL时，返回NULL，当str中不存在substr时返回0，注意下标从1开始。                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [instr1](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_instr1.html)                     | instr1(string \<str1\>, string \<str2\>\[, bigint \<start_position\>\[, bigint \<nth_appearance\>\]\])                                                                                                                                                                                                                                                                                                                                                                                                                                   | BIGINT       | instr1函数用于计算子串str2在字符串str1中的位置。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [initcap](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_initcap.html)                   | initcap(string A)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | STRING       | 将文本字符串转换成首字母大写其余字母小写的形式。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| [keyvalue](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_keyvalue.html)                 | keyvalue(string \<str\>,\[string \<split1\>,string \<split2\>,\] string \<key\>)                                                                                                                                                                                                                                                                                                                                                                                                                                                         | STRING       | 用于计算将字符串str按照split1进行切分，并按split2将每组变成Key-Value对，返回key所对应的Value。                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [length](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_length.html)                     | length(string \<str\>)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | BIGINT       | 返回字符串的长度。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| [lengthb](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_lengthb.html)                   | lengthb(string \<str\>)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | STRING       | 计算字符串str以字节为单位的长度。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [levenshtein](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_levenshtein.html)           | levenshtein(string A, string B)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | INT          | 返回两个字符串之间的Levenshtein距离，如levenshtein('kitten','sitting') =3。                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [locate](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_locate.html)                     | locate(string \<substr\>, string \<str\>\[, bigint \<start_pos\>\])                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | BIGINT       | 用于在str中查找substr的位置。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| [lower/lcase](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_lower_lcase.html)           | lower(string A) ，lcase(string A)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | STRING       | 将文本字符串转换成字母全部小写的形式。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| [lpad](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_lpad.html)                         | lpad(string \<str1\>, int \<length\>, string \<str2\>)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | STRING       | 用于返回指定长度的字符串，给定字符串str1长度小于指定长度length时，由指定字符str2从左侧填补。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| [ltrim](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_ltrim.html)                       | ltrim(\[\<trimChars\>,\] string \<str\>)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | STRING       | 删除字符串左边的空格，其他的空格保留。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| [parse_url](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_parse_url.html)               | parse_url(string urlString, string partToExtract \[, string keyToExtract\])                                                                                                                                                                                                                                                                                                                                                                                                                                                              | STRING       | 返回给定URL的指定部分，partToExtract的有效值包括HOST，PATH， QUERY， REF， PROTOCOL， AUTHORITY，FILE和USERINFO。 例如：parse_url('http://facebook.com/path1/p.php?k1=v1\&k2=v2#Ref1', 'HOST') 返回 'facebook.com'.。 当第二个参数为QUERY时，可以使用第三个参数提取特定参数的值，例如： parse_url('http://facebook.com/path1/p.php?k1=v1\&k2=v2#Ref1', 'QUERY', 'k1') 返回'v1'。 |
| [printf](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_printf.html)                     | printf(String format, Obj... args)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | STRING       | 将输入按特定格式打印输出。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| [regexp_count](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_regexp_count.html)         | regexp_count(string \<source\>, string \<pattern\>\[, bigint \<start_position\>\])                                                                                                                                                                                                                                                                                                                                                                                                                                                       | BIGINT       | 用于计算source中从start_position位置开始，匹配指定pattern的子串数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [regexp_extract](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_regexp_extract.html)     | regexp_extract(string \<source\>, string \<pattern\>\[, bigint \<groupid\>\])                                                                                                                                                                                                                                                                                                                                                                                                                                                            | STRING       | 用于将字符串source按照pattern的分组规则进行字符串匹配，返回第groupid个组匹配到的字符串内容。                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| [replace](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_replace.html)                   | replace(string \<str\>, string \<old\>, string \<new\>)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | STRING       | 将字符串中与指定字符串匹配的子串替换为另一字符串。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| [regexp_replace](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_regexp_replace.html)     | - 适用于Spark2.4.5：regexp_replace(string \<source\>, string \<pattern\>, string \<replace_string\>)  - 适用于Spark3.3.1：regexp_replace(string \<source\>, string \<pattern\>, string \<replace_string\>\[, bigint \<occurrence\>\])   | STRING       | - 适用于Spark2.4.5：用于将source字符串中第occurrence次匹配pattern的子串，以及之后匹配pattern的子串，全都替换成指定字符串replace_string后，返回结果字符  - 适用于Spark3.3.1：用于将source字符串中第occurrence次匹配pattern的子串，以及之后匹配pattern的子串，全都替换成指定字符串replace_string后，返回结果字符                 |
| [regexp_replace1](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_regexp_replace1.html)   | regexp_replace1(string \<source\>, string \<pattern\>, string \<replace_string\>\[, bigint \<occurrence\>\])                                                                                                                                                                                                                                                                                                                                                                                                                             | STRING       | 将source字符串中第occurrence次匹配pattern的子串，替换成指定字符串replace_string后，返回结果字符串。                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [regexp_instr](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_regexp_instr.html)         | regexp_instr(string \<source\>, string \<pattern\>\[,bigint \<start_position\>\[, bigint \<occurrence\>\[, bigint \<return_option\>\]\]\])                                                                                                                                                                                                                                                                                                                                                                                               | BIGINT       | 用于计算字符串source从start_position开始，与pattern第occurrence次匹配的子串的起始或结束位置。                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [regexp_substr](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_regexp_substr.html)       | regexp_substr(string \<source\>, string \<pattern\>\[, bigint \<start_position\>\[, bigint \<occurrence\>\]\])                                                                                                                                                                                                                                                                                                                                                                                                                           | STRING       | 用于计算从start_position位置开始，source中第occurrence次匹配指定pattern的子串。                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| [repeat](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_repeat.html)                     | repeat(string \<str\>, bigint \<n\>)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | STRING       | 重复N次字符串。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| [reverse](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_reverse.html)                   | reverse(string \<str\>)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | STRING       | 返回倒序字符串。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| [rpad](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_rpad.html)                         | rpad(string \<str1\>, int \<length\>, string \<str2\>)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | STRING       | 用于将字符串str2将字符串str1向右补足到length位。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [rtrim](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_rtrim.html)                       | rtrim(\[\<trimChars\>, \]string \<str\>)， rtrim(trailing \[\<trimChars\>\] from \<str\>)                                                                                                                                                                                                                                                                                                                                                                                      | STRING       | 删除字符串右边的空格，其他的空格保留。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| [soundex](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_soundex.html)                   | soundex(string \<str\>)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | STRING       | 从str返回一个soundex字符串，如soundex('Miller')= M460。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [space](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_space.html)                       | space(bigint \<n\>)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | STRING       | 返回指定数量的空格。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| [substr/substring](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_substr_substring.html) | substr(string \<str\>, bigint \<start_position\>\[, bigint \<length\>\]) ，substring(string \<str\>, bigint \<start_position\>\[, bigint \<length\>\])                                                                                                                                                                                                                                                                                                                                                                                    | STRING       | 用于返回字符串str从start_position开始，长度为length的子串。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| [substring_index](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_substring_index.html)   | substring_index(string \<str\>, string \<separator\>, int \<count\>)                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | STRING       | 用于截取字符串str第count个分隔符之前的字符串。如果count为正，则从左边开始截取。如果count为负，则从右边开始截取。                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [split_part](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_split_part.html)             | split_part(string \<str\>, string \<separator\>, bigint \<start\>\[, bigint \<end\>\])                                                                                                                                                                                                                                                                                                                                                                                                                                                   | STRING       | 用于依照分隔符separator拆分字符串str，返回从start部分到end部分的子串（闭区间）。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [translate](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_translate.html)               | translate(string\|char\|varchar input, string\|char\|varchar from, string\|char\|varchar to)                                                                                                                                                                                                                                                                                                                                                                                                                                             | STRING       | 将input字符串中的所出现的字符或者字符串from用字符或者字符串to替换。例如：将abcde中的bcd替换成BCD，translate("abcde", "bcd", "BCD")                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [trim](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_trim.html)                         | trim(\[\<trimChars\>,\]string \<str\>)， trim(\[BOTH\] \[\<trimChars\>\] from \<str\>)                                                                                                                                                                                                                                                                                                                                                                                          | STRING       | 删除字符串两端的空格，字符之间的空格保留。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| [upper/ucase](https://support.huaweicloud.com/sqlref-spark-dli/dli_spark_upper_ucase.html)           | upper(string A) ，ucase(string A)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | STRING       | 将文本字符串转换成字母全部大写的形式。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
   
