CQL（Cypher查询语言）

目录

CQL 简介

CQL 代表 Cypher 查询语言。 像 Oracle 数据库具有查询语言 SQL，Neo4j 具有 CQL 作为查询语言。
Neo4j CQL

  • 它是 Neo4j 图形数据库的查询语言。
  • 它是一种声明性模式匹配语言
  • 它遵循 SQL 语法。
  • 它的语法是非常简单且人性化、可读的格式。
    如 Oracle SQL
  • Neo4j CQL 已命令来执行数据库操作。
  • Neo4j CQL 支持多个子句像在哪里，顺序等，以非常简单的方式编写非常复杂的查询。
  • NNeo4j CQL 支持一些功能，如字符串，Aggregation.In 加入他们，它还支持一些关系功能。

命令/条款

常用的 Neo4j CQL 命令/条款如下：

S.No. CQL命令/条 用法
1。 CREATE 创建 创建节点，关系和属性
2。 MATCH 匹配 检索有关节点，关系和属性数据
3。 RETURN 返回 返回查询结果
4。 WHERE 哪里 提供条件过滤检索数据
5。 DELETE 删除 删除节点和关系
6。 REMOVE 移除 删除节点和关系的属性
7。 ORDER BY 以…排序 排序检索数据
8。 SET 组 添加或更新标签
  • 命令使用对大小写不敏感；
  • 命令原称为 Clauses，直译为子句/从句/条款，介于 Clauses 下会有其子一级语句，若称 Clauses 为子句，则子一级语句会被称为子子句，故将 Clauses 译为命令，其子一级语句称子句；

函数

以下是常用的 Neo4j CQL 函数：

S.No. 定制列表功能 用法
1。 String 字符串 它们用于使用 String 字面量。
2。 Aggregation 聚合 它们用于对 CQL 查询结果执行一些聚合操作。
3。 Relationship 关系 他们用于获取关系的细节，如startnode，endnode等。

数据类型

这些数据类型与 Java 语言类似。 它们用于定义节点或关系的属性

Neo4j CQL支持以下数据类型：

S.No. CQL数据类型 用法
1. boolean 用于表示布尔文字：true，false。
2. byte 用于表示 8 位整数。
3. short 用于表示 16 位整数。
4. int 用于表示 32 位整数。
5. long 用于表示 64 位整数。
6. float 用于表示 32 位浮点数。
7. double 用于表示 64 位浮点数。
8. char 用于表示 16 位字符。
9. String 用于表示字符串。
  • neo4j 中String 支持 Unicode 第零平面中的字符；
  • neo4j 中String 类型对不在第零平面的 Unicode 字符不完全能支持，存在不确定的问题，如 emoji 等；
  • neo4j 不自带内置的数据类型判断函数，需要使用 APOC 拓展包

结构类型

类型 含义
Node 节点
Relationship 关系
Path 链路
区别于文件保存的路径，此处称链路
指的是节点与连接节点的关系所共同组成的概念）

复合结构

类 含义
List 列表，序列，数组
Map 键值对

其他

之外，neo4j 支持时间点、时间段和坐标数据类型并提供它们的运算和函数

变量命名

  • 命名应以字母开头，包括非英语字母；
  • 命名不能以数字开头；
  • 命名不能以符号开头；
  • 命名长度最高支持 65535(2^16 - 1)或 65534，取决于 neo4j 的版本；
  • 命名对大小写敏感；
  • 命名中的空格会被自动忽略；

命名空间与作用域

  • 同一查询语句中，节点标签、关系类型、属性名可以重复使用同一名称，如：
CREATE (a:a {a:'a'})-[r:a]->(b:a {a: 'a'})
  • 统一查询语句中，节点名、关系名不能使用同一名称，如：
CREATE (a)-[a]->(b)
  • 同一作用域内，同一名称在同一命名空间内，可重复使用，如：
MATCH(s1:student)

MATCH(s2:student) WHERE s2.name<>s1.name 

CREATE(s1)-[:classmates]->(s2)

操作符

操作符类型 操作符
聚集操作 DISTINCT
成员变量操作 . ：用于访问静态成员变量
[] ：用于访问动态成员变量
= ：用于整体成员变量修改，未指定的成员变量会被清空为 null
+= ：用于改变指定的成员变量
数学运算符 +,-,*,/,%,^
比较运算符 =,<>,<,>,<=,>=,IS NULL,NOT,NULL
字符串匹配符 STARTS WITH,ENDS WITH,CONTAINS
布尔运算 AND,OR,XOR,NOT
字符串运算 + ：关联字符串
=~ ：正则匹配
时间运算 +和- ：用于时间之间加减
*和/ ：用于时间和数量之间
键值对操作 . ：用于访问值
[] ：用于访问动态值
列表操作 + ：关联
IN ：查找列表中是否存在该元素
[] ：动态地访问元素
  • 动态访问
CREATE
  (a:Restaurant {name: 'Hungry Jo', rating_hygiene: 10, rating_food: 7}),
  (b:Restaurant {name: 'Buttercup Tea Rooms', rating_hygiene: 5, rating_food: 6}),
  (c1:Category {name: 'hygiene'}),
  (c2:Category {name: 'food'})
WITH a, b, c1, c2
MATCH (restaurant:Restaurant), (category:Category)
WHERE restaurant["rating_" + category.name] > 6
RETURN DISTINCT restaurant.name
  • 聚合
CREATE
  (a:Person {name: 'Anne', eyeColor: 'blue'}),
  (b:Person {name: 'Bill', eyeColor: 'brown'}),
  (c:Person {name: 'Carol', eyeColor: 'blue'})
WITH [a, b, c] AS ps
UNWIND ps AS p
RETURN DISTINCT p.eyeColor

仅返回 blue 和 brown

  • 整体成员变量修改
CREATE (a:Person {name: 'Jane', age: 20})
WITH a
MATCH (p:Person {name: 'Jane'})
SET p = {name: 'Ellen', livesIn: 'London'}
RETURN p.name, p.age, p.livesIn

age会变为null

  • 修改指定的成员变量
CREATE (a:Person {name: 'Jane', age: 20})
WITH a
MATCH (p:Person {name: 'Jane'})
SET p += {name: 'Ellen', livesIn: 'London'}
RETURN p.name, p.age, p.livesIn
  • 比较运算
    • 和 null 进行比较，结果只会是 null；
    • 不同类型数据比较会得到 false；
    • 比较两侧中可以是带计算的表达式；
    • 时间点比较需要考虑时区；
    • 时间段无法比较，比较结果只会是 null；
    • 可以在一行中连续比较，完全正确则返回 true
RETURN 1 = 1 - 0 < 2 < 3
result is true
  • 布尔比较
a b a AND b a OR b a XOR b NOT a
false false false false false true
false null false null null true
false true false true true true
true false false true true false
true null null true null false
true true true true false false
null false false null null null
null null null null null null
null true null true null null

转义字符

转义字符 对应字符
\t Tab制表符
\b Backspace退格
\n Newline换行
\r Carriage return回车
\f Form feed换页
' ‘
" "
|\ Backslash反斜线
\uxxxx UTF-16
\Uxxxxxxxx UTF-32

保留关键字

  • Clauses 命令
    • CALL
    • CREATE
    • DELETE
    • DETACH
    • EXISTS
    • FOREACH
    • LOAD
    • MATCH
    • MERGE
    • OPTIONAL
    • REMOVE
    • RETURN
    • SET
    • START
    • UNION
    • UNWIND
    • WITH
  • Subclauses 子句
    • LIMIT
    • ORDER
    • SKIP
    • WHERE
    • YIELD
  • Modifiers 修饰符
  • ASC
  • ASCENDING
  • ASSERT
  • BY
  • CSV
  • DESC
  • DESCENDING
  • ON
  • Expressions 表达式
    • ALL
    • CASE
    • ELSE
    • END
    • THEN
    • WHEN
  • Operators 操作符
    • AND
    • AS
    • CONTAINS
    • DISTINCT
    • ENDS
    • IN
    • IS
    • NOT
    • OR
    • STARTS
    • XOR
  • Schema
    • CONSTRAINT
    • CREATE
    • DROP
    • EXISTS
    • INDEX
    • NODE
    • KEY
    • UNIQUE
  • Hints
    • INDEX
    • JOIN
    • PERIODIC
    • COMMIT
    • SCAN
    • USING
  • Literals文字值
  • false
  • null
  • true
  • Reserved for future use 保留
    • ADD
    • DO
    • FOR
    • MANDATORY
    • OF
    • REQUIRE
    • SCALAR

