内置字符串函数¶

本文介绍 NebulaGraph 支持的字符串函数。

注意事项¶

字符串的表示方式为用双引号或单引号包裹。

和 SQL 一样，nGQL 的字符索引（位置）从1开始。但是 C 语言的字符索引是从0开始的。

strcasecmp()¶

strcasecmp() 比较两个字符串（不区分大小写）。

语法：strcasecmp(<string_a>,<string_b>)

string_a、string_b：待比较的字符串。

返回类型：int。

当 string_a = string_b 时，返回 0，当 string_a > string_b 是，返回大于 0 的数，当 string_a < string_b 时，返回小于 0 的数。

示例：

nebula> RETURN strcasecmp("a","aa");
+----------------------+
| strcasecmp("a","aa") |
+----------------------+
| -97                  |
+----------------------+

lower() 和 toLower()¶

lower() 和 toLower() 都可以返回指定字符串的小写形式。

语法：lower(<string>)、toLower(<string>)

string：指定的字符串。

返回类型：string。

示例：

nebula> RETURN lower("Basketball_Player");
+----------------------------+
| lower("Basketball_Player") |
+----------------------------+
| "basketball_player"        |
+----------------------------+

upper() 和 toUpper()¶

upper() 和 toUpper() 都可以返回指定字符串的大写形式。

语法：upper(<string>)、toUpper(<string>)

string：指定的字符串。

返回类型：string。

示例：

nebula> RETURN upper("Basketball_Player");
+----------------------------+
| upper("Basketball_Player") |
+----------------------------+
| "BASKETBALL_PLAYER"        |
+----------------------------+

length()¶

length() 返回：

指定字符串的长度，单位：字节。
路径的长度，单位：跳。

语法：length({<string>|<path>})

string：指定的字符串。
path：指定的路径，使用变量表示。
返回类型：int。

示例：

nebula> RETURN length("basketball");
+----------------------+
| length("basketball") |
+----------------------+
| 10                   |
+----------------------+

nebula> MATCH p=(v:player{name:"Tim Duncan"})-->(v2) return length(p);
+-----------+
| length(p) |
+-----------+
| 1         |
| 1         |
| 1         |
+-----------+

trim()¶

trim() 删除指定字符串头部和尾部的空格。

语法：trim(<string>)

string：指定的字符串。

返回类型：string。

示例：

nebula> RETURN trim(" basketball player ");
+-----------------------------+
| trim(" basketball player ") |
+-----------------------------+
| "basketball player"         |
+-----------------------------+

ltrim()¶

ltrim() 删除字符串头部的空格。

语法：ltrim(<string>)

string：指定的字符串。

返回类型：string。

示例：

nebula> RETURN ltrim(" basketball player ");
+------------------------------+
| ltrim(" basketball player ") |
+------------------------------+
| "basketball player "         |
+------------------------------+

rtrim()¶

rtrim() 删除字符串尾部的空格。

语法：rtrim(<string>)

string：指定的字符串。

返回类型：string。

示例：

nebula> RETURN rtrim(" basketball player ");
+------------------------------+
| rtrim(" basketball player ") |
+------------------------------+
| " basketball player"         |
+------------------------------+

left()¶

left() 返回指定字符串头部若干个字符组成的子字符串。

语法：left(<string>,<count>)

string：指定的字符串。

count：指定从头部开始的字符数量。如果count超过字符串的长度，则返回字符串本身。

返回类型：string。

示例：

nebula> RETURN left("basketball_player",6);
+-----------------------------+
| left("basketball_player",6) |
+-----------------------------+
| "basket"                    |
+-----------------------------+

right()¶

right() 返回指定字符串尾部若干个字符组成的子字符串。

语法：right(<string>,<count>)

string：指定的字符串。

count：指定从尾部开始的字符数量。如果count超过字符串的长度，则返回字符串本身。

返回类型：string。

示例：

nebula> RETURN right("basketball_player",6);
+------------------------------+
| right("basketball_player",6) |
+------------------------------+
| "player"                     |
+------------------------------+

lpad()¶

