存储过程 #

存储过程特点：
├── 封装复杂逻辑
├── 提高代码复用
├── 支持参数传递
├── 可返回多个结果
└── 可用Java编写

CALL procedure.name()

CALL procedure.name(param1, param2)

CALL db.labels() YIELD label
RETURN label

CALL db.indexes() YIELD name, state
WHERE state = 'ONLINE'
RETURN name

CALL db.labels() YIELD label
MATCH (n)
WHERE label IN labels(n)
RETURN label, count(n) AS count
ORDER BY count DESC

CALL db.info()

CALL db.labels()

CALL db.relationshipTypes()

CALL db.propertyKeys()

CALL db.indexes()

CALL db.constraints()

CALL db.stats.retrieve('GRAPH COUNTS')

APOC功能：
├── 数据转换
├── 图算法
├── 文本处理
├── 日期时间
├── 数学运算
├── 集合操作
├── 虚拟关系
└── 批处理

dbms.security.procedures.unrestricted=apoc.*
dbms.security.procedures.allowlist=apoc.*

CALL apoc.help('all')

RETURN apoc.text.replace('Hello World', 'World', 'Neo4j')
RETURN apoc.text.capitalize('hello')
RETURN apoc.text.capitalizeAll('hello world')

RETURN apoc.coll.union([1, 2], [2, 3])
RETURN apoc.coll.intersection([1, 2, 3], [2, 3, 4])
RETURN apoc.coll.difference([1, 2, 3], [2, 3, 4])

RETURN apoc.date.currentTimestamp()
RETURN apoc.temporal.format(date(), 'yyyy-MM-dd')

RETURN apoc.convert.toJson({name: 'Tom', age: 30})
RETURN apoc.convert.fromJsonMap('{"name":"Tom","age":30}')

CALL apoc.create.nodes(['Person'], [
    {name: 'Tom'},
    {name: 'Jerry'}
])

CALL apoc.periodic.iterate(
    'MATCH (p:Person) RETURN p',
    'SET p.processed = true',
    {batchSize: 1000}
)

MATCH (start:Person {name: 'Tom'})
CALL apoc.path.expand(start, 'KNOWS>', null, 1, 3) YIELD path
RETURN path

MATCH (a:Person)-[:KNOWS]->(b:Person)
WITH a, count(b) AS friendCount
CALL apoc.create.vRelationship(a, 'FRIEND_COUNT', {count: friendCount}, null) YIELD rel
RETURN a, rel

package com.example;

import org.neo4j.procedure.*;
import org.neo4j.graphdb.*;

public class CustomProcedures {
    
    @Context
    public GraphDatabaseService db;
    
    @Procedure(name = "com.example.hello", mode = Mode.READ)
    @Description("Returns a hello message")
    public Stream<HelloResult> hello(@Name("name") String name) {
        return Stream.of(new HelloResult("Hello, " + name + "!"));
    }
    
    public static class HelloResult {
        public String message;
        
        public HelloResult(String message) {
            this.message = message;
        }
    }
}

CALL com.example.hello('Tom') YIELD message
RETURN message

建议：
├── 使用索引加速查询
├── 限制返回结果数量
├── 使用分批处理大数据量
├── 避免复杂计算
└── 合理使用缓存

安全建议：
├── 限制存储过程权限
├── 验证输入参数
├── 避免SQL注入
├── 使用参数化查询
└── 记录操作日志

CALL apoc.do.when(
    EXISTS((:Person {name: 'Tom'})),
    'RETURN "Person exists" AS result',
    'CREATE (p:Person {name: "Tom"}) RETURN "Person created" AS result',
    {}
) YIELD value
RETURN value.result

CALL apoc.periodic.iterate(
    'LOAD CSV WITH HEADERS FROM "file:///data.csv" AS row RETURN row',
    'CREATE (p:Person {id: row.id, name: row.name})',
    {batchSize: 1000, parallel: true}
)

CALL apoc.periodic.iterate(
    'MATCH (p:Person) WHERE p.status = "deleted" RETURN p',
    'DETACH DELETE p',
    {batchSize: 1000}
)

MATCH (start:Person {name: 'Tom'})
CALL apoc.path.expandConfig(start, {
    relationshipFilter: 'KNOWS>',
    minLevel: 1,
    maxLevel: 3,
    uniqueness: 'NODE_GLOBAL'
}) YIELD path
RETURN path

MATCH (p:Person)
WITH p, apoc.text.capitalize(p.name) AS capitalizedName
SET p.capitalizedName = capitalizedName