注释

cypher使用 ""//" 作为注释开头

MATCH (n) RETURN n //这是行末注释
MATCH (n)
//这是一行注释
RETURN n

分支判断CASE

CASE 本身应属于子句的一种，但提供了流程控制的功能，故记在语法一节中
语法

CASE test
  WHEN value THEN result
  [WHEN ...]
  [ELSE default]
END

例

  • 单个判断
MATCH (n)
RETURN
CASE n.eyes
  WHEN 'blue' THEN 1
  WHEN 'brown' THEN 2
  ELSE 3
END AS result
  • 与其他查询结果共同组成一个结果行
MATCH (n)
RETURN n.name,
CASE
  WHEN n.age IS NULL THEN -1
  ELSE n.age - 10
END AS age_10_years_ago

语法规范

变量命名

  • 节点标签使用大驼峰：VehicleOwner；
  • 关系类型使用大写+下划线：OWNS_VEHICLE；

cypher查询语句文件

使用拓展名 .cypher

指代

  • 指代节点标签或关系类型时，应带上":"，如： :Label, :REL_TYPE；
  • 指代函数时，函数名使用小驼峰；

缩进与换行

  • 每个子句新起一行；
  • ON GREATE 与 ON MATCH 应缩进两格；
  • ON GREAT 应写在 ON MATCH 之前；
MERGE (n)
  ON CREATE SET n.prop = 0
MERGE (a:A)-[:T]-(b:B)
  ON CREATE SET a.name = 'me'
  ON MATCH SET b.name = 'you'
RETURN a.prop
  • 子查询段由{}括起，子查询内容空缩进两格，"}"应单独一行；
MATCH (a:A)
WHERE EXISTS {
  MATCH (a)-->(b:B)
  WHERE b.prop = $param
}
RETURN a.foo
  • 简单的子查询段不应换行；
MATCH (a:A)
WHERE EXISTS { (a)-->(b:B) }
RETURN a.prop

大小写

  • 关键字应大写；
  • null 值应小写；
  • Boolean 类型的值"true"、"false"应小写；
  • 对于函数名、属性名、变量名、参数名应使用小驼峰；

空格

WITH {key1: 'value', key2: 42} AS map
RETURN map
  • 对于 Map
    • "{"与第一个键之间不应有空格；
    • 键与":"之间不应有空格；
    • ":"与值之间应有一个空格；
    • 值与","间不应有空格；
    • ","与下一个键之间应有一个空格；
    • 最后一个值与"}"间不应有空格；
MATCH (p:Person {property: -1})-[:KNOWS {since: 2016}]->()
RETURN p.name
  • 节点标签与关系类型与属性间应有一个空格
MATCH (:Person)-->(:Vehicle)
RETURN count(*)
  • 一个模式内不应有空格
  • 操作符两侧应有空格；
MATCH (person:Person:Owner)
RETURN person.name
  • 标签指定间不应有空格；
  • List中的元素与前一个","间应有一个空格；
  • 函数参数与"("，")"间不应有空格；
  • 简单子查询段与"{"，"}"间应有一个空格；

模式

patterns

  • 模式需要换行时，应在箭头后换行；
MATCH (:Person)-->(vehicle:Car)-->(:Company)<--
      (:Country)
RETURN count(vehicle)
  • 模式中指代的节点或标签接下来不会被使用时应匿名指代；
CREATE (a:End {prop: 42}),
	   (:End {prop: 3}),
	   (:Begin {prop: id(a)})
  • 尽可能将模式复合，避免出现重复结果；
  • 有代称指代的节点应在匿名指代的节点前；
MATCH (manufacturer:Company)<--(vehicle:Car)<--(:Person)
WHERE manufacturer.foundedYear < 2000
RETURN vehicle.mileage
  • 将接下来要是用的重要节点放在最前；
MATCH (:Person)-->(vehicle:Car)-->(:Company)<--(:Country)
RETURN vehicle.mileage
  • 尽量将右向模式写在前；

单个符号使用

  • 用单引号引起单个单词，用双引号引起句子；
  • 当句子本身出现引号时，使用出现少的那个引起句子，出现次数相同时，使用单引号；
  • 避免使用反引号"`"引起字符、单词或关键字；
  • 句末不适用分号";"；

命令

删除节点

只删除节点

MATCH (n:Test{name: 'test1'}) DELETE (n)

运行上述语句会报错：Cannot delete node<10000>, because it still has relationships. To delete this node, you must first delete its relationships.，该语句只删除 name 为 test1 的节点，但该节点因为有关系与之相连，故删除节点报错。

删除节点及其子图

MATCH (n:Test{name: 'test1'}) DETACH DELETE (n)

运行上述语句，执行成功，会删除 name 为 test1 的节点及其子图，也就是该节点与其他节点相连的边也会删除

删除全部节点

MATCH (n) DETACH DELETE (n)

该语句会删除整个图谱，即所有的节点和关系，应当慎用，另外，当图谱规模很大时，运行该语句容易报错（OOM，Out Of Memeory）。

ID 属性

在 Neo4j 中，“Id” 是节点和关系的默认内部属性。 这意味着，当我们创建一个新的节点或关系时，Neo4j 数据库服务器将为内部使用分配一个数字。 它会自动递增。

例：
新增一个节点

CREATE (tweet:Tweet{ message:"Hello"})

查看该节点

MATCH (n:Tweet) RETURN n

[1]

Caption 标题

所谓的 Caption 标题，就是更改 Neo4j 浏览器的节点显示的文字（圆圈内部）。比如
[2]

CREATE 创建

Neo4j CQL 创建一个没有属性的节点

CREATE (<node-name>:<label-name>)

语法说明
规范说法是节点标签名称，其实相当于 Mysql 数据库中的表名，而是节点名称，其实代指创建的此行数据。

示例

CREATE (emp:Employee)

或者

CREATE (:Employee)

Neo4j CQL 创建具有属性的节点

Neo4j CQL“CREATE”命令用于创建带有属性的节点。 它创建一个具有一些属性（键值对）的节点来存储数据。

CREATE (
   <node-name>:<label-name>
   { 	
      <Property1-name>:<Property1-Value>,
      ........
      <Propertyn-name>:<Propertyn-Value>
   }
)
名称 含义
指代用节点名
此处的节点名相当于操作节点的代称，作用域仅在本次查询语句中
用于在本语句的其他位置指代此处的节点，下同
节点标签/类型
属性名
属性值

示例

CREATE (
	dept:Dept 
	{ 
		deptno:10,
		dname:"Accounting",
		location:"Hyderabad" 
	}
)

创建多个标签到节点

语法：

CREATE (
	<node-name>:<label-name1>:<label-name2>.....:<label-namen>
)

示例

CREATE (
	m:Movie:Cinema:Film:Picture
)

MATCH 查询

Neo4j CQL MATCH 命令用于

  • 从数据库获取有关节点和属性的数据
  • 从数据库获取有关节点，关系和属性的数据

MATCH命令语法：

MATCH (
	<node-name>:<label-name> 
)
名称 含义
指代用名称
节点标签/类型
指代用节点名
同上

示例

MATCH (dept:Dept)

但是执行后会报错：

Neo.ClientError.Statement.SyntaxError: 
Query cannot conclude with MATCH 
(must be RETURN or an update clause) (line 1, column 1 (offset: 0))

如果你观察到错误消息，它告诉我们，我们可以使用 MATCH 命令与 RETURN 子句或 UPDATA 子句。

WITH

