Cypher笔记（一）

其他 2018-11-05 09:41:49 阅读次数: 0

Cypher笔记（一）

更详细的内容请阅读《neo4j权威指南》

运算符

  • 数学运算符：+、-、*、/、%、^
  • 比较运算符：=、<>、<、>、<=、>=、IS NULL、IS NOT NULL
  • 布尔运算符：AND、OR、XOR、NOT
  • 字符串运算符：+、=~
  • 列表运算符：+、IN

语句

  • 读语句：MATCH、OPTIONAL MATCH、WHERE、START、Aggregation、LOAD CSV
  • 写语句：CREATE、MERGE、SET、DELETE、REMOVE、FOREACH、CREATE UNIQUE
  • 通用语句：RETURN、ORDER BY、LIMIT、SKIP、WITH、UNWIND、UNION、CALL
  • 字符串匹配：STARTS WITH、ENDS WITH、CONTAINS
MATCH

MATCH是模式描述的一部分，匹配的时候就会考虑到WHERE语句中的断言，而不是匹配之后。

OPTIONAL MATCH

用于搜索模式中描述的匹配项，对于找不到的项用null代替。

WHERE

在WITH和START中用于过滤结果，在MATCH和OPTIONAL MATCH中为模式增加约束，而不能看作匹配完成后的结果过滤

START

通过遗留索引查找开始点

START n = node:Pig(name = 'A') RETURN n
START n = node:Pig('name:A') RETURN n
START r = relationship:Own(name = 'Andres') RETURN r
Aggregation
  • count：count(*)用于计算匹配的行数，count(<expression>)用于计算<expression>中的非空值的数量
  • sum：计算所有值之和，空值会被丢弃
  • avg：计算数值列平均值
  • percentileDisc：计算给定值在一个组中的百分位，取值0.0到1.0。它使用舍入法返回最接近百分位的值
  • percentileCont：计算给定值在一个组中的百分位，取值0.0到1.0。采用线性插值的方法，在两个值之间计算一个加权平均数
  • stdev：计算给定值在一个组中的标准偏差，采用标准的two-pass方法，以N-1作为分母，当以部分样本作为无偏估计时应使用stdev；当计算整个样本的标准偏差时应使用stdevp
  • stdevp：计算给定值在一个组中的标准偏差
  • max
  • min
  • collect：将所有值收集起来放入一个列表，空值会被忽略
  • distinct：去掉重复值
MATCH (n { name: 'A' })-->(x) RETURN n, count(*) // 返回了开始节点和与之关联的节点数量
LOAD CSV

用于从CSV文件中导入数据

  • CSV文件的URL可以由FROM后面紧跟的任意表达式来指定
  • 需要使用AS来为CSV数据指定一个常量
  • LOAD CSV支持gzip、Deflate和ZIP压缩的资源
  • CSV文件可以存在数据库服务器上，通过file:///URL来访问。LOAD CSV也支持通过HTTPS、HTTP、FTP来访问CSV文件
  • LOAD CSV支持HTTP重定向，但基于安全考虑重定向时不能该表协议类型，比如冲HTTPS到HTTP
MERGE

确保图数据库中存在某个特定的模式，如果不存在就创建它，如果存在则合并属性（逻辑或）

MATCH (person:Person) MERGE (city:City { name: person.bornIn }) RETURN city

MERGE (keanu:Person { name: 'Keanu Reeves' })
ON CREATE SET keanu.created = timestamp()
RETURN keanu.name, keanu.created

MERGE (person:Person)
ON MATCH SET person.found  = True
RETURN person.name, person.found

MERGE (keanu:Person { name: 'Keanu Reeves' })
ON CREATE SET keanu.created = timestamp()
ON MATCH SET keanu.lastSeen = timestamp(), keanu.found = True
RETURN keanu.name, keanu.created, keanu.lastSeen
// 如果节点不存在则设置created属性，否则设置lastSeen和found属性

CREATE CONSTRAINT ON (n:Person) ASSERT n.name IS UNIQUE
CREATE CONSTRAINT ON (n:Person) ASSERT n.role IS UNIQUE
MERGE (michael:Person{ name: 'Michael Douglas', role: 'Grodon Gekko' }) RETURN michael
SET