lpad() 在指定字符串的头部填充字符串至指定长度，并返回结果字符串。

语法：lpad(<string>,<count>,<letters>)

string：指定的字符串。

count：指定从尾部开始将要返回的字符数量。如果count少于string字符串的长度，则只返回string字符串从前到后的count个字符。

letters：从头部填充的字符串。

返回类型：string。

示例：

nebula> RETURN lpad("abcd",10,"b");
+---------------------+
| lpad("abcd",10,"b") |
+---------------------+
| "bbbbbbabcd"        |
+---------------------+

nebula> RETURN lpad("abcd",3,"b");
+--------------------+
| lpad("abcd",3,"b") |
+--------------------+
| "abc"              |
+--------------------+

rpad()¶

rpad() 在指定字符串的尾部填充字符串至指定长度，并返回结果字符串。

语法：rpad(<string>,<count>,<letters>)

string：指定的字符串。

count：指定从头部开始将要返回的字符数量。如果count少于string字符串的长度，则只返回string字符串从前到后的count个字符。

letters：从尾部填充的字符串。

返回类型：string。

示例：

nebula> RETURN rpad("abcd",10,"b");
+---------------------+
| rpad("abcd",10,"b") |
+---------------------+
| "abcdbbbbbb"        |
+---------------------+

nebula> RETURN rpad("abcd",3,"b");
+--------------------+
| rpad("abcd",3,"b") |
+--------------------+
| "abc"              |
+--------------------+

substr() 和 substring()¶

substr() 和 substring() 从指定字符串的指定位置开始（不包括开始位置的字符），提取后面的若干个字符，组成新的字符串并返回。

语法：substr(<string>,<pos>,<count>)、substring(<string>,<pos>,<count>)

string：指定的字符串。

pos：指定开始的位置，即字符索引，数据类型为 int。

count：指定从开始位置往后提取的字符数量。

返回类型：string。

`substr()`和`substring()`的返回说明¶

如果pos为 0，表示从指定字符串头部开始提取（包括第一个字符）。

如果pos大于最大字符索引，则返回空字符串。

如果pos是负数，则返回BAD_DATA。

如果省略count，则返回从pos位置开始到字符串末尾的子字符串。

如果count为 0，则返回空字符串。

使用NULL作为任何参数会出现错误。

openCypher 兼容性

在 openCypher 中，如果字符串a为null，会返回null。

示例：

nebula> RETURN substr("abcdefg",2,4);
+-----------------------+
| substr("abcdefg",2,4) |
+-----------------------+
| "cdef"                |
+-----------------------+

nebula> RETURN substr("abcdefg",0,4);
+-----------------------+
| substr("abcdefg",0,4) |
+-----------------------+
| "abcd"                |
+-----------------------+

nebula> RETURN substr("abcdefg",2);
+---------------------+
| substr("abcdefg",2) |
+---------------------+
| "cdefg"             |
+---------------------+

reverse()¶

reverse() 逆序返回指定的字符串。

语法：reverse(<string>)

string：指定的字符串。

返回类型：string。

示例：

nebula> RETURN reverse("abcdefg");
+--------------------+
| reverse("abcdefg") |
+--------------------+
| "gfedcba"          |
+--------------------+

replace()¶

replace() 将指定字符串中的子字符串 a 替换为字符串 b。

语法：replace(<string>,<substr_a>,<string_b>)

string：指定的字符串。

substr_a：子字符串 a。

string_b：字符串 b。

返回类型：string。

示例：

nebula> RETURN replace("abcdefg","cd","AAAAA");
+---------------------------------+
| replace("abcdefg","cd","AAAAA") |
+---------------------------------+
| "abAAAAAefg"                    |
+---------------------------------+

split()¶

split() 将子字符串 b 识别为分隔符，分隔指定字符串，并返回分隔后的字符串列表。

语法：split(<string>,<substr>)

string：指定的字符串。

substr：子字符串 b。

返回类型：list。

示例：

nebula> RETURN split("basketballplayer","a");
+-------------------------------+
| split("basketballplayer","a") |
+-------------------------------+
| ["b", "sketb", "llpl", "yer"] |
+-------------------------------+

