Cypher进阶(函数、索引)

server/2025/2/6 13:52:54/

文章目录

  • Cypher进阶
    • Aggregation
      • count()函数
      • 统计函数
      • collect()函数
    • unwind
    • foreach
    • merge
    • union
    • load csv
    • call
  • 函数
    • 断言函数
      • all()
      • any()
      • ~~exists()~~
      • is not null
      • none()
      • single()
    • 标量函数
      • coalesce()
      • startNode()/endNode()
      • id()
      • length()
      • size()
    • 列表函数
      • nodes()
      • keys()
      • range()
      • reduce()
    • 数学函数
      • 数值函数
      • 对数函数
    • 字符串函数
    • 索引
      • 创建索引
      • 查看索引
      • 删除索引
      • 使用索引

Cypher_1">Cypher进阶

  • 构造需要使用到的图
sql">create (A:Person {name:"A",age:13})
create (B:Person {name:"B",age:33,eyes:"blue"})
create (C:Person {name:"C",age:44,eyes:"blue"})
create (D1:Person {name:"D",eyes:"broen"})
create (D2:Person {name:"D"})
create (A)-[:knows]->(B)
create (A)-[:knows]->(C)
create (A)-[:knows]->(D1)
create (B)-[:knows]->(D2)
create (C)-[:knows]->(D2)

在这里插入图片描述

sql">match (n:Person) return n

在这里插入图片描述

Aggregation

  • Cypher 支持使用聚合（Aggregation）来计算聚在一起的数据，类似 SQL 中的 group by。聚合函数有多个输入值，然后基于它们计算出一个聚合值。例如，avg 函数计算多个数值的平均值。min 函数用于找到一组值中最小的那个值。

count()函数

  • count用于计算行的数量.
  • 查询A的标签以及好友数量
sql">match (n {name:"A"})-->(x) return labels(n), n.age, count(*)

在这里插入图片描述

  • 查询A相关的关系数量
sql">match (n {name:"A"}) -[r]->() return type(r),count(*)

在这里插入图片描述

  • 查询A的好友数量
sql">match (n {name:"A"})-->(x) return count(x)

在这里插入图片描述

  • 查询给空属性的节点数量
sql">match (n:Person) return count(n.age)
  • 查询朋友数量，去重以及未去重情况
sql">match (me:Person)-->(friend:Person)-->(friend_of_friend:Person)
where me.name="A"
return count(distinct friend_of_friend),count(friend_of_friend)

在这里插入图片描述

统计函数

sql">match(n:Person) return sum(n.age) //求和
match(n:Person) return avg(n.age) //平均值
match(n:Person) return max(n.age) //最大值
match(n:Person) return min(n.age) //最小值

collect()函数

  • collect()将所有值收集起来放入到一个集合中，排除null值
sql">match (n:Person) return collect(n.age)

在这里插入图片描述

unwind

  • unwind将列表展开为一个行的序列
sql">unwind [1,2,3,null] as x return x, 'val' as y

在这里插入图片描述

  • 将列表展开并且去重后形成新的列表
sql">with [1,1,2,2] as coll unwind coll as x with distinct x return collect(x) as setOfVals

在这里插入图片描述

  • 将a、b两个列表连接形成新的列表，再将其展开进行操作，然后去重，最后收集
sql">with [1,2,2] as a,[3,4] as b
unwind(a+b) as x
with distinct x
return collect(x) as y

在这里插入图片描述

  • 嵌套列表的展开操作
sql">with [[1,2],[3,4],5] as nested
unwind nested as x
unwind x as y
return collect(y)

sql">[1, 2, 3, 4, 5]

在这里插入图片描述

foreach

  • foreach主要用于更新列表中的数据，或者来自路径的组件、聚合的结果。
  • 再foreach括号内，可以执行任何的更新命令，包括create，create unique，delete，foreach。如果希望对列表中的每个元素执行额外的match命令，使用unwind命令更合适。
  • 构造数据
sql">create (A:Person {name:"A"})
create (B:Person {name:"B"})
create (C:Person {name:"C"})
create (D:Person {name:"D"})
create (A)-[:knows]->(B)
create (B)-[:knows]->(C)
create (C)-[:knows]->(D)