用于更新节点的标签以及节点和关系的属性

MATCH (n { name: 'Andres' }) SET n.name = NULL RETURN n // 删除节点属性

MATCH (at { name: 'Andres' }), (pn { name: 'Peter' }) SET at = pn RETURN at, pn // 复制属性

MATCH (peter { name: 'Peter' }) SET peter += { hungry: TRUE, position: 'Entrepreneur' } RETURN peter

MATCH (n { name: 'Stefan' }) SET n:German:Bossman RETURN n
DELETE

删除图元素（关系、节点和路径）。注意不能只删除节点，而不删除与之关联的关系，要么显示地删除对应的关系，要么使用DETACH DELETE

MATCH (n { name: 'Andres' }) DETACH DELETE n
REMOVE

用于删除图元素的属性和标签

MATCH (n { name: 'Andres' }) REMOVE n.age, n:German:Swedish RETURN n
FOREACH

用于更新列表中的数据，或者来自路径的组建，或者来自聚合的结果

MATCH p = (begin)-[*]-(END)
WHERE begin.name = 'A' AND END.name = 'D'
FOREACH (n IN nodes(p) | SET n.marked = TRUE )

MATCH (a:Person {name: 'A'})
FOREACH (name IN ['Mike', 'Carl', 'Bruce'] | CREATE (a)-[:FRIEND]->(:Person {name: 'name'}))
CREATE UNIQUE

尽可能的匹配，然后创建为匹配到的。MERGE并不能很强的保证关系的唯一性。CREATE UNIQUE不回去修改现有图。

MATCH (root { name: 'root' }) CREATE UNIQUE (root)-[:LOVES]-(someone:German { alone: false }) RETURN someone
// 原本root节点没有与任何节点有LOVES关系，因此创建了一个新的节点与root建立LOVES关系
ORDER BY

紧跟RETURN和WITH，指定了输出结果如何排序。升序排列时空值总在结果末尾，降序排列相反。

MATCH (n) RETURN ORDER BY n.name, n.age DESC
// 多属性排序，先根据第一个属性排序，值相同时再检查第二个属性，依次类推

MATCH (n) RETURN n ORDER BY n.name SKIP toInt(3 * rand()) + 1 LIMIT toInt(3 * rand()) + 1
WITH

将分段的查询部分连接在一起，查询结果从一部分以管道的形式传递到另一部分作为开始点。操作可以改变结果的形式和数量。当写部分基于读部分的结果时，两者之间的转换必须使用WITH。

MATCH (david { name: 'David' })--(otherPerson)-->()
WITH otherPerson, count(*) AS foaf
WHERE foaf > 1 RETURN otherPerson

MATCH (n) WITH n ORDER BY n.name DESC LIMIT 3 RETURN collect(n.name)

MATCH (n { name: 'Anders' })--(m)
WITH m ORDER BY m.name DESC LIMIT 1
MATCH (m)--(o) RETURN o.name
UNWIND

将一个列表展开为一个行的序列

UNWIND [1, 2, 3] AS x RETURN x

WITH [1, 1, 2, 2] AS coll UNWIND coll AS x WITH DISTINCT x RETURN collect(x) AS set
UNION

将多个查询结果组合起来

MATCH (n:Actor) RETURN n.name AS name UNION ALL MATCH (n:Movie) RETURN n.title AS name
// UNION ALL将两个查询的结果组合在一起，结果包含重复行

MATCH (n:Actor) RETURN n.name AS name UNION MATCH (n:Movie) RETURN n.title AS name
// 结果无重复值
CALL

用于调用数据库中的过程。使用CALL语句调用过程时需要指定所需要的参数，可以通过在过程名的后面使用都好分隔的列表来显式地指定，也可以用查询参数来作为过程调用的实参，后者仅适用于在单独的过程调用中作为参数，即整个查询语句只包含一个单一的CALL调用。大多数过程返回固定列的记录流。YIELD子句用于显示地选择返回结果集中的哪些部分并绑定到一个变量以供后续的查询引用。在一个更大的查询内部，过程调用返回的结果可以显示地使用YIELD引入一个WHERE子句来过滤结果。

