1. 什么是Cypher内置函数 #

Cypher内置函数是Neo4j提供的预定义函数，用于处理数据、进行计算和转换。这些函数可以直接在Cypher查询中使用，无需额外安装。

1.1 前置知识：函数的概念 #

函数是一段可重用的代码，接受输入（参数），执行特定操作，并返回结果。例如：

• toString(123)：将数字123转换为字符串"123"
• count(p)：计算节点p的数量

1.2 函数分类 #

Cypher内置函数主要分为以下几类：

类别	说明	常用函数
字符串函数	处理文本数据	toString(), substring(), replace(), toUpper(), toLower(), split(), trim(), size()
数值函数	数值计算和转换	toInteger(), toFloat(), round(), ceil(), floor(), abs(), sqrt()
日期时间函数	处理日期和时间	date(), datetime(), duration()
聚合函数	对数据进行统计	count(), sum(), avg(), min(), max(), collect()
列表函数	处理列表数据	range(), head(), last(), size(), reverse()

1.3 为什么需要函数？ #

函数可以帮助我们：

• 简化代码：避免重复编写相同的逻辑
• 提高效率：使用优化过的内置函数
• 统一标准：使用标准化的函数处理数据
• 增强功能：实现复杂的数据处理需求

2. 字符串函数 #

字符串函数用于处理文本数据，如转换、截取、替换等操作。

2.1 toString() - 转换为字符串 #

将任何类型的值转换为字符串。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p:Person {name: '张三', age: 30, score: 95.5})

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.age, p.score

// 使用toString()将数值转换为字符串
MATCH (p:Person)
RETURN p.name, 
       toString(p.age) AS ageStr,
       toString(p.score) AS scoreStr,
       toString(p.age) + '岁' AS ageWithUnit

// 查询最终结果
MATCH (p:Person)
RETURN p.name, 
       toString(p.age) AS ageStr,
       toString(p.score) AS scoreStr

2.2 substring() - 获取子字符串 #

从字符串中提取一部分。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p:Person {name: '张三', email: 'zhangsan@example.com', phone: '13800138000'})

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.email, p.phone

// 使用substring()获取子字符串
MATCH (p:Person)
RETURN p.name,
       substring(p.email, 0, 8) AS emailPrefix,
       substring(p.phone, 0, 3) AS phonePrefix,
       substring(p.name, 0, 1) AS firstName

// 查询最终结果
MATCH (p:Person)
RETURN p.name,
       substring(p.email, 0, 8) AS emailPrefix,
       substring(p.phone, 0, 3) AS phonePrefix

2.3 replace() - 替换字符串 #

替换字符串中的指定内容。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p:Person {name: '张三', email: 'zhangsan@example.com', title: 'Java开发工程师'})

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.email, p.title

// 使用replace()替换字符串
MATCH (p:Person)
RETURN p.name,
       replace(p.email, '@example.com', '@company.com') AS newEmail,
       replace(p.title, 'Java', 'Python') AS newTitle

// 查询最终结果
MATCH (p:Person)
RETURN p.name,
       replace(p.email, '@example.com', '@company.com') AS newEmail,
       replace(p.title, 'Java', 'Python') AS newTitle

2.4 split() - 分割字符串 #

将字符串按指定分隔符分割成列表。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p:Person {name: '张三', email: 'zhangsan@example.com', tags: 'Java,Python,Neo4j'})

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.email, p.tags

// 使用split()分割字符串
MATCH (p:Person)
RETURN p.name,
       split(p.email, '@') AS emailParts,
       split(p.tags, ',') AS tagList

// 查询最终结果
MATCH (p:Person)
RETURN p.name,
       split(p.email, '@') AS emailParts,
       split(p.tags, ',') AS tagList

2.5 toUpper() 和 toLower() - 大小写转换 #

将字符串转换为大写或小写。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p:Person {name: 'Zhang San', email: 'zhangsan@example.com', code: 'ABC123'})

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.email, p.code

// 使用toUpper()和toLower()进行大小写转换
MATCH (p:Person)
RETURN p.name,
       toUpper(p.name) AS nameUpper,
       toLower(p.name) AS nameLower,
       toUpper(p.email) AS emailUpper,
       toLower(p.code) AS codeLower

// 查询最终结果
MATCH (p:Person)
RETURN p.name,
       toUpper(p.name) AS nameUpper,
       toLower(p.name) AS nameLower

2.6 trim() - 去除空白字符 #

去除字符串两端的空白字符（空格、制表符等）。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据（包含前后空格）
CREATE (p:Person {name: '  张三  ', email: '  zhangsan@example.com  ', title: '\t开发工程师\t'})

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.email, p.title

// 使用trim()去除空白字符
MATCH (p:Person)
RETURN trim(p.name) AS nameTrimmed,
       trim(p.email) AS emailTrimmed,
       trim(p.title) AS titleTrimmed