在这里插入图片描述
在这里插入图片描述

  • 循环设置节点的属性marked=true
    sql">match p=(begin)-[*]->(end)
where begin.name='A' and end.name='D'
foreach (n in nodes(p) | set n.marked=true)

merge

  • merge或者匹配已存在的节点并绑定到它，或者创建新的然后绑定到它。它有点像match和create的组合。
  • 当在整个模式上使用merge时，要么是整个模式匹配到，要么是整个模式被创建。merge不能部分地应用于模式，如果希望部分匹配，可以将模式拆分为多个merge语句。
sql">//删除数据
match (n) detach delete n
//构造数据
CREATE (A:Person {bornIn: 'New York', name: 'Charlie Sheen', chauffeurName: 'John Brown'})
CREATE (B:Person {bornIn: 'New York', name: 'Oliver Stone', chauffeurName: 'Bill White'})
CREATE (C:Person {chauffeurName: 'John Brown', bornIn: 'New Jersey', name: 'Michael Douglas'})
CREATE (D:Person {bornIn: 'Ohio', name: 'Martin Sheen', chauffeurName: 'Bob Brown'})
CREATE (E:Person {bornIn: 'New York', name: 'Rob Reiner', chauffeurName: 'Ted Green'})
CREATE (M1:Movie {title: 'Wall Street'})
CREATE (M2:Movie {title: 'The American President'})CREATE (A)-[:ACTED_IN]->(M1)
CREATE (A)-[:FATHER]->(D)
CREATE (B)-[:ACTED_IN]->(M1)
CREATE (C)-[:ACTED_IN]->(M1)
CREATE (C)-[:ACTED_IN]->(M2)
CREATE (D)-[:ACTED_IN]->(M1)
CREATE (D)-[:ACTED_IN]->(M2)
CREATE (E)-[:ACTED_IN]->(M2)RETURN *

在这里插入图片描述

在这里插入图片描述

  1. 节点未完全匹配，所以会创建节点

    sql">merge (robert:Critic) return robert,labels(robert)
merge (charlie {name:"Charlie Sheen", age: 10}) return charlie

    {"identity": 29,"labels": [],"properties": {"name": "Charlie Sheen","age": 10},"elementId": "4:c4c1679d-3dad-4695-b164-654c5485fd8c:29"
}

  2. 匹配到节点，不会创建新的节点

    sql">merge (michael:Person {name:"Michael Douglas"})
return michael.name, michael.bornIn

在这里插入图片描述

  1. 按照Person的出生地创建city节点，重新执行不会创建city节点

    sql">match (person:Person)
merge (city:City {name: person.bornIn})
return person.name,person.bornIn,city

    ╒═════════════════╤═════════════╤════════════════════════════╕
│person.name      │person.bornIn│city                        │
╞═════════════════╪═════════════╪════════════════════════════╡
│"Charlie Sheen"  │"New York"   │(:City {name: "New York"})  │
├─────────────────┼─────────────┼────────────────────────────┤
│"Oliver Stone"   │"New York"   │(:City {name: "New York"})  │
├─────────────────┼─────────────┼────────────────────────────┤
│"Michael Douglas"│"New Jersey" │(:City {name: "New Jersey"})│
├─────────────────┼─────────────┼────────────────────────────┤
│"Martin Sheen"   │"Ohio"       │(:City {name: "Ohio"})      │
├─────────────────┼─────────────┼────────────────────────────┤
│"Rob Reiner"     │"New York"   │(:City {name: "New York"})  │
└─────────────────┴─────────────┴────────────────────────────┘

  2. 当创建节点时执行 on create中的内容

    sql">merge (keanu:Person {name:"keanu Reeves"})
on create set keanu.created=timestamp()
return keanu.name,keanu.created

    ╒══════════════╤═════════════╕
│keanu.name    │keanu.created│
╞══════════════╪═════════════╡
│"keanu Reeves"│1738637550446│
└──────────────┴─────────────┘

  3. 当匹配到节点时，设置属性

    sql">merge (person:Person)
on match set person.found=true 
return person.name,person.found

    ╒═════════════════╤════════════╕