CALL db.labels
CALL `db`.`labels`
CALL org.neo4j.procedure.example.addNodeToIndex('users', 0, 'name')
CALL org.neo4j.procedure.example.addNodeToIndex('users', $node, 'name')

CALL db.labels() YIELD result AS label WHERE label CONTAINS 'User' RETURN count(label) AS numLabels
函数


  • 断言函数
    • all：判断是否一个断言适用于列表中的所有元素
      • all(variable IN list WHERE predicate)
    • any：判断是否一个断言至少适用于列表中的一个元素
      • any(variable IN list WHERE predicate)
    • none：如果断言不适用于列表中的任何元素，则返回true
      • none(variable IN list WHERE predicate)
    • single：如果断言刚好只适用于列表中的一个元素，返回true
      • single(variable IN list WHERE predicate)
    • exists：如果数据库中存在该模式或者节点中存在该属性时，返回true
      • exists(pattern-or-property)
  • 标量函数：返回一个单值
    • size：返回表中元素的个数
      • size(list)
    • size：模式表达式的size，计算的时结果集元素的个数，而不是表达式本身的长度
      • size(pattern expression)
    • length：返回路径的长度
      • length(path)
    • length：返回字符串的长度
      • length(string)
    • type：返回字符串代表的关系类型
      • type(relationship)
    • id：返回关系或者节点的id
      • id(property-container)
    • coalesce：返回表达式列表中第一个非空的值，如果所有实参都为空，则返回null
      • coalesce(expression[, expression]*)
    • head：返回列表中的第一个元素
      • head(expression)
    • last：返回列表中的最后一个元素
      • last(expression)
    • timestamp：返回当前时间与1970年1月1日午夜之间的差值，单位毫秒
      • timestamp()
    • startNode：返回一个关系的开始节点
      • startNode(relationship)
    • endNode：返回一个关系的结束节点
      • endNode(relationship)
    • properties：将实参转为属性值的map。如果实参是一个节点或者关系，返回的就是节点或关系的属性的map，如果实参已经是一个map，那么原样返回
      • properties(expression)
    • toInt、toFloat
  • 列表函数
    • nodes：返回一条路径中的所有节点
    • relationships：返回一条路径中的所有关系
    • labels：以字符串列表的形式返回一个节点的所有标签
    • keys：以字符串列表的形式返回一个节点、关系或者map的所有属性的名称
    • extract：从节点或者关系列表中返回单个属性或者某个函数的值。它将遍历整个列表，针对列表中的每一个元素运行一个表达式，然后以列表的形式返回这些结果。它的工作方式类型类似于Lisp和Scala等函数式语言中的map方法
      • extract(variable IN list | expression)
    • filter：返回列表中满足断言要求的所有元素
      • filter(variable IN list WHERE predicate)
    • tail：返回列表中除了首元素之外的所有元素
    • range：返回某个范围内的数值，值默认步长为1，范围包含起始边界
      • range(start, end[, step])
    • reduce：对列表中的每一个元素执行一个表达式，将表达式的结果存入一个累加器
      • reduce(accumulator = initial, variable IN list | expression)
  • 数学函数
    • abs：绝对值
    • ceil：返回大于等于实参的最小整数，上取整
    • floor：返回小于等于实参的最大整数，下取整
    • round：返回距离表达式值最近的整数，四舍五入
    • sign：返回表达式正负号
    • rand：返回(0, 1)之间一个随机数，返回的数值在整个区间均匀分布
    • log：自然对数
    • log10：常用对数
    • exp：返回e^n
    • e：返回自然对数的底
    • sqrt：平方根
    • sin、cos、tan、cot、asin、acos、atan、atan2
    • pi：常数pi
    • degrees：弧度转度
    • radians：度转弧度
    • haversin：半正矢
  • 字符串函数
    • replace：replace(original, search, replace)
    • substring：substring(original, start[, length])
    • left：left(original, length)
    • right：right(original, right)
    • ltrim、rltrim、trim：移除空白字符
    • lower、upper
    • split：split(original, splitPattern)
    • reverse
    • toString