// 查询最终结果
MATCH (p:Person)
RETURN trim(p.name) AS nameTrimmed,
       trim(p.email) AS emailTrimmed,
       trim(p.title) AS titleTrimmed

2.7 size() - 获取字符串长度 #

获取字符串的字符数量。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p:Person {name: '张三', email: 'zhangsan@example.com', bio: '软件工程师'})

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.email, p.bio

// 使用size()获取字符串长度
MATCH (p:Person)
RETURN p.name,
       size(p.name) AS nameLength,
       size(p.email) AS emailLength,
       size(p.bio) AS bioLength

// 查询最终结果
MATCH (p:Person)
RETURN p.name,
       size(p.name) AS nameLength,
       size(p.email) AS emailLength

3. 数值函数 #

数值函数用于数值计算和类型转换。

3.1 toInteger() - 转换为整数 #

将值转换为整数（会截断小数部分）。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p:Person {name: '张三', age: '30', score: '95.7', price: 99.9})

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.age, p.score, p.price

// 使用toInteger()转换为整数
MATCH (p:Person)
RETURN p.name,
       toInteger(p.age) AS ageInt,
       toInteger(p.score) AS scoreInt,
       toInteger(p.price) AS priceInt

// 查询最终结果
MATCH (p:Person)
RETURN p.name,
       toInteger(p.age) AS ageInt,
       toInteger(p.score) AS scoreInt,
       toInteger(p.price) AS priceInt

3.2 toFloat() - 转换为浮点数 #

将值转换为浮点数。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p:Person {name: '张三', age: 30, score: '95.7', price: '99.9'})

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.age, p.score, p.price

// 使用toFloat()转换为浮点数
MATCH (p:Person)
RETURN p.name,
       toFloat(p.age) AS ageFloat,
       toFloat(p.score) AS scoreFloat,
       toFloat(p.price) AS priceFloat

// 查询最终结果
MATCH (p:Person)
RETURN p.name,
       toFloat(p.age) AS ageFloat,
       toFloat(p.score) AS scoreFloat,
       toFloat(p.price) AS priceFloat

3.3 round() - 四舍五入 #

将数值四舍五入到最近的整数。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p:Person {name: '张三', score1: 95.4, score2: 95.6, score3: 95.5})

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.score1, p.score2, p.score3

// 使用round()进行四舍五入
MATCH (p:Person)
RETURN p.name,
       round(p.score1) AS score1Rounded,
       round(p.score2) AS score2Rounded,
       round(p.score3) AS score3Rounded

// 查询最终结果
MATCH (p:Person)
RETURN p.name,
       round(p.score1) AS score1Rounded,
       round(p.score2) AS score2Rounded,
       round(p.score3) AS score3Rounded

3.4 ceil() 和 floor() - 向上/向下取整 #

ceil()向上取整，floor()向下取整。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p:Person {name: '张三', score: 95.3, price: 99.7})

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.score, p.price

// 使用ceil()和floor()进行取整
MATCH (p:Person)
RETURN p.name,
       ceil(p.score) AS scoreCeil,
       floor(p.score) AS scoreFloor,
       ceil(p.price) AS priceCeil,
       floor(p.price) AS priceFloor

// 查询最终结果
MATCH (p:Person)
RETURN p.name,
       ceil(p.score) AS scoreCeil,
       floor(p.score) AS scoreFloor

3.5 abs() - 绝对值 #

返回数值的绝对值（去掉负号）。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p:Person {name: '张三', temp1: 25.5, temp2: -10.3, diff: -5})

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.temp1, p.temp2, p.diff

// 使用abs()获取绝对值
MATCH (p:Person)
RETURN p.name,
       abs(p.temp1) AS temp1Abs,
       abs(p.temp2) AS temp2Abs,
       abs(p.diff) AS diffAbs

// 查询最终结果
MATCH (p:Person)
RETURN p.name,
       abs(p.temp1) AS temp1Abs,
       abs(p.temp2) AS temp2Abs,
       abs(p.diff) AS diffAbs

3.6 sqrt() - 平方根 #

计算数值的平方根。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p:Person {name: '张三', area: 16, value: 25, number: 100})

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.area, p.value, p.number

// 使用sqrt()计算平方根
MATCH (p:Person)
RETURN p.name,
       sqrt(p.area) AS areaSqrt,
       sqrt(p.value) AS valueSqrt,
       sqrt(p.number) AS numberSqrt

// 查询最终结果
MATCH (p:Person)
RETURN p.name,
       sqrt(p.area) AS areaSqrt,
       sqrt(p.value) AS valueSqrt,
       sqrt(p.number) AS numberSqrt

4. 日期时间函数 #

日期时间函数用于处理日期和时间。详细内容请参考第13课：日期时间处理。