│person.name      │person.found│
╞═════════════════╪════════════╡
│"Charlie Sheen"  │true        │
├─────────────────┼────────────┤
│"Oliver Stone"   │true        │
├─────────────────┼────────────┤
│"Michael Douglas"│true        │
├─────────────────┼────────────┤
│"Martin Sheen"   │true        │
├─────────────────┼────────────┤
│"Rob Reiner"     │true        │
├─────────────────┼────────────┤
│"keanu Reeves"   │true        │
└─────────────────┴────────────┘

  4. 已经存在的节点，不执行create set，会执行match set

    sql">merge (keanu:Person {name:"Keanu Reeves"})
on create set keanu.created =timestamp()
on match set keanu.lastSeen =timestamp()
return keanu.name,keanu.created,keanu.lastSeen

    ╒══════════════╤═════════════╤══════════════╕
│keanu.name    │keanu.created│keanu.lastSeen│
╞══════════════╪═════════════╪══════════════╡
│"Keanu Reeves"│1738675666030│null          │
└──────────────┴─────────────┴──────────────┘

  5. 匹配或创建关系

    sql">match (charlie:Person {name:"Charlie Sheen"}),(wallStreet:Movie {title:"Wall Street"})
merge (charlie)-[r:ACTED_IN]->(wallStreet)
return charlie.name, type(r),wallStreet.title

    ╒═══════════════╤══════════╤════════════════╕
│charlie.name   │type(r)   │wallStreet.title│
╞═══════════════╪══════════╪════════════════╡
│"Charlie Sheen"│"ACTED_IN"│"Wall Street"   │
└───────────────┴──────────┴────────────────┘

  6. merge可以和match与merge子句一起使用

    sql">match (person:Person)
merge (city:City {name:person.bornIn})
merge (person)-[r:BORN_IN]->(city)
return person.name,person.bornIn,city

union

  • union是将多个查询结果组合起来。
    sql">create (A:Actor {name:"Anthony Hopkins"})
create (B:Actor {name:"Hitchcock"})
create (C:Actor {name:"Helen Mirren"})
create (M:Movie {title:"Hitchcock"})
create (A)-[:KNOWS]-> (C)
create (A)-[:ACTS_IN]->(M)
create (C)-[:ACTS_IN]->(M)

在这里插入图片描述

  1. 连接演员与电影的查询结果
    sql">match (n:Actor)
return n.name as name
union all match (n:Movie)
return n.title as name

    ╒═════════════════╕
│name             │
╞═════════════════╡
│"Anthony Hopkins"│
├─────────────────┤
│"Hitchcock"      │
├─────────────────┤
│"Helen Mirren"   │
├─────────────────┤
│"Hitchcock"      │
└─────────────────┘

load csv

  • load csv用于从csv文件中导入数据。
sql">//artists.csv
1,ABBA,1992
2,Roxette,1986
3,Europe,1979
4,The Cardigans,1992

sql">load csv from 'https://xxx/csv/artists.csv' as line
create (:Artist {name line[1],year: toInteger(line[2])})
  • csv文件包含头标题
sql">//artists.csv
Id,Name,Yeat
1,ABBA,1992
2,Roxette,1986
3,Europe,1979
4,The Cardigans,1992

sql">load csv from 'https://xxx/csv/artists.csv' as line
create (:Artist {name: line.name,year: toInteger(line.Year)})
  • 加载大量数据，使用periodic commit可以使neo4j每1000（默认）条提交一次
sql">using periodic commit
load csv from 'https://xxx'
create (:Artist {name line[1],year: toInteger(line[2])})//自定义提交频率
using periodic commit 500
load csv from 'https://xxx'
create (:Artist {name line[1],year: toInteger(line[2])})
  • linenumber()获取行号
sql">load csv form 'https://xxx' as line
return linenumber() as number ,line