自定义函数
自定义函数用Java语言编写，可部署到数据库中，调用方式和其他Cypher函数一样，举个例子： 
MATCH (n:Member) RETURN org.neo4j.function.example.join(collect(n.name))

编写自定义函数类似于过程的创建，但它采用 @UserFunction注解，并且只返回一个单值。有效的输出类型包括long、Long、double、Double、boolean、Boolean、String、Node、Relationship、Path、Map<String, Object>、List<T>，举个例子： 
package example;
import org.neo4j.procedure.Name;
import org.neo4j.procedure.Procedure;
import org.neo4j.procedure.UserFunction;

public class Join {
    @UserFunction
    @Description("example.join(['s1', 's2', ...], delimiter) - join the given strings with the given delimiter.")
    public String join(
    @Name("strings") List<String> strings,
    @Name(value = "delimiter", defaultValue = ",") String delimiter) {
        if (strings == null || delimiter == null) return null;
        else return Strings.join(delimiter, strings);
    }
}
>

其他实例

MATCH (john {name: 'John'})-[:friend]->(fof)
RETURN john.name, fof.name

MATCH (user)-[:friend]->(follower)
WHERE user.name IN ['Joe', 'John', 'Sara', 'Maria', 'Steve'] AND follower.name = ~'S.*'
RETURN user.name, follower.name

MATCH (n {name: 'John'})-[:FRIEND]-(friend)
WITH n, count(friend) AS friendsCount
WHERE friendsCount > 3
RETURN n, friendsCount

MATCH (n {name: 'John'})-[:FRIEND]-(friend)
WITH n, count(friend) AS friendsCount
SET n.friendsCount = friendsCount
RETURN n.friendsCount

CREATE (adam:User{name: 'Adam'}), (pernilla:User{name: 'Pernilla'}), (david:User{name: 'David'}),
(adam)-[:FRIEND]->(pernilla), (pernilla)-[:FRIEND]->(david)

MATCH (user: User{name: 'Adam'})-[r1: FRIEND]-()-[r2:FRIEND]-(friend_of_a_friend)
RETURN friend_of_a_friend.name AS fofName

MATCH (user:User{name: 'Adam'})-[r1:FRIEND]-(friend), (friend)-[r2:FRIEND]-(friend_of_a_friend)
RETURN friend_of_a_friend.name AS fofName

MATCH (user:User{name: 'Adam'})-[r1:FRIEND]-(friend)
MATCH (friend)-[r2:FRIEND]-(friend_of_a_friend)
RETURN friend_of_a_friend.name AS fofName

CYPHER 2.3
START n = node:nodes(name = 'A')
RETURN n

MATCH (n)
RETURN
CASE n.eyes
WHEN 'blue'
THEN 1
WHEN 'brown'
THEN 2
ELSE 3 END AS result

MATCH (a) WHERE a.surname STARTS WITH 'Sven' AND a.prename ENDS WITH 'PY' RETURN a

MATCH (n) WHERE n.name = ~'.*h.*' AND n.address = ~'Sweden\\/Malmo' RETURN n // 注意反斜杠也要转义

MATCH (n) RETURN n.name SKIP 1 LIMIT 3

MATCH (n) WHERE id(n) = 10 RETURN n.name

MATCH (n) WHERE id(n) IN [1, 3, 54] RETURN n.name

MATCH (n) WHERE 21 < n.age < 30 RETURN n

MATCH (n) RETURN n // 这是注释

(a)--(b)
(a)-->(b)<--(c)
(a)-[{blocked: false}]->(b)
(a)-[r:TYPE1 | TYPE2]->(b)
(a)-[*2]->(b)
(a)-[*3..]->(b)
(a)-[*3..5]->(b)

MATCH (me)-[:KNOWS*1..2]-(remote_friend)
WHERE me.name = 'Filipa'
RETURN remote_friend.name

p = (a)-[*3..5]->(b)