4.1 date() - 日期函数 #

创建或获取日期。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p:Person {name: '张三', birthDate: date('1990-01-15'), joinDate: date()})

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.birthDate, p.joinDate

// 使用date()函数
MATCH (p:Person)
RETURN p.name,
       date() AS today,
       p.birthDate,
       p.joinDate

// 查询最终结果
MATCH (p:Person)
RETURN p.name,
       date() AS today,
       p.birthDate,
       p.joinDate

4.2 datetime() - 日期时间函数 #

创建或获取日期时间。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p:Person {name: '张三', createTime: datetime('2023-01-15T10:30:00Z'), updateTime: datetime()})

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.createTime, p.updateTime

// 使用datetime()函数
MATCH (p:Person)
RETURN p.name,
       datetime() AS now,
       p.createTime,
       p.updateTime

// 查询最终结果
MATCH (p:Person)
RETURN p.name,
       datetime() AS now,
       p.createTime,
       p.updateTime

4.3 duration() - 持续时间函数 #

创建持续时间对象。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p:Person {name: '张三', workDuration: duration({days: 365}), breakDuration: duration('PT1H30M')})

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.workDuration, p.breakDuration

// 使用duration()函数
MATCH (p:Person)
RETURN p.name,
       duration({days: 7}) AS oneWeek,
       duration('PT2H') AS twoHours,
       p.workDuration,
       p.breakDuration

// 查询最终结果
MATCH (p:Person)
RETURN p.name,
       duration({days: 7}) AS oneWeek,
       p.workDuration,
       p.breakDuration

5. 聚合函数 #

聚合函数用于对一组数据进行计算。详细内容请参考第9课：结果处理和聚合。

5.1 count() - 计数 #

计算行数或非空值数量。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p1:Person {name: '张三', age: 30}),
       (p2:Person {name: '李四', age: 25}),
       (p3:Person {name: '王五', age: 35}),
       (c:Company {name: '科技公司'}),
       (p1)-[:WORKS_FOR]->(c),
       (p2)-[:WORKS_FOR]->(c)

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.age

// 使用count()计数
MATCH (p:Person)
RETURN count(p) AS totalPersons

// 统计每个公司的人数
MATCH (c:Company)<-[:WORKS_FOR]-(p:Person)
RETURN c.name, count(p) AS employeeCount

// 查询最终结果
MATCH (c:Company)<-[:WORKS_FOR]-(p:Person)
RETURN c.name, count(p) AS employeeCount

5.2 sum() - 求和 #

计算数值的总和。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p1:Person {name: '张三', salary: 10000}),
       (p2:Person {name: '李四', salary: 12000}),
       (p3:Person {name: '王五', salary: 15000}),
       (c:Company {name: '科技公司'}),
       (p1)-[:WORKS_FOR]->(c),
       (p2)-[:WORKS_FOR]->(c),
       (p3)-[:WORKS_FOR]->(c)

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.salary

// 使用sum()求和
MATCH (p:Person)
RETURN sum(p.salary) AS totalSalary

// 统计每个公司的总薪资
MATCH (c:Company)<-[:WORKS_FOR]-(p:Person)
RETURN c.name, sum(p.salary) AS totalSalary

// 查询最终结果
MATCH (c:Company)<-[:WORKS_FOR]-(p:Person)
RETURN c.name, sum(p.salary) AS totalSalary

5.3 avg() - 平均值 #

计算数值的平均值。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p1:Person {name: '张三', score: 85}),
       (p2:Person {name: '李四', score: 90}),
       (p3:Person {name: '王五', score: 95}),
       (c:Course {name: '数学'}),
       (p1)-[:TAKES]->(c),
       (p2)-[:TAKES]->(c),
       (p3)-[:TAKES]->(c)

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.score

// 使用avg()计算平均值
MATCH (p:Person)
RETURN avg(p.score) AS averageScore

// 统计每门课程的平均分
MATCH (c:Course)<-[:TAKES]-(p:Person)
RETURN c.name, avg(p.score) AS averageScore

// 查询最终结果
MATCH (c:Course)<-[:TAKES]-(p:Person)
RETURN c.name, avg(p.score) AS averageScore

5.4 min() 和 max() - 最小值和最大值 #

找最小值或最大值。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p1:Person {name: '张三', age: 30}),
       (p2:Person {name: '李四', age: 25}),
       (p3:Person {name: '王五', age: 35}),
       (c:Company {name: '科技公司'}),
       (p1)-[:WORKS_FOR]->(c),
       (p2)-[:WORKS_FOR]->(c),
       (p3)-[:WORKS_FOR]->(c)

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.age

// 使用min()和max()找最小值和最大值
MATCH (p:Person)
RETURN min(p.age) AS minAge, max(p.age) AS maxAge