连接不同的查询语句部分，未被 WITH 指定的变量将不会在之后的查询语句中起效

RETURN 返回

  • Neo4j CQL RETURN子句用于
    • 检索节点的某些属性
    • 检索节点的所有属性
    • 检索节点和关联关系的某些属性
    • 检索节点和关联关系的所有属性
      RETURN命令语法：
RETURN 
   <node-name>.<property1-name>,
   ........
   <node-name>.<propertyn-name>

RETURN 不能单独使用
指定属性时，可以指定多个属性，按照节点组合后返回，返回类型为由节点 id 为主键构成的表
不指定属性时，返回节点，返回由节点组成的图

名称 含义
指代用节点名
节点属性名

示例

MATCH (e:Employee) RETURN e

或

MATCH (dept: Dept)
RETURN dept.deptno,dept.dname,dept.location

关系基础

Neo4j 图数据库遵循属性图模型来存储和管理其数据。
根据属性图模型，关系应该是定向的。 否则，Neo4j 将抛出一个错误消息。

CREATE  
	(<node1-label-name-OR-node-name>)
	-[<relationship-label-name>:<relationship-name>{<define-properties-list>}]->
	(<node2-label-name-OR-node-name>)
名称 含义
节点标签名或节点名<br>为节点标签名时，选中该标签的所有节点
为节点名时，选择对应节点（组），一般由 MATCH 匹配得到
同上
关系类型
关系名
关系属性集

基于方向性，Neo4j 关系被分为两种主要类型。

  • 单向关系
  • 双向关系

使用新节点创建关系

示例

CREATE (e:Employee)-[r:DemoRelation]->(c:Employee)

双向关系

这句会创建节点 e，节点 c，以及 e -> c 的关系r，这里需要注意方向，比如双向是（5.x版本已经不支持改写法）

CREATE (e:Employee)<-[r:DemoRelation]->(c:Employee)

创建两个单向关系来模拟双向关系

CREATE (alice:Person {name: 'Alice'})
CREATE (bob:Person {name: 'Bob'})

MATCH (alice:Person {name: 'Alice'}), (bob:Person {name: 'Bob'}) RETURN alice,bob

CREATE (alice)-[:FRIEND_OF]->(bob)
CREATE (bob)-[:FRIEND_OF]->(alice)

使用 APOC

另一种简化的方法是使用 APOC 库中的apoc.create.addRelationships函数。这可以让你一次性创建两个方向的关系。首先，确保 APOC 库已安装并启用。

安装 APOC

如果你还没有安装 APOC，可以使用以下命令安装：

CALL apoc.install.plugins(['https://github.com/neo4j-contrib/neo4j-apoc-procedures/releases/download/4.4.0.1/apoc-4.4.0.1-all.jar'])

使用 APOC 创建双向关系

使用 APOC 库创建双向关系的示例：

MATCH (alice:Person {name: 'Alice'}), (bob:Person {name: 'Bob'})
WITH alice, bob
UNWIND ['FRIEND_OF'] AS type
CALL apoc.create.addRelationships([alice, bob], type) YIELD rel
RETURN rel

这个查询将为 alice 和 bob 之间的每种关系类型创建两个关系，即 alice -> bob 和 bob -> alice。

使用已知节点创建带属性的关系

MATCH (<node1-label-name>:<node1-name>),(<node2-label-name>:<node2-name>)

CREATE  
    (<node1-label-name>)-[<relationship-label-name>:<relationship-name>
    {
   
   <define-properties-list>}]->(<node2-label-name>)
RETURN <relationship-label-name>

还是一系列键值对

示例

MATCH (cust:Customer),(cc:CreditCard) 
CREATE (cust)-[r:DO_SHOPPING_WITH{shopdate:"12/12/2014",price:55000}]->(cc) 
RETURN r

检索关系节点的详细信息

MATCH 
(<node1-label-name>)-[<relationship-label-name>:<relationship-name>]->(<node2-label-name>) RETURN <relationship-label-name>
名称 含义
节点标签/类型
同上
指代用关系名称
关系类型

示例

MATCH (cust)-[r:DO_SHOPPING_WITH]->(cc) 
RETURN cust,cc

MATCH (e)-[r:DemoRelation]->(c) 
RETURN e,c

WHERE 子句

像 SQL 一样，Neo4j CQL 在 CQL MATCH 命令中提供了 WHERE 子句来过滤 MATCH 查询的结果。

简单 WHERE 子句语法

WHERE <property-name> <comparison-operator> <value>

语法说明：

S.No. 语法元素 描述
1 WHERE 它是一个 Neo4j CQL 关键字。
2 <属性名称> 它是节点或关系的属性名称。
3 <比较运算符> 它是 Neo4j CQL 比较运算符之一。
4 <值> 它是一个字面值，如数字文字，字符串文字等。

Neo4j CQL 中的比较运算符

Neo4j 支持以下的比较运算符，在 Neo4j CQL WHERE 子句中使用来支持条件

S.No. 布尔运算符 描述
1. = 它是 Neo4j CQL “等于”运算符。
2. <> 它是一个 Neo4j CQL “不等于”运算符。
3. < 它是一个 Neo4j CQL “小于”运算符。
4. > 它是一个 Neo4j CQL “大于”运算符。
5. <= 它是一个 Neo4j CQL “小于或等于”运算符。
6. = 它是一个 Neo4j CQL “大于或等于”运算符。

我们可以使用布尔运算符在同一命令上放置多个条件。

Neo4j CQL 中的布尔运算符

Neo4j 支持以下布尔运算符在 Neo4j CQL WHERE子句中使用以支持多个条件。

S.No. 布尔运算符 描述
1 AND 它是一个支持 AND 操作的 Neo4j CQL 关键字。
2 OR 它是一个 Neo4j CQL 关键字来支持 OR 操作。
3 NOT 它是一个 Neo4j CQL 关键字支持 NOT 操作。
4 XOR 它是一个支持 XOR 操作的 Neo4j CQL 关键字。

示例

MATCH (emp:Employee) 
WHERE emp.name = 'Abc' OR emp.name = 'Xyz'
RETURN emp

利用WHERE创建指定关系节点：

MATCH (cust:Customer),(cc:CreditCard) 
WHERE cust.id = "1001" AND cc.id= "5001" 
CREATE (cust)-[r:DO_SHOPPING_WITH{shopdate:"12/12/2014",price:55000}]->(cc) 
RETURN r

有必要补充一下，可以不使用WHERE达到WHERE的一些效果，比如

MATCH p=(m:Bot{
   id:123})<-[:BotRelation]->(:Bot)  RETURN p

DELETE 删除

Neo4j 使用 CQL DELETE 子句

  • 删除节点。
  • 删除节点及相关节点和关系。

DELETE节点子句语法

DELETE <node-name-list>

示例

MATCH (e: Employee) DELETE e

DELETE节点和关系子句语法

DELETE <node1-name>,<node2-name>,<relationship-name>

示例

MATCH (cc: CreditCard)-[rel]-(c:Customer) 
DELETE cc,c,rel

REMOVE 删除

有时基于我们的客户端要求，我们需要向现有节点或关系添加或删除属性。

我们使用 Neo4j CQL SET 子句向现有节点或关系添加新属性。

我们使用 Neo4j CQL REMOVE子 句来删除节点或关系的现有属性。

  • Neo4j CQL REMOVE 命令用于
    • 删除节点或关系的标签
    • 删除节点或关系的属性
  • Neo4j CQL DELETE 和 REMOVE 命令之间的**主要区别 **
    • DELETE 操作用于删除节点和关联关系。
    • REMOVE 操作用于删除标签和属性。
  • Neo4j CQL DELETE 和 REMOVE 命令之间的**相似性 **
    • 这两个命令不应单独使用。
    • 两个命令都应该与 MATCH 命令一起使用。

REMOVE属性子句语法

REMOVE <node-name>.<property1-name>,<node-name>.<property2-name>

语法说明：

S.No. 语法元素 描述
1。 它是节点的名称。
2。 它是节点的属性名称。

示例