RETURN [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] AS list
RETURN range(0, 10)[3]
RETURN range(0, 10)[-3]
RETURN range(0, 10)[0..3]
RETURN range(0, 10[0..-5]
RETURN size(range(0, 10))

RETURN [x IN range(0, 10) WHERE x % 2 = 0 | x^3] AS result
RETURN [x IN range(0, 10) | x^3] AS result // ^是数学运算符

MATCH (a:Person{name: 'Charile Sheen'})
RETURN [(a)-->(b) WHERE b:Movie | b.year] AS years

RETURN {key: 'Value', listKey: [{ inner: 'Map1' }, { inner: 'Map2'}]}

MATCH (actor:Person {name: 'Charlie Sheen'})-[:ACTED_IN]->(movie:Movie)
RETURN actor { .name, .realName, movies: collect(movie { .title, .year })}

MATCH (actor:Person)-[:ACTED_IN]->(movie:Movie)
WITH actor, count(movie) AS nrOfMovies
RETURN actor { .name, nrOfMovies }

MATCH (actor:Person{ name: 'Charlie Sheen' })
RETURN actor { .*, .age }

MATCH (wallstreet { title: 'Wall Street' })<-[:ACTED_IN | :DIRECTED]-(person)
RETURN person.name

MATCH (n { name: 'Rob Reiner'})-[r:`TYPE WITH SPACE`]->() RETURN type(r)

MATCH (martin { name: 'Charlie Sheen'})-[:ACTED_IN*1..3]-(movie:Movie) RETURN movie.title
// 结果：['Wall Street', 'The American President', 'The American President']

MATCH p = (michael {name: 'Michael Douglas'})-->() RETURN p
// 结果：[Node[2]\{name:"Michael Douglas"\},:ACTED_IN[5]\{role:"President Andrew Shepherd"\},Node[6]\{title:"The American President"\}]

MATCH (a)-[r]-(b) WHERE id(r)=0 RETURN a,b
// 尝试匹配两个方向的关系

MATCH (martin:Person { name: 'Martin Sheen' }), (oliver:Person { name: 'Oliver Stone' }),
p = shortestPath((martin)-[*..15]-(oliver))
RETURN p

MATCH (martin:Person { name: 'Martin Sheen' }), (oliver:Person { name: 'Oliver Stone' }),
p = shortestPath((martin)-[*..15]-(oliver))
WHERE NONE (r IN rels(p) WHERE type(r) = 'FATHER') // WHERE断言确保不考虑两个节点间的父亲/儿子关系
RETURN p

MATCH (martin:Person { name: 'Martin Sheen' }), (michael:Person { name: 'Michael Douglas' }),
p = allShortestPaths((martin)-[*]-(michael))
RETURN p

MATCH (a:Movie {title: 'Wall Street'}) OPTIONAL MATCH (a)-->(x) RETURN x // 返回null，因为没有外向关系

MATCH (n) WHERE n:Swedish AND n.name = 'Peter' OR NOT exists(n.name) AND n[toLower('AGE')] < 30 RETURN n
// has被exists代替了

MATCH (n) WHERE n.name = ~'(?i)ANDR.*' RETURN n // 非大小写敏感的正则表达式

MATCH (tobias { name: 'Tobias' }), (others)
WHERE others.name IN ['Andres', 'Peter'] AND (tobias)<--(others) // 模式作为断言
RETURN others

MATCH (n)-[r]->() WHERE n.name = 'Andres' AND type(r) = ~'K.*' RETURN r

MATCH (n) WHERE n.belt = 'white' OR n.belt IS NULL RETURN n

CREATE (n:Person:Swedish) RETURN n // 多标签节点

MATCH (`Tom Smith` { name: 'Tom Smith' }) RETURN `Tom Smith`.name AS source

猜你喜欢

转载自blog.csdn.net/qq_37242224/article/details/81325625
今日推荐
周排行
成为C++高手之宏与枚举
在CAD二次开发中使用进度条
Js插件ECharts，HighCharts学习网址整理
Celery提交任务出错(on windows.)
cephfs内核客户端性能追踪
thinkphp中PHPExcel用法
EntityFramework动态组合多排序字段
汇编语言（八）实验9 根据材料编程
安装ubuntu后必须做的事情（对我而言）
JS函数式编程
每日归档
更多
2024-10-22(0)
2024-10-21(0)
2024-10-20(0)
2024-10-19(0)
2024-10-18(0)
2024-10-17(0)
2024-10-16(0)
2024-10-15(0)
2024-10-14(0)
2024-10-13(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022