call

  • call语句用于调用数据库中的过程。
  • 使用call语句调用过程。调用过程时，需要指定所需要的参数。可以通过在过程名的后面使用逗号分隔的列表来显式地指定，也可以使用查询参数来作为过程调用的实参。后者仅适用于在单独的过程调用中作为参数，即整个查询语句只包含一个单一的 CALL 调用。
  • 大多数的过程返回固定列的记录流，类似于 Cypher 查询返回的记录流。YIELD 子句用于显式地选择返回结果集中的哪些部分并绑定到一个变量以供后续的查询引用。在一个更大的查询内部，过程调用返回的结果可以显式地使用 YTELD 引入一个 WHERE 子句来过滤结果（类似 WITH… WHERE…。
  • Neo4j 支持 VOID 过程。VOID 过程既没有声明任何结果字段，也不返回任何结果记录。调用 VOID 过程可能有一个副作用，就是它既不允许也不需要使用 YIELD。在一个大的查询中调用 VOID 过程，就像 WITH*在记录流的作用那样简单地传递输入的每一个结果。
  • 查询当前数据库中的标签
sql">call db.labels()

╒═══════╕
│label  │
╞═══════╡
│"Movie"│
├───────┤
│"Actor"│
└───────┘
  • 复杂查询中调用过程`
sql">call db.labels() yield label return(label) as labelNumbers

╒════════════╕
│labelNumbers│
╞════════════╡
│"Movie"     │
├────────────┤
│"Actor"     │
└────────────┘
  • where设置条件
    sql">call db.labels() yield label where label contains "Person" return label

    ╒═══════╕
│label  │
╞═══════╡
│"Movie"│
└───────┘

函数

断言函数

  • 断言函数是对给定的输入返回true或false的布尔函数
sql">CREATE (p1:Person {name: 'Alice', eyes: 'brown', age: 31})
CREATE (p2:Person {eyes: 'brown', age: 61})
CREATE (p3:Person {name: 'Charlie', eyes: 'green', age: 53})
CREATE (p4:Person {name: 'Bob', eyes: 'blue', age: 25})
CREATE (p5:Person {name: 'Daniel', eyes: 'brown', age: 54})
CREATE (p6:Person {array:['one', 'two', 'three'], name: 'Eskil', eyes: 'blue', age: 41})CREATE (p1)-[:KNOWS]->(p3)
CREATE (p1)-[:KNOWS]->(p4)
CREATE (p3)-[:KNOWS]->(p5)
CREATE (p4)-[:KNOWS]->(p5)
CREATE (p4)-[:MARRIED]->(p6)

在这里插入图片描述
在这里插入图片描述

all()

  • 判断是否一个断言使用于列表中的所有元素
  • 语言L：all(variable in list where predicate)
  • 返回结果中不包含年龄小于30岁的人
sql">match p=(a)-[*1..3]->(b)
where a.name='Alice' and b.name='Daniel' and all(x in nodes(p) where x.age>30)
return p

在这里插入图片描述

any()

  • 判断是否一个断言适用于列表中的一个元素
  • 语法：any(variable in list where predicate)
sql">match (a)
where a.name='Eskil' and any(x in a.array where x='one')
return a.name,a.array

sql">╒═══════╤═══════════════════════╕
│a.name │a.array                │
╞═══════╪═══════════════════════╡
│"Eskil"│["one", "two", "three"]│
└───────┴───────────────────────┘

exists()

  • 判断是否存在该模式或者节点中是否存储属性
  • 匹配所有包含name属性的节点以及包含了married关系的标记为true
sql">match (n)
where exists(n.name)
return n.name as name,exists((n)-[:MARRIED]->()) as is_married

The property existence syntax `... exists(variable.property)` is no longer supported. Please use `variable.property IS NOT NULL`

is not null

sql">MATCH (n)
WHERE n.name IS NOT NULL
RETURN n.name AS name, EXISTS((n)-[:MARRIED]->()) AS is_married

╒═════════╤══════════╕
│name     │is_married│
╞═════════╪══════════╡
│"Alice"  │false     │
├─────────┼──────────┤
│"Charlie"│false     │
├─────────┼──────────┤
│"Bob"    │true      │
├─────────┼──────────┤
│"Daniel" │false     │
├─────────┼──────────┤
│"Eskil"  │false     │
└─────────┴──────────┘

none()

  • none()：如果断言不适用于列表中的任何元素，则返回true
  • 语法：none(variable in list where predicate)
sql">match p=(n)-[*1..3]->(b)
where n.name="Alice" and none(x in nodes(p) where x.age=25)
return p

在这里插入图片描述

single()

  • 如果断言只适用于列表中的某一个元素，返回true
  • 语法：none(variable in list where predicate)
  • 匹配节点中只包含eyes='blue’的节点
sql">match p=(n)-->(b)
where n.name="Alice" and single(var in nodes(p) where var.eyes="blue")
return p

在这里插入图片描述

标量函数

  • 清空并构造数据
sql">//删除数据
match (n) detach delete n
//构造数据
CREATE (p1:Developer {name: 'Alice', eyes: 'brown', age: 38})
CREATE (p2:Developer {name: 'Charlie', eyes: 'green', age: 53})
CREATE (p3:Developer {name: 'Bob', eyes: 'blue', age: 25})
CREATE (p4:Developer {name: 'Daniel', eyes: 'brown', age: 54})
CREATE (p5:Developer {name: 'Eskil', eyes: 'blue', age: 41, array: ['one', 'two', 'three']})CREATE (p1)-[:KNOWS]->(p2)
CREATE (p1)-[:KNOWS]->(p3)
CREATE (p2)-[:KNOWS]->(p4)
CREATE (p3)-[:KNOWS]->(p4)
CREATE (p3)-[:MARRIED]->(p5)

在这里插入图片描述
在这里插入图片描述

coalesce()

  • coalesce()：返回表达式列表中的第一个非空的值，如果所有的实参数都为空，则返回null
  • 语法：coalesce(espression [, expression]*)
  • 查询Alice的hairColor，eyes属性，由于hairColor不存在，则返回eyes
sql">match (a) where a.name="Alice" return coalesce(a.hairColor,a.eyes)

╒════════════════════════════╕
│coalesce(a.hairColor,a.eyes)│
╞════════════════════════════╡
│"brown"                     │
└────────────────────────────┘

startNode()/endNode()

  • startNode():返回一个关系中的开始节点
  • endNode():返回一个关系中的结束节点
sql">match (x {name:"Alice"})-[r]-()
return startNode(r)

╒══════════════════════════════════════════════════╕
│startNode(r)                                      │
╞══════════════════════════════════════════════════╡
│(:Developer {name: "Alice",eyes: "brown",age: 38})│
├──────────────────────────────────────────────────┤
│(:Developer {name: "Alice",eyes: "brown",age: 38})│
└──────────────────────────────────────────────────┘

sql">match (x {name:"Alice"})-[r]-()
return endNode(r)

╒════════════════════════════════════════════════════╕
│endNode(r)                                          │
╞════════════════════════════════════════════════════╡
│(:Developer {name: "Charlie",eyes: "green",age: 53})│
├────────────────────────────────────────────────────┤
│(:Developer {name: "Bob",eyes: "blue",age: 25})     │
└────────────────────────────────────────────────────┘

id()

  • id()：返回关系或节点的ID
sql">match (m) return id(m)

╒═════╕
│id(m)│
╞═════╡
│65   │
├─────┤
│66   │
├─────┤
│67   │
├─────┤
│68   │
├─────┤
│69   │
└─────┘

length()

  • length()：返回路径的长度
sql">match p=(a)-->(b)-->(c)
where a.name="Alice"
return p,length(p)

╒══════════════════════════════════════════════════════════════════════╤═════════╕
│p                                                                     │length(p)│
╞══════════════════════════════════════════════════════════════════════╪═════════╡
│(:Developer {name: "Alice",eyes: "brown",age: 38})-[:KNOWS]->(:Develop│2        │
│er {name: "Charlie",eyes: "green",age: 53})-[:KNOWS]->(:Developer {nam│         │
│e: "Daniel",eyes: "brown",age: 54})                                   │         │
├──────────────────────────────────────────────────────────────────────┼─────────┤
│(:Developer {name: "Alice",eyes: "brown",age: 38})-[:KNOWS]->(:Develop│2        │
│er {name: "Bob",eyes: "blue",age: 25})-[:KNOWS]->(:Developer {name: "D│         │
│aniel",eyes: "brown",age: 54})                                        │         │
├──────────────────────────────────────────────────────────────────────┼─────────┤
│(:Developer {name: "Alice",eyes: "brown",age: 38})-[:KNOWS]->(:Develop│2        │
│er {name: "Bob",eyes: "blue",age: 25})-[:MARRIED]->(:Developer {array:│         │
│ ["one", "two", "three"],name: "Eskil",eyes: "blue",age: 41})         │         │
└──────────────────────────────────────────────────────────────────────┴─────────┘

size()

  • 返回列表中元素的个数或字符串的长度
sql">match (a) 
where size(a.name)>6
return size(a.name) 

╒════════════╕
│size(a.name)│
╞════════════╡
│7           │
└────────────┘

列表函数

  • 列表函数返回列表中的元素
sql">CREATE (p1:Developer:Person {name: 'Alice', eyes: 'brown', age: 38})
CREATE (p2 {name: 'Charlie', eyes: 'green', age: 53})
CREATE (p3 {name: 'Bob', eyes: 'blue', age: 25})
CREATE (p4 {name: 'Daniel', eyes: 'brown', age: 54})
CREATE (p5 {name: 'Eskil', eyes: 'blue', age: 41, array: ['one', 'two', 'three']})CREATE (p1)-[:KNOWS]->(p2)
CREATE (p1)-[:KNOWS]->(p3)
CREATE (p2)-[:KNOWS]->(p4)
CREATE (p3)-[:KNOWS]->(p4)
CREATE (p3)-[:MARRIED]->(p5)

在这里插入图片描述

nodes()

  • nodes()：用于返回路径中所有的节点
sql">match p=(a)-->(b)-->(c)
where a.name="Alice" and c.name="Eskil"
return nodes(p)  

╒══════════════════════════════════════════════════════════════════════╕
│nodes(p)                                                              │
╞══════════════════════════════════════════════════════════════════════╡
│[(:Developer:Person {name: "Alice",eyes: "brown",age: 38}), ({name: "B│
│ob",eyes: "blue",age: 25}), ({array: ["one", "two", "three"],name: "Es│
│kil",eyes: "blue",age: 41})]                                          │
└──────────────────────────────────────────────────────────────────────┘

keys()

  • keys()：返回节点或关系的所有属性的名称
    sql">match (a)
where a.name="Alice"
return keys(a)  

    ╒═══════════════════════╕
│keys(a)                │
╞═══════════════════════╡
│["age", "eyes", "name"]│
└───────────────────────┘

range()

  • range()：返回某个范围内的数值。值之间的默认步长为1，范围包含起始边界值
  • 语法：range(start,end[, step])
    sql">return range(0,10), range(2,18,3)

    ╒══════════════════════════════════╤═════════════════════╕
│range(0,10)                       │range(2,18,3)        │
╞══════════════════════════════════╪═════════════════════╡
│[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]│[2, 5, 8, 11, 14, 17]│
└──────────────────────────────────┴─────────────────────┘

reduce()

  • reduce()：对列表中的每个元素执行一个表达式，将表达式结构存入一个累加器。
  • 语法：reduce(accumulator=initial, variable in list | expression)
sql">match p=(a)-->(b)-->(c)
where a.name="Alice" and b.name="Bob" and c.name="Daniel"
return reduce(totalAge=0, n in nodes(p) | totalAge+n.age) as reduction 

╒═════════╕
│reduction│
╞═════════╡
│117      │
└─────────┘

数学函数

数值函数

  1. abs()：返回实参的绝对值。
  2. ceil(): 返回大于或等于实参的最小整数。
  3. floor(): 返回小于或等于实参的最大整数。
  4. round(): 返回距离表达式值最近的整数。
  5. rand(): 返回 [0, 1) 之间的一个随机数，返回的数值在整个区间遵循均匀分布。
  6. sign(): 返回一个数值的正负。
  • 如果值为 0，返回 0。
  • 如果值为负数，返回 -1。
  • 如果值为正数，返回 1。
sql">match (a),(e)
where a.name="Alice" and e.name="Eskil"
return a.age,e.age,abs(a.age-e.age)

╒═════╤═════╤════════════════╕
│a.age│e.age│abs(a.age-e.age)│
╞═════╪═════╪════════════════╡
│38   │41   │3               │
└─────┴─────┴────────────────┘

对数函数

  1. e()：获取e
  2. exp()：返回以自然常数e为底的指数
  3. log10()：返回表达式的常用对数(以10为底)
  4. sqrt()：返回值的平方根
sql">return e(),exp(2),log(27),log10(100),sqrt(169)

╒═════════════════╤════════════════╤═════════════════╤══════════╤═════════╕
│e()              │exp(2)          │log(27)          │log10(100)│sqrt(169)│
╞═════════════════╪════════════════╪═════════════════╪══════════╪═════════╡
│2.718281828459045│7.38905609893065│3.295836866004329│2.0       │13.0     │
└─────────────────┴────────────────┴─────────────────┴──────────┴─────────┘

字符串函数

函数名定义功能语法示例结果
toString()将值转换为字符串用于非字符串类型（如数字、布尔值）转字符串toString(expression)RETURN toString(123)"123"
split()按分隔符拆分字符串将字符串分割为列表split(字符串, 分隔符)RETURN split("A,B,C", ",")["A", "B", "C"]
trim()去除字符串两端空格清理字符串前后空格trim(字符串)RETURN trim(" Hello ")"Hello"
toUpper()转换为大写将字符串全部转为大写toUpper(字符串)RETURN toUpper("neo4j")"NEO4J"
toLower()转换为小写将字符串全部转为小写toLower(字符串)RETURN toLower("NEO4J")"neo4j"
substring()截取子字符串从指定位置截取字符串substring(字符串, 起始位置[, 长度])RETURN substring("Neo4j", 2, 3)"o4j" (从索引2开始)
replace()替换字符串中的子串替换匹配的子串replace(原字符串, 旧值, 新值)RETURN replace("Hello World", "World", "Neo4j")"Hello Neo4j"
size()计算字符串长度返回字符串的字符数size(字符串)RETURN size("Neo4j")5

索引

  • 数据库的索引就是为了加快检索数据效率而引入的冗余信息。他的代价是需要额外的存储空间和写入变得缓慢。
  • Cypher允许所有节点的某个属性上有特定的标签。索引一旦创建，它将自己管理并当图发生变化时自动更新。一旦索引创建并生效后，Neo4j将自动开始使用索引。

创建索引

  • 使用create index for可以在拥有某个标签的所有节点的某个属性上创建索引。
  • 语法：CREATE INDEX person_name_index FOR (p:Person) ON (p.name);
    • CREATE INDEX 是创建索引的关键字。
    • person_name_index 是索引的名称，可以自定义。
    • FOR (p:Person) 表示这个索引是针对标签为 Person 的节点。
    • ON (p.name) 表示是基于节点的 name 属性创建索引。
sql">CREATE INDEX person_name_index FOR (p:Person) ON (p.name);

Added 1 index, completed after 79 ms.

查看索引

sql">show index

╒═══╤═══════════════════╤════════╤═════════════════╤════════╤══════════════╤═════════════╤══════════╤══════════════════╤════════════════╤════════════════════════════════╤═════════╕
│id │name               │state   │populationPercent│type    │entityType    │labelsOrTypes│properties│indexProvider     │owningConstraint│lastRead                        │readCount│
╞═══╪═══════════════════╪════════╪═════════════════╪════════╪══════════════╪═════════════╪══════════╪══════════════════╪════════════════╪════════════════════════════════╪═════════╡
│2  │"index_f7700477"   │"ONLINE"│100.0            │"LOOKUP"│"RELATIONSHIP"│null         │null      │"token-lookup-1.0"│null            │"2025-02-01T13:51:02.983000000Z"│1        │
├───┼───────────────────┼────────┼─────────────────┼────────┼──────────────┼─────────────┼──────────┼──────────────────┼────────────────┼────────────────────────────────┼─────────┤
│1  │"person_name_index"│"ONLINE"│100.0            │"RANGE" │"NODE"        │["Person"]   │["name"]  │"range-1.0"       │null            │"2025-02-05T04:27:27.362000000Z"│149      │
└───┴───────────────────┴────────┴─────────────────┴────────┴──────────────┴─────────────┴──────────┴──────────────────┴────────────────┴────────────────────────────────┴─────────┘

删除索引

  • drop index可以删除某个标签的所有节点的某个属性上的索引。
sql">DROP INDEX person_name_index;

使用索引

  • 通常不需要在查询中指出使用哪个索引。Cypher自行决定。
    sql">match (person:Person {name:"Alice"})
return person

    sql">╒═════════════════════════════════════════════════════════╕
│person                                                   │
╞═════════════════════════════════════════════════════════╡
│(:Developer:Person {name: "Alice",eyes: "brown",age: 38})│
└─────────────────────────────────────────────────────────┘

http://www.ppmy.cn/server/165420.html

相关文章

Haskell语言的数据可视化

Haskell语言的数据可视化

Haskell语言的数据可视化 引言 数据可视化是数据科学与分析中的重要组成部分。通过将数据以直观的图形和图表形式展示出来，用户能够更容易地理解和分析数据。虽然Python和R是数据可视化的主流语言，但Haskell作为一种函数式编程语言，也具备强…
阅读更多...
蓝桥杯之c++入门（一）【C＋＋入门】

蓝桥杯之c++入门（一）【C＋＋入门】

目录 前言5. 算术操作符5.1 算术操作符5.2 浮点数的除法5.3 负数取模5.4 数值溢出5.5 练习练习1：计算 ( a b ) ⋆ c (ab)^{\star}c (ab)⋆c练习2：带余除法练习3：整数个位练习4：整数十位练习5：时间转换练习6&#xff…
阅读更多...
我问了DeepSeek和ChatGPT关于vue中包含几种watch的问题，它们是这么回答的……

我问了DeepSeek和ChatGPT关于vue中包含几种watch的问题，它们是这么回答的……

前言：听说最近DeepSeek很火，带着好奇来问了关于Vue的一个问题，看能从什么角度思考，如果回答的不对，能不能尝试纠正，并帮我整理出一篇不错的文章。 第一次回答的原文如下： 在 Vue 中，…
阅读更多...
实现网站内容快速被搜索引擎收录的方法

实现网站内容快速被搜索引擎收录的方法

本文转自：百万收录网 原文链接：https://www.baiwanshoulu.com/6.html 实现网站内容快速被搜索引擎收录，是网站运营和推广的重要目标之一。以下是一些有效的方法，可以帮助网站内容更快地被搜索引擎发现和收录： 一、确…
阅读更多...
Maven的单元测试

Maven的单元测试

1. 单元测试的基本概念 单元测试（Unit Testing） 是一种软件测试方法，专注于测试程序中的最小可测试单元——通常是单个类或方法。通过单元测试，可以确保每个模块按预期工作，从而提高代码的质量和可靠性。 2.安装和配…
阅读更多...
Qt Creator 中使用 vcpkg

Qt Creator 中使用 vcpkg

Qt Creator 中使用 vcpkg Qt Creator 是一个跨平台的轻量级 IDE，做 Qt 程序开发的同学们肯定对这个 IDE 都比较属于。这个 IDE 虽然没有 Visual Stdio 功能那么强，但是由于和 Qt 集成的比较深，用来开发 Qt 程序还是很顺手的。 早期&#xf…
阅读更多...
Leetcode922： 按奇偶排序数组 II

Leetcode922： 按奇偶排序数组 II

题目描述： 给定一个非负整数数组 nums， nums 中一半整数是 奇数 ，一半整数是 偶数 。 对数组进行排序，以便当 nums[i] 为奇数时，i 也是 奇数 ；当 nums[i] 为偶数时， i 也是 偶数 。 你可以返…
阅读更多...
【人工智能】掌握图像风格迁移：使用Python实现艺术风格的自动化迁移

【人工智能】掌握图像风格迁移：使用Python实现艺术风格的自动化迁移

《Python OpenCV从菜鸟到高手》带你进入图像处理与计算机视觉的大门！ 解锁Python编程的无限可能：《奇妙的Python》带你漫游代码世界 图像风格迁移（Image Style Transfer）是一种基于深度学习的计算机视觉技术，通过将一张图像的内容与另一张图像的艺术风格结合，生成一幅具…
阅读更多...
最新文章

Copyright @ 2022~2023