CREATE (book:Book {id:122,title:"Neo4j Tutorial",pages:340,price:250}) 

MATCH (book:Book) RETURN book

[3]

在数据浏览器上键入以下命令删除 price 属性，删除一个属性

MATCH (book { id:122 })
REMOVE book.price
RETURN book

[4]

REMOVE一个Label子句语法

REMOVE <label-name-list>

可以删除很多个属性，属性。
只要在属性与属性之间用逗号（，）分隔开就行。
示例

MATCH (book { id:122 })
REMOVE book.price，book.id，book.pages
RETURN book
S.No. 语法元素 描述
1. REMOVE 它是一个 Neo4j CQL 关键字。
2. 它是一个标签列表，用于永久性地从节点或关系中删除它。

删除标签

REMOVE 语句删除属性是永久的，也可以永久删除标签。
标签与节点名之间用（：）隔开

REMOVE 
<node-name>:<label2-name>, 
.... 
<node-name>:<labeln-name>

示例

CREATE (m:Movie:Pic)

MATCH (m:Movie) 
REMOVE m:Pic

SET 子句

有时，根据我们的客户端要求，我们需要向现有节点或关系添加新属性。

要做到这一点，Neo4j CQL提供了一个 SET 子句。

  • Neo4j CQL 已提 供SET 子句来执行以下操作。
    • 向现有节点或关系添加新属性
    • 添加或更新属性值

SET 子句语法

SET  <node-label-name>.<property1-name>=<property1-value>,...<node-laben-name>.<propertyn-name>=<propertyn-value>

语法说明：

S.No. 语法元素 描述
1 <节点标签名称> 这是一个节点的标签名称。
2 <属性名称> 它是一个节点的属性名。
3 <属性值> 它是一个节点的属性值。

示例

CREATE (
	dc:DebitCard 
		{
			id:11,
			name:"ABC11XYZ",
			number:2234567890,
			vaild_from:0o2/11,
			vaild_to:0o2/21
		}
	)

MATCH (dc:DebitCard)
SET dc.atm_pin = 3456
RETURN dc

ORDER BY 排序

Neo4j CQL ORDER BY 子句
Neo4j CQL 在 MATCH 命令中提供了 “ORDER BY” 子句，对 MATCH 查询返回的结果进行排序。

我们可以按升序或降序对行进行排序。

默认情况下，它按升序对行进行排序。 如果我们要按降序对它们进行排序，我们需要使用 DESC 子句。

ORDER BY 子句语法

ORDER BY  <property-name-list>  [DESC]

语法：

MATCH(
	<node-name>:<label-name> 
)
RETURN 
	<node-label-name>.<property1-name>
	<node-label-name>.<property2-name>, 
	.... 
	<node-label-name>.<propertyn-name> 
ORDER BY
	<node-label-name>.<property1-name>,
	<node-label-name>.<property2-name>, 
	.... 
	<node-label-name>.<propertyn-name>
S.No. 语法元素 描述
1。 它是节点的标签名称。
2。 它是节点的属性名称。

示例

CREATE (
   emp1:Employee
   { 	
      empid:1,
      name:"i1",
      salary:10000,
      deptno:1
   }
), (
   emp2:Employee
   { 	
      empid:2,
      name:"i2",
      salary:12000,
      deptno:1
   }
), (
   emp3:Employee
   { 	
      empid:3,
      name:"i3",
      salary:13000,
      deptno:2
   }
), (
   emp4:Employee
   { 	
      empid:4,
      name:"i4",
      salary:14000,
      deptno:4
   }
);

MATCH (emp:Employee)
RETURN emp.empid,emp.name,emp.salary,emp.deptno
ORDER BY emp.name DESC

UNION / UNION ALL 子句

与 SQL 一样，Neo4j CQL 有两个子句，将两个不同的结果合并成一组结果

  • UNION
  • UNION ALL

UNION子句
它将两组结果中的公共行组合并返回到一组结果中。 它不从两个节点返回重复的行。

限制：
结果列类型和来自两组结果的名称必须匹配，这意味着列名称应该相同，列的数据类型应该相同。

UNION子句语法

<MATCH Command1>
   UNION
<MATCH Command2>
S.No. 语法元素 描述
1。 它是 CQL MATCH 命令，由 UNION 子句使用。
2。 它是 CQL MATCH 命令两个由 UNION 子句使用。
3。 UNION 它是 UNION 子句的 Neo4j CQL 关键字。
注意
如果这两个查询不返回相同的列名和数据类型，那么它抛出一个错误。

示例

MATCH (cc:CreditCard) RETURN cc.id,cc.number
UNION
MATCH (dc:DebitCard) RETURN dc.id,dc.number

UNION ALL子句
它结合并返回两个结果集的所有行成一个单一的结果集。它还返回由两个节点重复行。

限制
结果列类型，并从两个结果集的名字必须匹配，这意味着列名称应该是相同的，列的数据类型应该是相同的。

UNION ALL子句语法

<MATCH Command1>
UNION ALL
<MATCH Command2>

示例

MATCH (cc:CreditCard) RETURN cc.id,cc.number
UNION ALL
MATCH (dc:DebitCard) RETURN dc.id,dc.number

LIMIT 和 SKIP 子句

Neo4j CQL 已提供 LIMIT 子句和 SKIP 来过滤或限制查询返回的行数。

简单来说：LIMIT 返回前几行，SKIP 返回后几行。

LIMIT 示例

MATCH (emp:Employee) 
RETURN emp
LIMIT 2

它只返回 Top 的两个结果，因为我们定义了 limit = 2。这意味着前两行。

SKIP示例

MATCH (emp:Employee) 
RETURN emp
SKIP 2

它只返回来自 Bottom 的两个结果，因为我们定义了 skip = 2。这意味着最后两行。

MERGE 命令

Neo4j 使用 CQL MERGE 命令

  • 创建节点，关系和属性
  • 为从数据库检索数据

MERGE 命令是 CREATE 命令和 MATCH 命令的组合。

MERGE = CREATE + MATCH

Neo4j CQL MERGE 命令在图中搜索给定模式，如果存在，则返回结果

如果它不存在于图中，则它创建新的节点/关系并返回结果。

Neo4j CQL MERGE 语法

MERGE (<node-name>:<label-name>
{
   <key>:<1-Value>
   .....
   <n-key>:<n-Value>
})

注意
Neo4j CQL MERGE 命令语法与 CQL CREATE 命令类似。

  • 我们将使用这两个命令执行以下操作
    • 创建具有一个属性的配置文件节点：Id，名称
    • 创建具有相同属性的同一个Profile节点：Id，Name
    • 检索所有Profile节点详细信息并观察结果

我们将使用 CREATE 命令执行这些操作：

MERGE (gp2:GoogleProfile2{ Id: 201402,Name:"Nokia"})

MERGE (gp2:GoogleProfile2{ Id: 201402,Name:"Nokia"})

MATCH  (gp1:GoogleProfile1) 
RETURN gp1.Id,gp1.Name

如果我们观察上面的查询结果，它只显示一行，因为 CQL MERGE 命令检查该节点在数据库中是否可用。 如果它不存在，它创建新节点。 否则，它不创建新的。

通过观察这些结果，我们可以说，CQL MERGE 命令将新的节点添加到数据库，只有当它不存在。

NULL 值

Neo4j CQL 将空值视为对节点或关系的属性的缺失值或未定义值。

当我们创建一个具有现有节点标签名称但未指定其属性值的节点时，它将创建一个具有 NULL 属性值的新节点。

让我们用一个例子来看这个。

MATCH (e:Employee) 
WHERE e.id IS NOT NULL
RETURN e.id,e.name,e.sal,e.deptno

提供了一个 WHERE 子句来过滤该行，即 Id 属性不应该包含 NULL 值。

MATCH (e:Employee) 
WHERE e.id IS NULL
RETURN e.id,e.name,e.sal,e.deptno

这里我们使用IS操作符来仅返回 NULL 行。

IN 操作符

与 SQL 一样，Neo4j CQL 提供了一个IN运算符，以便为 CQL 命令提供值的集合。