// 统计每个公司的年龄范围
MATCH (c:Company)<-[:WORKS_FOR]-(p:Person)
RETURN c.name, min(p.age) AS minAge, max(p.age) AS maxAge

// 查询最终结果
MATCH (c:Company)<-[:WORKS_FOR]-(p:Person)
RETURN c.name, min(p.age) AS minAge, max(p.age) AS maxAge

5.5 collect() - 收集到列表 #

将值收集到列表中。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p1:Person {name: '张三'}),
       (p2:Person {name: '李四'}),
       (p3:Person {name: '王五'}),
       (c:Company {name: '科技公司'}),
       (p1)-[:WORKS_FOR]->(c),
       (p2)-[:WORKS_FOR]->(c),
       (p3)-[:WORKS_FOR]->(c)

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name

// 使用collect()收集到列表
MATCH (p:Person)
RETURN collect(p.name) AS allNames

// 收集每个公司的员工姓名
MATCH (c:Company)<-[:WORKS_FOR]-(p:Person)
RETURN c.name, collect(p.name) AS employeeNames

// 查询最终结果
MATCH (c:Company)<-[:WORKS_FOR]-(p:Person)
RETURN c.name, collect(p.name) AS employeeNames

6. 列表函数 #

列表函数用于处理列表数据。

6.1 range() - 创建范围列表 #

创建数值范围列表。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p:Person {name: '张三'})

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name

// 使用range()创建范围列表
MATCH (p:Person)
RETURN p.name,
       range(1, 10) AS numbers1To10,
       range(0, 5) AS numbers0To5,
       range(1, 10, 2) AS oddNumbers

// 查询最终结果
MATCH (p:Person)
RETURN p.name,
       range(1, 10) AS numbers1To10,
       range(1, 10, 2) AS oddNumbers

6.2 head() 和 last() - 获取首尾元素 #

获取列表的第一个或最后一个元素。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p:Person {name: '张三', tags: ['Java', 'Python', 'Neo4j'], scores: [85, 90, 95]})

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.tags, p.scores

// 使用head()和last()获取首尾元素
MATCH (p:Person)
RETURN p.name,
       head(p.tags) AS firstTag,
       last(p.tags) AS lastTag,
       head(p.scores) AS firstScore,
       last(p.scores) AS lastScore

// 查询最终结果
MATCH (p:Person)
RETURN p.name,
       head(p.tags) AS firstTag,
       last(p.tags) AS lastTag,
       head(p.scores) AS firstScore,
       last(p.scores) AS lastScore

6.3 size() - 获取列表大小 #

获取列表的元素数量。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p:Person {name: '张三', tags: ['Java', 'Python', 'Neo4j'], skills: ['编程', '数据库', '算法', '设计']})

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.tags, p.skills

// 使用size()获取列表大小
MATCH (p:Person)
RETURN p.name,
       size(p.tags) AS tagCount,
       size(p.skills) AS skillCount

// 查询最终结果
MATCH (p:Person)
RETURN p.name,
       size(p.tags) AS tagCount,
       size(p.skills) AS skillCount

6.4 reverse() - 反转列表 #

反转列表元素的顺序。

// 清空数据库
MATCH (n) DETACH DELETE n

// 创建测试数据
CREATE (p:Person {name: '张三', tags: ['Java', 'Python', 'Neo4j'], scores: [85, 90, 95]})

// 查询插入后的数据
MATCH (p:Person)
RETURN p.name, p.tags, p.scores

// 使用reverse()反转列表
MATCH (p:Person)
RETURN p.name,
       reverse(p.tags) AS reversedTags,
       reverse(p.scores) AS reversedScores

// 查询最终结果
MATCH (p:Person)
RETURN p.name,
       reverse(p.tags) AS reversedTags,
       reverse(p.scores) AS reversedScores

7. 小结 #

7.1 核心概念 #

类别	常用函数	主要用途
字符串函数	toString(), substring(), replace(), split(), toUpper(), toLower(), trim(), size()	处理文本数据
数值函数	toInteger(), toFloat(), round(), ceil(), floor(), abs(), sqrt()	数值计算和转换
日期时间函数	date(), datetime(), duration()	处理日期和时间
聚合函数	count(), sum(), avg(), min(), max(), collect()	对数据进行统计
列表函数	range(), head(), last(), size(), reverse()	处理列表数据

7.2 最佳实践 #

1. 使用合适的函数：根据数据类型和需求选择合适的函数
2. 组合使用函数：可以组合多个函数实现复杂功能
3. 注意函数返回值：了解函数的返回类型，避免类型错误

7.3 常见用法 #

• 使用字符串函数处理文本数据
• 使用数值函数进行数值计算和转换
• 使用日期时间函数处理日期和时间
• 使用聚合函数进行数据统计
• 使用列表函数处理列表数据