concat()¶

concat() 返回所有参数连接成的字符串。

语法：concat(<string1>,<string2>,...)

函数至少需要两个或以上字符串参数。如果字符串参数只有一个，则返回该字符串参数本身。

如果任何一个的字符串参数为 NULL，则 concat() 函数返回值为NULL。

返回类型：string。

示例：

//连接 1，2，3
nebula> RETURN concat("1","2","3") AS r;
+-------+
| r     |
+-------+
| "123" |
+-------+

//字符串参数有 NULL
nebula> RETURN concat("1","2",NULL) AS r;
+----------+
| r        |
+----------+
| __NULL__ |
+----------+

nebula> GO FROM "player100" over follow \
        YIELD concat(src(edge), properties($^).age, properties($$).name, properties(edge).degree) AS A;
+------------------------------+
| A                            |
+------------------------------+
| "player10042Tony Parker95"   |
| "player10042Manu Ginobili95" |
+------------------------------+

concat_ws()¶

concat_ws() 返回用分隔符（separator）连接的所有字符串。

语法：concat_ws(<separator>,<string1>,<string2>,... )

函数至少需要两个或以上字符串参数。

如果分隔符为NULL时，concat_ws()函数才返回NULL。

如果分隔符不为NULL，字符串参数只有一个，则返回该字符串参数本身。

字符串参数存在NULL值时，忽略NULL值，继续连接下一个参数。

示例：

//分隔符为 +，连接 a，b，c。
nebula> RETURN concat_ws("+","a","b","c") AS r;
+---------+
| r       |
+---------+
| "a+b+c" |
+---------+

//分隔符为 NULL。
neubla> RETURN concat_ws(NULL,"a","b","c") AS r;
+----------+
| r        |
+----------+
| __NULL__ |
+----------+

//分隔符为 +，字符串参数有 NULL。
nebula> RETURN concat_ws("+","a",NULL,"b","c") AS r;
+---------+
| r       |
+---------+
| "a+b+c" |
+---------+

//分隔符为+。字符串参数只有一个
nebula> RETURN concat_ws("+","a") AS r;
+-----+
| r   |
+-----+
| "a" |
+-----+

nebula> GO FROM "player100" over follow \
        YIELD concat_ws(" ",src(edge), properties($^).age, properties($$).name, properties(edge).degree) AS A;
+---------------------------------+
| A                               |
+---------------------------------+
| "player100 42 Tony Parker 95"   |
| "player100 42 Manu Ginobili 95" |
+---------------------------------+

extract()¶

extract() 从指定字符串中提取符合正则表达式的子字符串。

语法：extract(<string>,"<regular_expression>")

string：指定的字符串。
regular_expression：正则表达式。
返回类型：list。

示例：

nebula> MATCH (a:player)-[b:serve]-(c:team{name: "Lakers"}) \
        WHERE a.player.age > 45 \
        RETURN extract(a.player.name, "\\w+") AS result;
+----------------------------+
| result                     |
+----------------------------+
| ["Shaquille", "O", "Neal"] |
+----------------------------+

nebula> MATCH (a:player)-[b:serve]-(c:team{name: "Lakers"}) \
        WHERE a.player.age > 45 \
        RETURN extract(a.player.name, "hello") AS result;
+--------+
| result |
+--------+
| []     |
+--------+

json_extract() 函数¶

json_extract() 将指定 JSON 字符串转换为 map 类型。

语法：extract(<string>)

string：指定字符串，为 JSON 格式。
返回类型：map。

Caution

目前仅支持 Bool、Double、Int、String 和 NULL 类型数据。
仅支持深度为 1 的 Map 嵌套，如果嵌套深度为 2 及以上，嵌套项保留为空。

示例：

nebula> YIELD json_extract('{"a": 1, "b": {}, "c": {"d": true}}') AS result;
+-----------------------------+
| result                      |
+-----------------------------+
| {a: 1, b: {}, c: {d: true}} |
+-----------------------------+

最后更新: September 4, 2023