IN 操作符语法

IN[<Collection-of-values>]

它是由逗号运算符分隔的值的集合。

示例

MATCH (e:Employee) 
WHERE e.id IN [123,124]
RETURN e.id,e.name,e.sal,e.deptno

INDEX 索引

Neo4j SQL 支持节点或关系属性上的索引，以提高应用程序的性能。
我们可以为具有相同标签名称的所有节点的属性创建索引。
我们可以在MATCH或WHERE或IN运算符上使用这些索引列来改进 CQL Command 的执行。

Neo4J 索引操作

  • Create Index 创建索引
  • Drop Index 丢弃索引

创建索引的语法：

CREATE INDEX ON :<label_name> (<property_name>)

注意
冒号（:)运算符用于引用节点或关系标签名称。
上述语法描述它在节点或关系的的上创建一个新索引。

示例

CREATE INDEX ON :Customer (name)

删除索引的语法：

DROP INDEX ON :<label_name> (<property_name>)

示例

DROP INDEX ON :Customer (name)

UNIQUE 约束

在 Neo4j 数据库中，CQL CREATE 命令始终创建新的节点或关系，这意味着即使您使用相同的值，它也会插入一个新行。 根据我们对某些节点或关系的应用需求，我们必须避免这种重复。 然后我们不能直接得到这个。 我们应该使用一些数据库约束来创建节点或关系的一个或多个属性的规则。

像 SQL 一样，Neo4j 数据库也支持对 NODE 或 Relationship 的属性的 UNIQUE 约束

UNIQUE 约束的优点

  • 避免重复记录。
  • 强制执行数据完整性规则

创建唯一约束语法

CREATE CONSTRAINT ON (<label_name>) ASSERT <property_name> IS UNIQUE

语法说明：

S.No. 语法元素 描述
1。 CREATE CONSTRAINT ON 它是一个 Neo4j CQL 关键字。
2。 它是节点或关系的标签名称。
3。 ASSERT 它是一个 Neo4j CQL 关键字。
4。 它是节点或关系的属性名称。
5。 IS UNIQUE 它是一个 Neo4j CQL 关键字，通知 Neo4j 数据库服务器创建一个唯一约束。

注意
上述语法描述了只需要 节点或关系就可以创造一个独特的约束。

示例

CREATE CONSTRAINT ON (cc:CreditCard) ASSERT cc.number IS UNIQUE

注意
如果创建约束时节点属性有重复值，Neo4j DB服务器将会抛出一个错误，表示无法创建。

删除 UNIQUE 约束语法：

DROP CONSTRAINT ON (<label_name>) ASSERT <property_name> IS UNIQUE

示例

DROP CONSTRAINT ON (cc:CreditCard) ASSERT cc.number IS UNIQUE

DISTINCT 独特

CREATE (
   m1:movie
   { 	
      name:"迪迦"
   }
), (
   m2:movie
   { 	
      name:"迪迦"
   }
), (
   m3:movie
   { 	
      name:"泰罗"
   }
), (
   m4:movie
   { 	
      name:"泰罗"
   }
);

这个函数的用法就像 SQL 中的 distinct 关键字，返回的是所有不同值。

示例
[5]

MATCH (m:movie) RETURN Distinct(m.name)

[6]

UNWIND

将一个 List 转为一个结果集

WITH [[1, 2], [3, 4], 5] AS nested
UNWIND nested AS x
UNWIND x AS y
RETURN y

FOREACH 遍历

MATCH p=(start)-[*]->(finish)
WHERE start.name = 'A' AND finish.name = 'D'
FOREACH (n IN nodes(p) | SET n.marked = true)

以上查询语句将所有从 A 到 D 路径上的节点都设置一个 marked 属性，值为 true

CALL

指定一处子句段，CALL 中的子句段不会作为最终查询结果返回，不能单独使用 CALL
用于复合多个查询语句段
子句段的命名空间和作用域与整体查询语句部分相同

CREATE
  (a:Person {name: 'Anne', eyeColor: 'blue'}),
  (b:Person {name: 'Bill', eyeColor: 'brown'}),
  (c:Person {name: 'Carol', eyeColor: 'blue'})

CALL {
  MATCH (p:Person)
  RETURN p
  ORDER BY p.age ASC
  LIMIT 1
UNION
  MATCH (p:Person)
  RETURN p
  ORDER BY p.age DESC
  LIMIT 1
}
RETURN p.name, p.age
ORDER BY p.name

CALL PROCEDURE

CALL 也用于使用处理过程(procedure)

CALL db.labels()
  • 无参数时，可略去"()"

YIELD 子句

在处理过程调用结尾，指定处理过程返回的多个属性值中的某几个

CALL dbms.procedures() YIELD name, signature
WHERE name='dbms.listConfig'
RETURN signature
  • 处理过程在当前版本已不建议使用，将来会被删除，建议使用的是指令处理过程在当前版本已不建议使用，将来会被删除，建议使用的是指令 ∗dbms.procedures() 处理过程在当前版本(4.3)已不建议使用，将来会被删除，建议使用的是 SHOWPROCEDURES 指令
  • 使用
CALL db.labels() YIELD *

来返回处理过程返回的所有属性值

USE

指定查询语句段要使用的数据库

USE myDatabase
MATCH (n) RETURN n

LOAD CSV

  • 加载 CSV 文件
    • 使用 URL 地址；
    • 需要使用 AS 子句指定引入的数据；
    • 可以是本地(file:///URL)，也可以是 HTTPS/HTTP/FTP 地址；
    • 支持由 gzip 或 Deflate 压缩的文件，支持本地由 ZIP 压缩的 CSV 文件；
    • 支持 HTTP 重定向，但不支持改变传输协议的重定向；
  • 目标 CSV 文件要求
    • 字符集应是 UTF-8；
    • 文件结尾依据系统，unix 下应为\n，Windows 下应为\r\n；
    • 字段分隔符应是',' ;
    • 在 LOAD CSV 指令中使用 FIELDTERMINATOR 修改字段分隔符；
    • 字符串指代应使用双引号引起("")；
    • 如果 DBMS 设置中设置 dbms.import.csv.legacy_quote_escaping=true，则\作为转义字符；
    • 目标使用的 CSV 文件需要放在对应的数据库的 import 文件夹下使用；
LOAD CSV FROM 'file:///artists.csv' AS line
CREATE (:Artist {name: line[1], year: toInteger(line[2])})

表格中带有表头的情况下，可通过表头指定对应的列

LOAD CSV WITH HEADERS FROM 'file:///artists-with-headers.csv' AS line
CREATE (:Artist {name: line.Name, year: toInteger(line.Year)})

指定字段分隔符

LOAD CSV FROM 'file:///artists-fieldterminator.csv' AS line FIELDTERMINATOR ';'
CREATE (:Artist {name: line[1], year: toInteger(line[2])})

USING PERIODIC COMMIT

  • 表格数据过多时，指定使用的行数
  • 不指定个数时，默认每 1000 行 commit 一次；
USING PERIODIC COMMIT 500 LOAD CSV FROM 'file:///artists.csv' AS line
CREATE (:Artist {name: line[1], year: toInteger(line[2])})
  • 默认下 csv 文件中非数字字段会被识别为 String；
  • 默认下 csv 文件中的数字字段会被识别为对应的数字类型；

函数

函数在使用时函数名都不区分大小写

SHOW FUNCTIONS

使用 SHOW FUNCTIONS 指令查看所有内置函数

字符串函数

String functions
本节内函数除toString()外主要参数都应为String类型，否则会返回一个错误

与 SQL 一样，Neo4J CQL 提供了一组 String 函数，用于在 CQL 查询中获取所需的结果。

注意： 所有 CQL 函数应使用“（）”括号。字符串函数除 toString() 外主要参数都应为 String 类型，否则会返回一个错误

left

left(original, length)

返回值：String
返回 original 自左起共 length 个字符，字符顺序不变

  • left(null, length) 或 left(null, null) 会返回 null；
  • left(original, null) 会返回一个错误；
  • length 不是整数时会返回一个错误；
  • length 比 original 的总长度还长时，返回 original 本身；

ltrim

ltrim(original)

返回值：String
去除 original 中最左侧连续的空格后返回剩余内容
ltrim(null) 会返回 null

replace

replace(original, search, replace)

返回值：String
将 original 中的 search 子串替换为 replace

  • 任何一个参数为 null 都会返回 null；
  • 如果 original 中没有 search 子串，则会返回 original 本身；

reverse

reverse(original)

返回值：String
将一个 String 中的字符反转顺序后的 String 返回
reverse(null)会返回null

right(original,length)

返回值：String
返回 origina l自右起共 length 个字符，字符顺序不变

  • right(null, length) 或 left(null, null) 会返回 null；
  • right(original, null) 会返回一个错误；
  • length 不是整数时会返回一个错误；
  • length 比 original 的总长度还长时，返回 original 本身；

rtrim

rtrim(original)

返回值：String
去 除original 中最右侧连续的空格后返回剩余内容
rtrim(null) 会返回 null

split

split(original, splitDelimiter)

返回值：List
将 original 在 splitDelimiter 的位置上分割为多个 String 并按顺序构成一个List返回

  • splitDelimiter 不会出现在返回的 String 中；
  • original 或 splitDelimiter 是 null 则会返回 null；

toLower

toLower(original)

返回值：String
将 original 中的大写字母转为小写后返回
toLower(null) 会返回 null

toString

toString(expression)

返回值：String
将一个 Integer/Float/String/Boolean/Point/Duration/Date/Time/Locatime/Localdatetime/Datetime 类型的数据转为 String 类型后返回

  • expression 为 String 时则返回其本身；
  • toString(null) 会返回 null；
  • 无法转换时会返回一个错误，如 expression 是一个 List 的情况

toStringOrNull

toStringOrNull(expression)

返回值：String
将一个 Integer/Float/String/Boolean/Point/Duration/Date/Time/Locatime/Localdatetime/Datetime 类型的数据转为 String 类型后返回
toString() 无法转换的情况会返回 null

toUpper

toUpper(original)

返回值：String
将 original 中的小写字母转为大写字母后返回
toUpper(null) 会返回 null；

trim

trim(original)

返回值：String
将 original 前后连续的空格去除后返回
trim(null) 会返回 null

UPPER

它需要一个字符串作为输入并转换为大写字母。 所有 CQL 函数应使用“（）”括号。
函数语法

UPPER (<input-string>)

注意：
可以是来自 Neo4J 数据库的节点或关系的属性名称。

示例

MATCH (e:Employee) 
RETURN e.empid,UPPER(e.name),e.salary,e.deptno

LOWER

它需要一个字符串作为输入并转换为小写字母。 所有 CQL 函数应使用“（）”括号。

函数语法

LOWER (<input-string>)

注意：
可以是来自 Neo4J 数据库的节点或关系的属性名称

MATCH (e:Employee) 
RETURN e.empid,LOWER(e.name),e.salary,e.deptno

substring

它接受一个字符串作为输入和两个索引：一个是索引的开始，另一个是索引的结束，并返回从 StartInded 到 EndIndex-1 的子字符串。 所有 CQL 函数应使用“（）”括号。

函数的语法

SUBSTRING(<input-string>,<startIndex> ,<endIndex>)

注意：
在 Neo4J CQL 中，如果一个字符串包含 n 个字母，则它的长度为 n，索引从 0 开始，到 n-1 结束。
是 SUBSTRING 函数的索引值。
是可选的。 如果我们省略它，那么它返回给定字符串的子串从 startIndex 到字符串的结尾。

示例

MATCH (e:Employee) 
RETURN e.empid,SUBSTRING(e.name,0,1),e.salary,e.deptno

判断函数

Predicate functions

all

all(variable IN list WHERE predicate)

返回值：Boolean
判断所有 list 中的变量 variable 是否都满足 predicate的判断，
都满足返回 true；
否则返回 false；

any

any(variable IN list WHERE predicate)

返回值：Boolean
判断list中的变量 variable 是否至少有一个满足predicate的判断，
有一个满足就返回 true；
都不满足返回 false；

  • 如果 list 本身是 null 则会返回 null；
  • 如果 list 中的值都是 null 则会返回 null；

exists

exists(pattern-or-property)

返回值：Boolean
当参数存在时，返回 true；
否则返 false；

isEmpty

isEmpty(list)
isEmpty(map)
isEmpty(string)

给定的 list/map/String 中如果没有元素，则返回 true；
否则返回 false；

none

none(variable IN list WHERE predicate)

给定的 list 中没有元素满足 predicate 时，返回 true；
存在元素满足 predicate 时，返回 false；
list 本身是 null 或其中的所有元素都是 null，则返回 null；

single

single(variable IN list WHERE predicate)

给定的 list 中只有一个元素满足 predicate 时，返回 true；
否则返回 false；
list 本身是 null 或其中的所有元素都是 null，则返回 null；

标量函数

Scalar functions

coalesce

coalesce(expression [, expression]*)
  • 返回所给表达式中第一个不为nuill的值；
  • 给定值都是null则返回null；

endNode

endNode(relationship)
  • 返回所给关系的尾结点；
  • relationship 为 null 时返回 null；
head(expression)
  • 返回给定表达式的list的第一个元素；
  • express 需要返回一个 list；
  • head(null)、head([])与head([null,1])都会返回 null；

id

id(expression)

返回值：Integer

  • 返回 expression 表达的节点/关系的 id；
  • 每个节点/关系实例都有一个独特的 id，在同一个数据库中不会重复；
  • id(null) 返回 null；

last

last(expression)

返回 expression 表达的 list 中最后一个元素

  • expression 应表达一个 list；
  • last(null)、last([])会返回 null；
  • 列表本身就是 null，也会返回 null；

length

length(path)

返回值：Integer
返回一条链路的长度，即链路上关系的个数，如：

MATCH p = (a)-->(b)-->(c)
RETURN length(p) AS length

该查询段的返回结果应为由 2 组成的单列表，表头为 length

properties

properties(expression)

返回值：Map
返回 expression 表达的节点/关系的所有属性值；
若 expression 本身就是一个 Map，则返回它本身；

randomUUID

randomUUID()

返回值：String
返回一个 128bit 的随机值，该值全局唯一
Universally Unique Identifier，亦称 Globally Unique Identifier

size

返回值：Integer

list

size(list)

返回 list 中元素的个数

  • size(null) 会返回 null；

pattern expression

size(pattern expression)

当 pattern expression 返回一个 list 时，size 返回该 list 的元素个数，如：

MATCH(n)
WHERE n.name = 'JOJO'
RETURN size((n)-[defeat]->())

(n)-[defeat]->()返回一个 list，其中含有所有 JOJO 与其打败过的人及“打败（defeat）”这一关系所组成的路径，size 返回这一 list 中元素的个数

String

size(string)

返回 string 中所包含字符的个数

startNode

startNode(relationship)

返回值：Node
返回一个关系的头节点
startNode(null) 会返回 null

timestamp

timestamp()

返回值：Integer
返回当前时间与 midnight, January 1, 1970 UTC 之间的时间间隔，单位毫秒

toBoolean

cql

返回值：Boolean
将 expression 表达的 String/Integer/Boolean 值转为一个 Boolean 值

  • toBoolean(null) 会返回 null；
  • expression 本身就是一个 Boolean 值，则会返回它本身；
  • 如果 expression 表达的 String 本身不是"true"或"false"（词语前后可以带空格），则会返回 null；
  • 如果 expression 返回一个整数
    • 0 会转为 false；
    • 其他非 0 整数会被转为 true；
  • 如果 expression 表达的不是 String/Integer/Boolean，则会返回一个错误；

toBooleanOrNull

toBooleanOrNull(expression)

返回值：Boolean 或 null
相较 toBoolean()，toBooleanOrNull() 会在 expression 表达的不是 String/Integer/Boolean 时返回 null

toFloat

toFloat(expression)

返回值：Float
将 expression 表达的 Integer/Float/String 转为一个 Float 值

  • toFloat(null) 会返回 null；
  • 如果 expression 本身是一个 Float，则会返回它本身；
  • 如果 expression 表达的内容不能被识别出一个浮点数，则会返回 null；
  • 如果 expression 不是 Integer/Float/String，则会返回一个错误；

toFloatOrNull

toFloatOrNull(expression)

返回值：Boolean 或 null
相较 toFloat()，toFloatOrNull() 会在 expression 表达的不是 Integer/Float/String 时返回 null

toInteger

toInteger(expression)

返回值：Integer
将 expression 表达的 Boolean/Integer/Float/String 转成一个 Integer 值

  • toInteger(null) 会返回 null；
  • 如果 expression 表达的是一个 Integer，则会返回它本身；
  • 如果 expression 表达的内容不能被识别为一个整数，则会返回 null；
  • 如果 expression 表达的内容是一个 Boolean
    • true 会被转为 1；
    • false 会被转为 0；
  • 如果 expression 表达的不是 Boolean/Integer/Float/String，则会返回一个错误；

toIntegerOrNull

toIntegerOrNull(expression)

返回值：Integer 或 null
相较于 toInteger()，toIntegerOrNull() 会在 expression 表达的不是 Boolean/Integer/Float/String 的时返回 null

type

type(relationship)

返回值：Sting
返回 relationship 的标签名

聚合函数

Aggregating functions
和 SQL 一样，Neo4j CQL 提供了一些在 RETURN 子句中使用的聚合函数。 它类似于 SQL 中的 GROUP BY 子句。
我们可以使用 MATCH 命令中的 RETURN + 聚合函数来处理一组节点并返回一些聚合值。

COUNT（计数）

它从 MATCH子 句获取结果，并计算结果中出现的行数，并返回该计数值。 所有 CQL 函数应使用“（）”括号。

函数语法

COUNT(<value>)

注意
可以是*，节点或关系标签名称或属性名称。

示例

MATCH (e:Employee) RETURN COUNT(*)

返回值：Integer

返回 expression 表达的内容的元素个数，或在 RETURN 子句中表达分类（由分类键决定）下的结果行数

  • 在一般情况下
    • 语法为
      count(expression)
    • expression 中的 null 值会被忽略，不会被计入；
    • count(null) 会返回 null；
    • 在参数前加 DISTINCET 关键字
      count(DISTINCT expression)
      则会忽略重复的内容
  • 在RETURN子句中对返回结果计数
    • 语法为
      count(*)
    • 若一行该字段返回的值为null，该行也被计入；
    • 例
MATCH (n {name: 'A'})-[r]->()
RETURN type(r), count(*)

查询结果

type(t) count(*)
"KNOWS" 3
"READS" 1
此处可以看出，聚集函数的分类按照非聚集函数的部分作为分类键形成

MAX（最大值）

它采用一组行和节点或关系的作为输入，并从给定行的 give 列中查找最大值。

函数语法

MAX(<property-name> )

返回值：一个值或一个 List
返回 expression 给定的数据中最大的

  • expression 应是一个结果集；
  • null 值会被忽略，不进行比较；
  • 在比较中
    • 数字被认为总大于任何 String；
    • String 被认为总大于任何 List；
  • List 的比较
    • 按照两个 List 中元素的前后顺序对应比较；
    • 有一处两个元素不相等时就会返回当次的比较结果，不论任何一个 List 后面是否还有元素未比较；
    • 两个 List 前面的元素相同，但有一个更长时，认为更长的那个 List 更大；
  • max(null) 会返回 null；

MIN（最小值）

它采用一组行和节点或关系的作为输入，并从给定行的give 列中查找最小值。

函数语法

MIN(<property-name> )

返回值：一个值或 List
返回给定的 expression 中最小的

  • expression 应是一个结果集；
  • null 值会被忽略，不进行比较；
  • 在比较中
    • String 被认为总小于于任何数字；
    • List 被认为总小于任何 String；
  • List 的比较
    • 按照两个 List 中元素的前后顺序对应比较；
    • 有一处两个元素不相等时就会返回当次的比较结果，不论任何一个 List 后面是否还有元素未比较；
    • 两个 List 前面的元素相同，但有一个更长时，认为更短的那个 List 更小；
  • min(null) 会返回 null；
    注意
    应该是节点或关系的名称。

示例

MATCH (e:Employee) 
RETURN MAX(e.salary),MIN(e.salary)

AVG（平均值）

它采用一组行和节点或关系的作为输入，并从给定行的give 列中查找平均值。

函数的语法

AVG(<property-name> )

返回值：与 expression 表达的数字相同

  • avg(null) 会返回 null；
  • expression 不为数字类型，则会返回一个错误；
  • avg() 的参数可以是时间段；

SUM（求和）

它采用一组行和节点或关系的作为输入，并从给定行的give 列中查找求和值。

函数的语法

SUM(<property-name> )

返回值：Integer/Float/Duration

  • sum(null) 会返回 0；
  • 为 null 的值会被忽略；

示例

MATCH (e:Employee) 
RETURN SUM(e.salary),AVG(e.salary)

此命令从数据库中可用的所有 Employee 节点查找总和平均值.

collect

collect(expression)

返回值：List
将 expression 表达的所有值聚合成一个 List 并返回

  • 返回的 List 中的元素并不一定都是同一类型的数据；
  • expression 中的 null 值会被忽略，不加入至 List；
  • collcet(null) 会返回一个空 List；

percentileCont

percentileCont(expression, percentile)

返回值：Float
对 expression 表达的值，按照 percentile 的比例找出对应的结果

  • expression 应该是数字表达式；
  • percentile 的值介于 0.0 与 1.0 之间；
  • percentileCont(null, percentile) 会返回 null；
  • expression 中的值按照顺序获得其对应的占比，如
数据集
13
33
44
其中每个数的占比依次为，33.3%、66.7%、100%
  • 对于 expression 的数据集中没有对应比例数字的情况，使用插值法在最近的两个数字间找出结果，如对上面的数据集进行如下查询
UNWIND[13,33,44] as n
RETURN percentileCont(n, 0.4)

得到结果 29.0，该数值是在 13 与 33 之间按照比例通过插值法得到的

percentileDisc

percentileDisc(expression, percentile)
返回值：Integer 或 Float

  • expression 应该是数字表达式；
  • percentile 的值介于 0.0 与 1.0 之间；
  • percentileDisc(null, percentile)会返回 null；
  • 对于 expression 的数据集中没有对应比例数字的情况，使用取整法在最近的数字中找出结果，如对上一个数据集进行如下查询
UNWIND[13,33,44] as n
RETURN percentileDisc(n,0.5)

得到结果 33，该数值是通过取整法在距离比例 0.5 最近的位置找到的数

stDev

stDev(expression)

返回值：Float
计算数据集的标准差

  • 对样本总体的一个样本或一个无偏估计计算标准差
  • 计算时，分母为 N-1；
  • stDev(null) 会返回 0；
  • 为 null 的值会被忽略；
  • expression 应为数字；

stDevP

stDevP(expression)

返回值：Float
计算数据集的标准差

  • 对样本总体计算标准差；
  • 计算时，分母为N；
  • stDev(null) 会返回 0；
  • 为 null 的值会被忽略；
  • expression 应为数字；

关系函数

Neo4j CQL 提供了一组关系函数，以在获取开始节点，结束节点等细节时知道关系的细节。

关系函数列表

S.No. 功能 描述
1。 STARTNODE 它用于知道关系的开始节点。
2。 ENDNODE 它用于知道关系的结束节点。
3。 ID 它用于知道关系的 ID。
4。 TYPE 它用于知道字符串表示中的一个关系的 TYPE。

现在我们将通过示例详细讨论每个 Neo4j CQL 关系函数

STARTNODE（关系的开始节点）

它需要一个字符串作为输入并转换为大写字母。 所有CQL函数应使用“（）”括号。

函数语法

STARTNODE (<relationship-label-name>)

注意：
可以是来自 Neo4j 数据库的节点或关系的属性名称。

示例

MATCH (a)-[movie:ACTION_MOVIES]->(b) 
RETURN STARTNODE(movie)

ENDNODE（关系的结束节点）

MATCH (a)-[movie:ACTION_MOVIES]->(b) 
RETURN ENDNODE(movie)

ID TYPE

MATCH (a)-[movie:ACTION_MOVIES]->(b) 
RETURN ID(movie),TYPE(movie)

列表函数

List functions

keys

keys(expression)

返回值：List
返回一个 Node/List/relationship 的所有属性的键名构成的 List

  • expression 应为一个 Node/List/relationship；
  • keys(null) 返回 null；

labels

labels(node)

返回值：List
返回一个 Node 的所有标签
labels(null) 会返回 null

nodes

nodes(path)

返回值：List
返回一个 Path 上的所有节点
nodes(null) 会返回 null

range

range(start, end [, step])

返回值：List
返回一个由从 start 到 end 的按顺序组成的 List

  • 步进
    • 可以不设置步进长度，默认为 1
      RETURN range(1,10)
    • 可以设置步进长度
      RETURN range(1,10,5)
    • 最后一个元素+步进长度超过 end 大小限制时，会停止加入元素直接返回，如
      RETURN range(1,10,5)
      会返回[1,6]
    • 步进可以是负数，此时判断自 start 起每个数是否小于 end
      RETURN range(1,10,-1)
      会返回[]
    • 步进为 0 时会返回一个错误；

reduce

reduce(accumulator = initial, variable IN list | expression)

返回值：Integer 或 Float 或由 expression 指定的数据类型
设定一个变量作为累加器 accumulator，初始化该累加器的值，遍历 list 中的每一个元素，执行 expression 的操作后，expression 的结果计入累加器

with ['a','b','c'] as char
return reduce(table = '',s in char |table + s)

返回"abc"

relationships

relationships(path)

返回值：List
返回 path 中所有关系组成的 List

reverse

reverse(original)

返回值：List
反转 original 中所有元素顺序后返回该 List

tail

tail(list)

返回值：List
返回 list 中除去第一个元素后剩下元素组成的 List，顺序不变

toBooleanList

toBooleanList(list)

返回值：List
将 list 中所有可被识别为 "true" 或 "false" 的值转为 Boolean 类型，然后返回该 List

  • 值为 null 的元素会被保留；
  • 本身为 Boolean 类型的元素会被保留；
  • list 本身为 null，会返回 null；
  • "true" 或 "false" 在字符串中其前后可以有空格；
  • 每个元素的转换由函数 toBooleanOrNull() 执行，无法被识别的情况会返回一个 null 元素；
  • 如果 list 不是 List 类型，会返回一个错误；

toFloatList

toFloatList(list)

返回值：List
将 list 中所有可被识别为数的元素转换为 Float 类型，然后返回该 List

  • 值为 null 的元素会被保留；
  • 本身为 Float 类型的元素会被保留；
  • list 本身为 null，会返回 null；
  • 每个元素的转换由函数 toFloatOrNull() 执行，无法被识别的情况会返回一个 null 元素；
  • 如果 list 不是 List 类型，会返回一个错误；

toIntegerList

toIntegerList(list)

返回值：List
将 list 中所有可被识别为整数的元素转换为 Integer 类型，然后返回该 List

  • 值为 null 的元素会被保留；
  • 本身为 Integer 类型的元素会被保留；
  • list 本身为 null，会返回 null；
  • 每个元素的转换由函数 toIntegerOrNull() 执行，无法被识别的情况会返回一个 null 元素；
  • 如果 list 不是 List 类型，会返回一个错误；

toStringList()

toIntegerList(list)

返回值：List
将 list 中所有可被识别为字符的元素转换为 String 类型，然后返回该 List

  • 值为 null 的元素会被保留；
  • 本身为 Intege r类型的元素会被保留；
  • list 本身为 null，会返回 null；
  • 每个元素的转换由函数 toStringOrNull() 执行，无法被识别的情况会返回一个 null 元素；
  • 如果 list 不是 List 类型，会返回一个错误；

数学函数

Mathematical functions

数

-numeric

abs

abs(expression)

返回 expression 的绝对值
abs(null) 会返回 null；

ceil

ceil(expression)

返回值：Float
向上取整，但返回的类型是浮点数
ceil(null) 会返回 null

floor

floor(expression)

返回值：Float
向下取整，但返回的类型是浮点数
floor(null) 会返回 null

rand

rand()

返回值：Float
返回一个随机数，值域是 [0,1)

round

round(expression[,precision[,mode]])

返回值：Float
返回 expression 最近的整数，但返回类型是浮点数

  • round(null) 会返回 null；

  • 对于expression=n+12,n∈Z，
    round(expression)=n+1

  • 可以指定精确度，precision 会指定返回结果精确到小数点后第几位
    round(3.141592, 3)

    会返回 3.142

  • 可以指定取整模式 mode，mode 应为 String 且可选模式如下

mode 描述
CEILING 向上取整，更大值
DOWN 向0取整，绝对值更小值
FLOOR 向下取整，更小值
HALF_DOWN 中间值向0取整，绝对值更小值；其余值取最近
HALF_EVEN 中间值在位数允许时取自身，否则取最近的偶数；其余值取最近
HALF_UP 中间值在precision不为0时，向绝对值更大值取整，precision为0时，向0取整；其余值取最近
UP 向绝对值更大值取整

sign

sign(expression)

返回值：Integer
依据 expression 的正负号返回一个整数

  • expression 为0则返回 0；
  • expression 为正则返回 1；
  • expression 为负则返回 -1；
  • sign(null) 会返回 null；

对数

-logarithmic

e

e()

返回值：Float
返回自然对数 e

RETURN e()

结果

e()
2.718281828459045

exp

exp(expression)

返回值：Float
返回 e 的 expression 次方
exp(null) 会返回 null；

log

log(expression)

返回值：Float
返回以自然对数 e 为底、以 expression 为真数的对数的值

  • log(null) 会返回 null；
  • log(0) 会返回 -Infinity；
  • expression 为负数时返回 NaN；
    此处此处官方文档声明会返回，实则不然，以下同理

log10

log10(expression)

返回值：Float
返回以 10 为底、以 expression 为真数的对数的值

  • log10(null) 会返回 null；
  • log10(0) 会返回 -Infinity；
  • expression 为负数时返回 NaN；

sqrt()

sqrt(expression)

返回值：Float
返回 expression 的平方根

  • sqrt(null) 会返回 null；
  • expression 为负数时返回 NaN；

三角

-trigonometric
cypher 中的三角函数有以下这些

  • acos()
  • asin()
  • atan()
  • atan2()
  • cos()
  • cot()
  • sin()
  • tan()
  • haversin()
    其参数单位均为弧度制
    之外，有以下这些函数

pi

pi()

返回值：Float
返回 π

RETURN pi()

结果为 3.141592653589793
由于实际上 pi() 不是数学意义上的π，sin(0.5*pi()) 的值为 1，但 sin(pi()) 值为1.2246467991473532e-16

degrees

degrees(expression)

返回值：Float
将 expression 表达的弧度制转为角度
degrees(null) 会返回 null

radians

radians()

返回值：Float
将 expression 表达的角度转为弧度制
radians(null) 会返回 null

LOAD CSV函数

LOAD CSV functions
本节函数均应在一个 LOAD CSV 查询段中使用，其他情况下回返回 null

linenumber

linenumber()

返回值：Integer
返回当前 LOAD CSV 正在使用的行号

file

file()

返回值：String
返回 LOAD CSV 正在使用的文件的绝对路径

用户定义函数

User-defined functions
使用用户定义的函数

其他函数

除此之外，neo4j 中还有 Point/Duration/Date/Time/Locatime/Localdatetime/Datetime 类型的函数

posted @ 2025-08-03 17:42  Thousand_Mesh  阅读(54)  评论(0)    收藏  举报