过程与函数

apoc.case

apoc.case(conditionals LIST<ANY>, elseQuery STRING, params MAP) - 对于给定 LIST<ANY> 中的每一对条件查询和只读查询，此过程将运行第一个条件评估为真的查询。如果没有条件为真，则改为运行 ELSE 查询。

过程 (Procedure) Cypher 25 中已弃用

apoc.help

apoc.help() - 返回可用 APOC 过程和函数的描述。如果提供了关键词，则仅返回名称中包含该关键词的过程和函数。

过程

apoc.version

apoc.version() - 返回当前安装的 APOC 版本。

函数

apoc.when

apoc.when(condition BOOLEAN, ifQuery STRING, elseQuery STRING, params MAP<STRING, ANY>) - 如果条件评估为真，此过程将运行只读的 ifQuery，否则将运行 elseQuery。

过程 (Procedure) Cypher 25 中已弃用

apoc.agg.first

apoc.agg.first(value ANY) - 返回给定集合中的第一个值。

函数

apoc.agg.graph

apoc.agg.graph(path ANY) - 返回所有不同的 NODE 和 RELATIONSHIP 值，并将它们收集到一个包含 nodes 和 relationships 键的 MAP 中。

函数 (Function) Cypher 25 中已弃用

apoc.agg.last

apoc.agg.last(value ANY) - 返回给定集合中的最后一个值。

函数

apoc.agg.maxItems

apoc.agg.maxItems(items ANY, value ANY, groupLimit INTEGER) - 返回一个 MAP {items: LIST<ANY>, value: ANY}，其中 value 键是当前存在的最大值，items 代表所有具有相同最大值的项目。项目列表的大小可以限制为给定的最大尺寸。

函数

apoc.agg.median

apoc.agg.median(value ANY) - 返回所有非空 INTEGER 和 FLOAT 值的数学中位数。

函数

apoc.agg.minItems

apoc.agg.minItems(items ANY, value ANY, groupLimit INTEGER) - 返回一个 MAP {items: LIST<ANY>, value: ANY}，其中 value 键是当前存在的最小值，items 代表所有具有相同最小值的项目。项目列表的大小可以限制为给定的最大尺寸。

函数

apoc.agg.nth

apoc.agg.nth(value ANY, offset INTEGER) - 返回给定集合中第 n 个值（若要获取未知长度集合的最后一项，可以使用 -1）。

函数

apoc.agg.percentiles

apoc.agg.percentiles(value INTEGER | FLOAT, percentiles LIST<FLOAT>) - 返回给定集合中数值范围内的指定百分位数。

函数

apoc.agg.product

apoc.agg.product(value INTEGER | FLOAT) - 返回集合中所有非空 INTEGER 和 FLOAT 值的乘积。

函数 (Function) Cypher 25 中已弃用

apoc.agg.slice

apoc.agg.slice(value ANY, from INTEGER, to INTEGER) - 返回给定集合中非空值的子集（集合是从零开始索引的）。要指定从开头到集合结尾的范围，长度应设置为 -1。

函数

apoc.agg.statistics

apoc.agg.statistics(value INTEGER | FLOAT, percentiles LIST<FLOAT>) - 返回给定集合中 INTEGER 和 FLOAT 值的以下统计信息：百分位数、最小值、最小非零值、最大值、总和、平均值、标准差。

函数

apoc.algo.aStar

apoc.algo.aStar(startNode NODE, endNode NODE, relTypesAndDirections STRING, weightPropertyName STRING, latPropertyName STRING, lonPropertyName STRING) - 运行 A* 搜索算法，在两个 NODE 值之间找到最优路径，并使用给定的 RELATIONSHIP 属性名作为成本函数。

过程

apoc.algo.aStarConfig

apoc.algo.aStarConfig(startNode NODE, endNode NODE, relTypesAndDirections STRING, config MAP<STRING, ANY>) - 运行 A* 搜索算法，在两个 NODE 值之间找到最优路径，并使用给定的 RELATIONSHIP 属性名作为成本函数。此过程会在配置中查找权重、纬度和经度属性。

过程

apoc.algo.allSimplePaths

apoc.algo.allSimplePaths(startNode NODE, endNode NODE, relTypesAndDirections STRING, maxNodes INTEGER) - 运行搜索算法，在给定的 RELATIONSHIP 值之间找到所有简单路径，深度最大为 maxNodes。返回的路径将不包含循环。

过程

apoc.algo.cover

apoc.algo.cover(nodes ANY) - 返回连接给定一组 NODE 值的所有 RELATIONSHIP 值。

过程 (Procedure) Cypher 25 中已弃用

apoc.algo.dijkstra

apoc.algo.dijkstra(startNode NODE, endNode NODE, relTypesAndDirections STRING, weightPropertyName STRING, defaultWeight FLOAT, numberOfWantedPaths INTEGER) - 使用给定的 RELATIONSHIP 属性作为成本函数运行 Dijkstra 算法。

过程

apoc.any.isDeleted

apoc.any.isDeleted(object ANY) - 如果给定的 NODE 或 RELATIONSHIP 不再存在，则返回 true。

函数

apoc.any.properties

apoc.any.properties(object ANY, keys LIST<STRING>) - 返回给定对象的所有属性。该对象可以是虚拟 NODE、真实 NODE、虚拟 RELATIONSHIP、真实 RELATIONSHIP 或 MAP。

函数

apoc.any.property

apoc.any.property(object ANY, key STRING) - 从对象中返回给定键的属性。该对象可以是虚拟 NODE、真实 NODE、虚拟 RELATIONSHIP、真实 RELATIONSHIP 或 MAP。

函数

apoc.atomic.add

apoc.atomic.add(container ANY, propertyName STRING, number INTEGER | FLOAT, retryAttempts INTEGER) - 将给定属性设置为其自身与给定 INTEGER 或 FLOAT 值之和。随后，该过程将属性设置为返回的和。

过程

apoc.atomic.concat

apoc.atomic.concat(container ANY, propertyName STRING, string STRING, retryAttempts INTEGER) - 将给定属性设置为其自身与该 STRING 值的连接结果。随后，该过程将属性设置为返回的 STRING。

过程

apoc.atomic.insert

apoc.atomic.insert(container ANY, propertyName STRING, position INTEGER, value ANY, retryAttempts INTEGER) - 将值插入到属性的 LIST<ANY> 值中的指定位置。随后，该过程将结果设置回属性。

过程

apoc.atomic.remove

apoc.atomic.remove(container ANY, propertyName STRING, position INTEGER, retryAttempts INTEGER) - 从属性的 LIST<ANY> 值中移除指定位置的元素。随后，该过程将属性设置为结果 LIST<ANY> 值。

过程

apoc.atomic.subtract

apoc.atomic.subtract(container ANY, propertyName STRING, number INTEGER | FLOAT, retryAttempts INTEGER) - 将值属性设置为其自身减去给定的 INTEGER 或 FLOAT 值。随后，该过程将属性设置为返回的差值。

过程

apoc.atomic.update

apoc.atomic.update(container ANY, propertyName STRING, operation STRING, retryAttempts INTEGER) - 使用 Cypher 操作更新属性的值。

过程

apoc.bitwise.op

apoc.bitwise.op(a INTEGER, operator STRING, b INTEGER) - 返回位运算的结果。

函数

apoc.coll.elements

apoc.coll.elements(coll LIST<ANY>, limit INTEGER, offset INTEGER) - 将 LIST<ANY> 解构为指示其特定类型的标识符。

过程

apoc.coll.split

apoc.coll.split(coll LIST<ANY>, value ANY) - 按给定的值分割集合。该值本身不会包含在结果 LIST<ANY> 值中。

过程

apoc.coll.zipToRows apoc.coll.zipToRows(list1 LIST<ANY>, list2 LIST<ANY>) - 返回两个 LIST<ANY> 值压缩在一起的结果，每行一个压缩对。

过程 (Procedure) Cypher 25 中已弃用

apoc.coll.avg

apoc.coll.avg(coll LIST<INTEGER | FLOAT>) - 返回 LIST<INTEGER | FLOAT> 中数字的平均值。

函数

apoc.coll.combinations

apoc.coll.combinations(coll LIST<ANY>, minSelect INTEGER, maxSelect INTEGER) - 返回 LIST<ANY> 元素在选择大小 minSelect 和 maxSelect 之间的所有组合集合（默认：minSelect）。

函数

apoc.coll.contains

apoc.coll.contains(coll LIST<ANY>, value ANY) - 返回给定值是否存在于给定集合中（使用 HashSet）。

函数 (Function) Cypher 25 中已弃用

apoc.coll.containsAll

apoc.coll.containsAll(coll1 LIST<ANY>, coll2 LIST<ANY>) - 返回给定值的所有项是否存在于给定集合中。

函数 (Function) Cypher 25 中已弃用

apoc.coll.containsAllSorted

apoc.coll.containsAllSorted(coll1 LIST<ANY>, coll2 LIST<ANY>) - 返回第二个 LIST<ANY> 中的所有给定值是否存在于已排序的集合中（使用二分查找）。

函数

apoc.coll.containsDuplicates

apoc.coll.containsDuplicates(coll LIST<ANY>) - 如果集合包含重复元素，则返回 true。

函数

apoc.coll.containsSorted

apoc.coll.containsSorted(coll LIST<ANY>, value ANY) - 返回给定值是否存在于已排序的集合中（使用二分查找）。

函数

apoc.coll.different

apoc.coll.different(coll LIST<ANY>) - 如果给定 LIST<ANY> 中的所有值都是唯一的，则返回 true。

函数

apoc.coll.disjunction

apoc.coll.disjunction(list1 LIST<ANY>, list2 LIST<ANY>) - 返回两个 LIST<ANY> 值之间的非重叠部分（差异集）。

函数

apoc.coll.dropDuplicateNeighbors

apoc.coll.dropDuplicateNeighbors(list LIST<ANY>) - 移除 LIST<ANY> 中重复的连续对象。

函数

apoc.coll.duplicates

apoc.coll.duplicates(coll LIST<ANY>) - 返回集合中重复项目的 LIST<ANY>。

函数

apoc.coll.duplicatesWithCount

apoc.coll.duplicatesWithCount(coll LIST<ANY>) - 返回集合中重复项目及其计数的 LIST<ANY>，键为 item 和 count。

函数

apoc.coll.fill

apoc.coll.fill(items STRING, count INTEGER) - 返回一个包含指定数量项目的 LIST<ANY>。

函数 (Function) Cypher 25 中已弃用

apoc.coll.flatten

apoc.coll.flatten(coll LIST<ANY>, recursive BOOLEAN) - 展平给定的 LIST<ANY>（要展平嵌套的 LIST<ANY> 值，请将 recursive 设置为 true）。

函数 (Function) Cypher 25 中已弃用

apoc.coll.frequencies

apoc.coll.frequencies(coll LIST<ANY>) - 返回集合中项目频率的 LIST<ANY>，键为 item 和 count。

函数

apoc.coll.frequenciesAsMap

apoc.coll.frequenciesAsMap(coll LIST<ANY>) - 返回集合中项目频率的 MAP，键为 item 和 count。

函数

apoc.coll.indexOf

apoc.coll.indexOf(coll LIST<ANY>, value ANY) - 返回指定值在 LIST<ANY> 中首次出现的索引。

函数 (Function) Cypher 25 中已弃用

apoc.coll.insert

apoc.coll.insert(coll LIST<ANY>, index INTEGER, value ANY) - 将值插入 LIST<ANY> 中的指定索引位置。

函数 (Function) Cypher 25 中已弃用

apoc.coll.insertAll

apoc.coll.insertAll(coll LIST<ANY>, index INTEGER, values LIST<ANY>) - 将所有值插入 LIST<ANY>，从指定索引开始。

函数

apoc.coll.intersection

apoc.coll.intersection(list1 LIST<ANY>, list2 LIST<ANY>) - 返回两个 LIST<ANY> 值的不同交集。

函数

apoc.coll.isEqualCollection

apoc.coll.isEqualCollection(coll LIST<ANY>, values LIST<ANY>) - 如果两个集合以任意顺序包含相同基数的相同元素，则返回 true（使用 HashMap）。

函数

apoc.coll.max

apoc.coll.max(values LIST<ANY>) - 返回给定 LIST<ANY> 中所有值的最大值。

函数 (Function) Cypher 25 中已弃用

apoc.coll.min

apoc.coll.min(values LIST<ANY>) - 返回给定 LIST<ANY> 中所有值的最小值。

函数 (Function) Cypher 25 中已弃用

apoc.coll.occurrences

apoc.coll.occurrences(coll LIST<ANY>, item ANY) - 返回给定项目在集合中出现的次数。

函数 (Function) Cypher 25 中已弃用

apoc.coll.pairs

apoc.coll.pairs(list LIST<ANY>) - 返回 LIST<ANY> 中相邻元素的 LIST<ANY> ([1,2],[2,3],[3,null])。

函数 (Function) Cypher 25 中已弃用

apoc.coll.pairsMin

apoc.coll.pairsMin(list LIST<ANY>) - 返回 LIST<ANY> 中相邻元素的 LIST<ANY> ([1,2],[2,3])，跳过最后一个元素。

函数 (Function) Cypher 25 中已弃用

apoc.coll.pairWithOffset

apoc.coll.pairWithOffset(coll LIST<ANY>, offset INTEGER) - 返回由偏移量定义的成对元素的 LIST<ANY>。

过程 函数 在 Cypher 25 中已弃用

apoc.coll.partition

apoc.coll.partition(coll LIST<ANY>, batchSize INTEGER) - 将原始 LIST<ANY> 分区为给定批大小的新 LIST<ANY>。最终的 LIST<ANY> 可能小于给定的批大小。

过程 函数 在 Cypher 25 中已弃用

apoc.coll.randomItem

apoc.coll.randomItem(coll LIST<ANY>)- 返回 LIST<ANY> 中的随机项目；如果为 LIST<NOTHING> 或 LIST<NULL>，则返回 null。

函数 (Function) Cypher 25 中已弃用

apoc.coll.randomItems

apoc.coll.randomItems(coll LIST<ANY>, itemCount INTEGER, allowRepick BOOLEAN) - 返回原始 LIST<ANY> 中 itemCount 个随机项目的 LIST<ANY>（可选是否允许原始 LIST<ANY> 中的元素被多次选中）。

函数

apoc.coll.remove

apoc.coll.remove(coll LIST<ANY>, index INTEGER, length INTEGER) - 从 LIST<ANY> 中移除一段值，从索引位置开始，长度为给定的值长度。

函数 (Function) Cypher 25 中已弃用

apoc.coll.removeAll

apoc.coll.removeAll(list1 LIST<ANY>, list2 LIST<ANY>) - 返回移除所有也存在于第二个 LIST<ANY> 中的元素后的第一个 LIST<ANY>。

函数

apoc.coll.runningTotal

apoc.coll.runningTotal(list LIST<INTEGER | FLOAT>) - 返回一个累积的 LIST<INTEGER | FLOAT>。

函数

apoc.coll.set

apoc.coll.set(coll LIST<ANY>, index INTEGER, value ANY) - 将指定索引处的元素设置为新值。

函数

apoc.coll.shuffle

apoc.coll.shuffle(coll LIST<ANY>) - 返回打乱后的 LIST<ANY>。

函数

apoc.coll.sort

apoc.coll.sort(coll LIST<ANY>) - 将给定的 LIST<ANY> 按升序排序。

函数 (Function) Cypher 25 中已弃用

apoc.coll.sortMaps

apoc.coll.sortMaps(list LIST<MAP<STRING, ANY>>, prop STRING) - 根据 prop 指示的 MAP 属性，将给定的 LIST<MAP<STRING, ANY>> 按降序排序。

函数

apoc.coll.sortMulti

apoc.coll.sortMulti(coll LIST<MAP<STRING, ANY>>, orderFields LIST<STRING>, limit INTEGER, skip INTEGER) - 根据给定的字段对 LIST<MAP<STRING, ANY>> 进行排序。要指示字段按升序排序，请在其前面加上插入符号 (^)。也可以对 LIST<MAP<STRING, ANY>> 进行限制和跳过值。

函数

apoc.coll.sortNodes

apoc.coll.sortNodes(coll LIST<NODE>, prop STRING) - 根据节点属性将给定的 LIST<NODE> 按降序排序。

函数 (Function) Cypher 25 中已弃用

apoc.coll.sortText

apoc.coll.sortText(coll LIST<STRING>, conf MAP<STRING, ANY>) - 将给定的 LIST<STRING> 按升序排序。

函数

apoc.coll.stdev

apoc.coll.stdev(list LIST<INTEGER | FLOAT>, isBiasCorrected BOOLEAN) - 分别在 isBiasCorrected 为 true 或 false 时返回样本标准差或总体标准差。

函数 (Function) Cypher 25 中已弃用

apoc.coll.subtract

apoc.coll.subtract(list1 LIST<ANY>, list2 LIST<ANY>) - 将第一个 LIST<ANY> 作为集合返回，并移除第二个 LIST<ANY> 中的所有元素。

函数

apoc.coll.sum

apoc.coll.sum(coll LIST<INTEGER | FLOAT>) - 返回 LIST<INTEGER | FLOAT> 中所有 INTEGER | FLOAT 的总和。

函数 (Function) Cypher 25 中已弃用

apoc.coll.sumLongs

apoc.coll.sumLongs(coll LIST<INTEGER | FLOAT>) - 返回 LIST<INTEGER | FLOAT> 中所有 INTEGER | FLOAT 的总和。

函数 (Function) Cypher 25 中已弃用

apoc.coll.toSet

apoc.coll.toSet(coll LIST<ANY>) - 从给定的 LIST<ANY> 返回唯一的 LIST<ANY>。

函数 (Function) Cypher 25 中已弃用

apoc.coll.union

apoc.coll.union(list1 LIST<ANY>, list2 LIST<ANY>) - 返回两个给定 LIST<ANY> 值的不同并集。

函数

apoc.coll.unionAll

apoc.coll.unionAll(list1 LIST<ANY>, list2 LIST<ANY>) - 返回两个给定 LIST<ANY> 值的完全并集（包含重复项）。

函数 (Function) Cypher 25 中已弃用

apoc.coll.zip

apoc.coll.zip(list1 LIST<ANY>, list2 LIST<ANY>) - 将两个给定 LIST<ANY> 值压缩在一起，作为 LIST<LIST<ANY>> 返回。

函数 (Function) Cypher 25 中已弃用

apoc.convert.setJsonProperty

过程

apoc.convert.toTree

apoc.convert.toTree(paths LIST<PATH>, lowerCaseRels BOOLEAN, config MAP<STRING, ANY>) - 返回 MAP 值流，将给定的 PATH 值表示为至少有一个根节点的树。

过程 在 Cypher 5 中已弃用 在 Cypher 25 中已移除

apoc.convert.fromJsonList

apoc.convert.fromJsonList(list LIST<STRING>, path STRING, pathOptions LIST<STRING>) - 将给定的 JSON 列表转换为 Cypher LIST<STRING>。

函数

apoc.convert.fromJsonMap

apoc.convert.fromJsonMap(map STRING, path STRING, pathOptions LIST<STRING>) - 将给定的 JSON 映射转换为 Cypher MAP。

函数

apoc.convert.getJsonProperty

apoc.convert.getJsonProperty(node NODE, key STRING, path STRING, pathOptions LIST<STRING>) - 将来自给定 NODE 属性的序列化 JSON 对象转换为等效的 Cypher 结构（例如 MAP, LIST<ANY>）。

函数

apoc.convert.getJsonPropertyMap

apoc.convert.getJsonPropertyMap(node NODE, key STRING, path STRING, pathOptions LIST<STRING>) - 将来自给定 NODE 属性的序列化 JSON 对象转换为 Cypher MAP。

函数

apoc.convert.toJson

apoc.convert.toJson(value ANY) - 序列化给定的 JSON 值。

函数

apoc.convert.toList

apoc.convert.toList(value ANY) - 将给定值转换为 LIST<ANY>。

函数 (Function) Cypher 25 中已弃用

apoc.convert.toMap

apoc.convert.toMap(map ANY) - 将给定值转换为 MAP。

函数

apoc.convert.toNode

apoc.convert.toNode(node ANY) - 将给定值转换为 NODE。

函数

apoc.convert.toNodeList

apoc.convert.toNodeList(list LIST<ANY>) - 将给定值转换为 LIST<NODE>。

函数

apoc.convert.toRelationship

apoc.convert.toRelationship(rel ANY) - 将给定值转换为 RELATIONSHIP。

函数

apoc.convert.toRelationshipList

apoc.convert.toRelationshipList(relList LIST<ANY>) - 将给定值转换为 LIST<RELATIONSHIP>。

函数

apoc.convert.toSet

apoc.convert.toSet(list LIST<ANY>) - 将给定值转换为在 Cypher 中表现为 LIST<ANY> 的集合。

函数 (Function) Cypher 25 中已弃用

apoc.convert.toSortedJsonMap

apoc.convert.toSortedJsonMap(value ANY, ignoreCase BOOLEAN) - 将来自给定 NODE 属性的序列化 JSON 对象转换为 Cypher MAP。

函数

apoc.create.addLabels

apoc.create.addLabels(nodes ANY, labels LIST<STRING>) - 将给定标签添加到给定的 NODE 值中。

过程 (Procedure) Cypher 25 中已弃用

apoc.create.clonePathToVirtual

apoc.create.clonePathToVirtual(path PATH) - 接收给定 PATH 并返回其虚拟表示。

过程

apoc.create.clonePathsToVirtual

apoc.create.clonePathsToVirtual(paths LIST<PATH>) - 接收给定 LIST<PATH> 并返回它们的虚拟表示。

过程

apoc.create.node

apoc.create.node(labels LIST<STRING>, props MAP<STRING, ANY>) - 创建具有给定动态标签的 NODE。

过程 (Procedure) Cypher 25 中已弃用

apoc.create.nodes

apoc.create.nodes(labels LIST<STRING>, props LIST<MAP<STRING, ANY>>) - 创建具有给定动态标签的 NODE 值。

过程 (Procedure) Cypher 25 中已弃用

apoc.create.relationship

apoc.create.relationship(from NODE, relType STRING, props MAP<STRING, ANY>, to NODE) - 创建具有给定动态关系类型的 RELATIONSHIP。

过程 (Procedure) Cypher 25 中已弃用

apoc.create.removeLabels

apoc.create.removeLabels(nodes ANY, labels LIST<STRING>) - 从给定的 NODE 值中移除给定标签。

过程 (Procedure) Cypher 25 中已弃用

apoc.create.removeProperties

apoc.create.removeProperties(nodes ANY, keys LIST<STRING>) - 从给定的 NODE 值中移除给定属性。

过程 (Procedure) Cypher 25 中已弃用

apoc.create.removeRelProperties

apoc.create.removeRelProperties(rels ANY, keys LIST<STRING>) - 从给定的 RELATIONSHIP 值中移除给定属性。

过程 (Procedure) Cypher 25 中已弃用

apoc.create.setLabels

apoc.create.setLabels(nodes ANY, labels LIST<STRING>) - 将给定标签设置到给定的 NODE 值上。不匹配的标签会从节点中删除。

过程 (Procedure) Cypher 25 中已弃用

apoc.create.setProperties

apoc.create.setProperties(nodes ANY, keys LIST<STRING>, values LIST<ANY>) - 将给定属性设置到给定的 NODE 值上。

过程 (Procedure) Cypher 25 中已弃用

apoc.create.setProperty

apoc.create.setProperty(nodes ANY, key STRING, value ANY) - 将给定属性设置到给定的 NODE 值上。

过程 (Procedure) Cypher 25 中已弃用

apoc.create.setRelProperties

apoc.create.setRelProperties(rels ANY, keys LIST<STRING>, values LIST<ANY>) - 在 RELATIONSHIP 值上设置给定属性。

过程 (Procedure) Cypher 25 中已弃用

apoc.create.setRelProperty

apoc.create.setRelProperty(rels ANY, key STRING, value ANY) - 在 RELATIONSHIP 值上设置给定属性。

过程 (Procedure) Cypher 25 中已弃用

apoc.create.uuids

apoc.create.uuids(count INTEGER) - 返回 UUID 流。

过程 在 Cypher 5 中已弃用 在 Cypher 25 中已移除

apoc.create.vNode

apoc.create.vNode(labels LIST<STRING>, props MAP<STRING, ANY>) - 返回虚拟 NODE。

过程 函数

apoc.create.vNodes

apoc.create.vNodes(labels LIST<STRING>, props LIST<MAP<STRING, ANY>>) - 返回虚拟 NODE 值。

过程

apoc.create.vRelationship

apoc.create.vRelationship(from NODE, relType STRING, props MAP<STRING, ANY>, to NODE) - 返回虚拟 RELATIONSHIP。

过程 函数

apoc.create.virtualPath

apoc.create.virtualPath(labelsN LIST<STRING>,n MAP<STRING, ANY>, relType STRING, props MAP<STRING, ANY>, labelsM LIST<STRING>, m MAP<STRING, ANY>) - 返回虚拟 PATH。

过程

apoc.create.uuid

apoc.create.uuid() - 返回一个 UUID。

函数 在 Cypher 5 中已弃用 在 Cypher 25 中已移除

apoc.create.uuidBase64

apoc.create.uuidBase64() - 返回一个使用 base64 编码的 UUID。

函数

apoc.create.uuidBase64ToHex

apoc.create.uuidBase64ToHex(base64Uuid STRING) - 接收给定的 base64 编码 UUID，并将其作为十六进制 STRING 返回。

函数

apoc.create.uuidHexToBase64

apoc.create.uuidHexToBase64(uuid STRING) - 接收以十六进制 STRING 表示的给定 UUID，并返回其 base64 编码形式。

函数

apoc.create.virtual.fromNode

apoc.create.virtual.fromNode(node NODE, propertyNames LIST<STRING>, config MAP) - 从给定的现有 NODE 返回虚拟 NODE。虚拟 NODE 仅包含所请求的属性。

函数

apoc.cypher.doIt

apoc.cypher.doIt(statement STRING, params MAP<STRING, ANY>) - 使用给定的参数运行动态构建的语句。此过程允许读取和写入语句。

过程

apoc.cypher.run

apoc.cypher.run(statement STRING, params MAP<STRING, ANY>) - 使用给定的参数运行动态构建的只读语句。

过程

apoc.cypher.runMany

apoc.cypher.runMany(statement STRING, params MAP<STRING, ANY>, config MAP<STRING, ANY>) - 运行每个分号分隔的语句，并返回语句结果的摘要。

过程

apoc.cypher.runManyReadOnly

apoc.cypher.runManyReadOnly(statement STRING, params MAP<STRING, ANY>, config MAP<STRING, ANY>) - 运行每个分号分隔的只读语句，并返回语句结果的摘要。

过程

apoc.cypher.runSchema

apoc.cypher.runSchema(statement STRING, params MAP<STRING, ANY>) - 使用给定的参数运行给定的查询模式语句。

过程

apoc.cypher.runTimeboxed

apoc.cypher.runTimeboxed(statement STRING, params MAP<STRING, ANY>, timeout INTEGER, config MAP) - 如果 Cypher 语句未在设置的超时时间（毫秒）内完成，则终止该语句。

过程

apoc.cypher.runWrite

apoc.cypher.runWrite(statement STRING, params MAP<STRING, ANY>) - apoc.cypher.doIt 的别名。

过程

apoc.cypher.runFirstColumnMany

apoc.cypher.runFirstColumnMany(statement STRING, params MAP<STRING, ANY>) - 使用给定的参数运行给定的语句，并返回收集到 LIST<ANY> 中的第一列。

函数

apoc.cypher.runFirstColumnSingle

apoc.cypher.runFirstColumnSingle(statement STRING, params MAP<STRING, ANY>) - 使用给定的参数运行给定的语句，并返回第一列的第一个元素。

函数

apoc.data.url

apoc.data.url(url STRING) - 将 URL 转换为 MAP。

函数

apoc.date.add

apoc.date.add(time INTEGER, unit STRING, addValue INTEGER, addUnit STRING) - 将指定时间单位的值添加到给定的时间戳中。

函数

apoc.date.convert

apoc.date.convert(time INTEGER, unit STRING, toUnit STRING) - 将给定的时间戳从一个时间单位转换为不同时间单位的时间戳。

函数 (Function) Cypher 25 中已弃用

apoc.date.convertFormat

apoc.date.convertFormat(temporal STRING, currentFormat STRING, convertTo STRING) - 将一种类型的日期格式 STRING 转换为另一种类型的日期格式 STRING。

函数 (Function) Cypher 25 中已弃用

apoc.date.currentTimestamp

apoc.date.currentTimestamp() - 返回当前的 Unix 纪元时间戳（毫秒）。

函数 (Function) Cypher 25 中已弃用

apoc.date.field

apoc.date.field(time INTEGER, unit STRING, timezone STRING) - 从给定的日期时间返回一个字段的值。

函数 (Function) Cypher 25 中已弃用

apoc.date.fields

apoc.date.fields(date STRING, pattern STRING) - 将给定的日期拆分为字段，并返回一个包含每个字段值的 MAP。

函数 (Function) Cypher 25 中已弃用

apoc.date.format

apoc.date.format(time INTEGER, unit STRING, format STRING, timezone STRING) - 返回时间值的 STRING 表示。时间单位（默认：毫秒）、日期格式（默认：ISO）和时区（默认：当前时区）都可以更改。

函数 (Function) Cypher 25 中已弃用

apoc.date.fromISO8601

apoc.date.fromISO8601(time STRING) - 将给定的日期 STRING (ISO8601) 转换为表示时间值的 INTEGER（毫秒）。

函数 (Function) Cypher 25 中已弃用

apoc.date.parse

apoc.date.parse(time STRING, unit STRING, format STRING, timezone STRING) - 将给定的日期 STRING 从指定格式解析为指定的时间单位。

函数 (Function) Cypher 25 中已弃用

apoc.date.systemTimezone

apoc.date.systemTimezone() - 返回系统时区的显示名称（例如 Europe/London）。

函数

apoc.date.toISO8601

apoc.date.toISO8601(time INTEGER, unit STRING) - 返回 ISO8601 格式的指定时间值的 STRING 表示。

函数 (Function) Cypher 25 中已弃用

apoc.date.toYears

apoc.date.toYears(value ANY, format STRING) - 将给定的时间戳或日期转换为表示年份的 FLOAT。

函数

apoc.diff.nodes

apoc.diff.nodes(leftNode NODE, rightNode NODE) - 返回详细说明两个给定 NODE 值之间差异的 MAP。

函数

apoc.do.case

apoc.do.case(conditionals LIST<ANY>, elseQuery STRING, params MAP<STRING, ANY>) - 对于给定 LIST<ANY> 中的每一对条件查询，此过程将运行第一个条件评估为真的查询。如果没有条件为真，则改为运行 ELSE 查询。

过程 (Procedure) Cypher 25 中已弃用

apoc.do.when

apoc.do.when(condition BOOLEAN, ifQuery STRING, elseQuery STRING, params MAP<STRING, ANY>) - 如果条件评估为真，则运行给定的读/写 ifQuery，否则运行 elseQuery。

过程 (Procedure) Cypher 25 中已弃用

apoc.example.movies

apoc.example.movies()- 使用 Neo4j 电影数据集播种数据库。

过程

apoc.export.arrow.all

apoc.export.arrow.all(file STRING, config MAP<STRING, ANY>) - 将整个数据库导出为 arrow 文件。

过程 在 Cypher 5 中已弃用 在 Cypher 25 中已移除

apoc.export.arrow.graph

apoc.export.arrow.graph(file STRING, graph ANY, config MAP<STRING, ANY>) - 将给定的图形导出为 arrow 文件。

过程 在 Cypher 5 中已弃用 在 Cypher 25 中已移除

apoc.export.arrow.query

apoc.export.arrow.query(file STRING, query STRING, config MAP<STRING, ANY>) - 将给定 Cypher 查询的结果导出为 arrow 文件。

过程 在 Cypher 5 中已弃用 在 Cypher 25 中已移除

apoc.export.arrow.stream.all

apoc.export.arrow.stream.all(config MAP<STRING, ANY>) - 将整个数据库导出为 arrow 字节数组。

过程 在 Cypher 5 中已弃用 在 Cypher 25 中已移除

apoc.export.arrow.stream.graph

apoc.export.arrow.stream.graph(graph ANY, config MAP<STRING, ANY>) - 将给定的图形导出为 arrow 字节数组。

过程 在 Cypher 5 中已弃用 在 Cypher 25 中已移除

apoc.export.arrow.stream.query

apoc.export.arrow.stream.query(query STRING, config MAP<STRING, ANY>) - 将给定的 Cypher 查询导出为 arrow 字节数组。

过程 在 Cypher 5 中已弃用 在 Cypher 25 中已移除

apoc.export.csv.all

apoc.export.csv.all(file STRING, config MAP<STRING, ANY>) - 将整个数据库导出到提供的 CSV 文件中。

过程

apoc.export.csv.data

apoc.export.csv.data(nodes LIST<NODE>, rels LIST<RELATIONSHIP>, file STRING, config MAP<STRING, ANY>) - 将给定的 NODE 和 RELATIONSHIP 值导出到提供的 CSV 文件中。

过程

apoc.export.csv.graph

apoc.export.csv.graph(graph MAP<STRING, ANY>, file STRING, config MAP<STRING, ANY>) - 将给定的图导出到提供的 CSV 文件中。

过程

apoc.export.csv.query

apoc.export.csv.query(query STRING, file STRING, config MAP<STRING, ANY>) - 将运行给定 Cypher 查询的结果导出到提供的 CSV 文件中。

过程

apoc.export.cypher.all

apoc.export.cypher.all(file STRING, config MAP<STRING, ANY>) - 将整个数据库（包括索引）以 Cypher 语句形式导出到提供的文件中（默认：Cypher Shell）。

过程

apoc.export.cypher.data

apoc.export.cypher.data(nodes LIST<NODE>, rels LIST<RELATIONSHIP>, file STRING, config MAP<STRING, ANY>) - 将给定的 NODE 和 RELATIONSHIP 值（包括索引）以 Cypher 语句形式导出到提供的文件中（默认：Cypher Shell）。

过程

apoc.export.cypher.graph

apoc.export.cypher.graph(graph MAP<STRING, ANY>, file STRING, config MAP<STRING, ANY>) - 将给定的图形（包括索引）以 Cypher 语句形式导出到提供的文件中（默认：Cypher Shell）。

过程

apoc.export.cypher.query

apoc.export.cypher.query(statement STRING, file STRING, config MAP<STRING, ANY>) - 将给定 Cypher 查询的 NODE 和 RELATIONSHIP 值（包括索引）以 Cypher 语句形式导出到提供的文件中（默认：Cypher Shell）。

过程

apoc.export.cypher.schema

apoc.export.cypher.schema(file STRING, config MAP<STRING, ANY>) - 将所有模式索引和约束导出为 Cypher 语句。

过程

apoc.export.graphml.all

apoc.export.graphml.all(file STRING, config MAP<STRING, ANY>) - 将整个数据库导出到提供的 GraphML 文件中。

过程

apoc.export.graphml.data

apoc.export.graphml.data(nodes LIST<NODE>, rels LIST<RELATIONSHIP>, file STRING, config MAP<STRING, ANY>) - 将给定的 NODE 和 RELATIONSHIP 值导出到提供的 GraphML 文件中。

过程

apoc.export.graphml.graph

apoc.export.graphml.graph(graph MAP<STRING, ANY>, file STRING, config MAP<STRING, ANY>) - 将给定的图形导出到提供的 GraphML 文件中。

过程

apoc.export.graphml.query

apoc.export.graphml.query(statement STRING, file STRING, config MAP<STRING, ANY>) - 将给定 Cypher 语句的 NODE 和 RELATIONSHIP 值导出到提供的 GraphML 文件中。

过程

apoc.export.json.all

apoc.export.json.all(file STRING, config MAP<STRING, ANY>) - 将整个数据库导出到提供的 JSON 文件中。

过程

apoc.export.json.data

apoc.export.json.data(nodes LIST<NODE>, rels LIST<RELATIONSHIP>, file STRING, config MAP<STRING, ANY>) - 将给定的 NODE 和 RELATIONSHIP 值导出到提供的 JSON 文件中。

过程

apoc.export.json.graph

apoc.export.json.graph(graph MAP<STRING, ANY>, file STRING , config MAP<STRING, ANY>) - 将给定的图形导出到提供的 JSON 文件中。

过程

apoc.export.json.query

apoc.export.json.query(statement STRING, file STRING, config MAP<STRING, ANY>) - 将 Cypher 语句的结果导出到提供的 JSON 文件中。

过程

apoc.graph.from

apoc.graph.from(data ANY, name STRING, props MAP<STRING, ANY>) - 通过从给定数据中提取所有 NODE 和 RELATIONSHIP 值来生成虚拟子图。

过程

apoc.graph.fromCypher

apoc.graph.fromCypher(statement STRING, params MAP<STRING, ANY>, name STRING, props MAP<STRING, ANY>) - 通过从给定 Cypher 语句返回的数据中提取所有 NODE 和 RELATIONSHIP 值来生成虚拟子图。

过程

apoc.graph.fromData

apoc.graph.fromData(nodes LIST<NODE>, rels LIST<RELATIONSHIP>, name STRING, props MAP<STRING, ANY>) - 通过从给定数据中提取所有 NODE 和 RELATIONSHIP 值来生成虚拟子图。

过程

apoc.graph.fromDB

apoc.graph.fromDB(name STRING, props MAP<STRING, ANY>) - 通过从给定数据库返回的数据中提取所有 NODE 和 RELATIONSHIP 值来生成虚拟子图。

过程

apoc.graph.fromDocument

apoc.graph.fromDocument(json ANY, config MAP<STRING, ANY>) - 通过从给定 JSON 文件返回的数据中提取所有 NODE 和 RELATIONSHIP 值来生成虚拟子图。

过程

apoc.graph.fromPath

apoc.graph.fromPath(path PATH, name STRING, props MAP<STRING, ANY>) - 通过从给定 PATH 返回的数据中提取所有 NODE 和 RELATIONSHIP 值来生成虚拟子图。

过程

apoc.graph.fromPaths

apoc.graph.fromPaths(paths LIST<PATH>, name STRING, props MAP<STRING, ANY>) - 通过从给定 PATH 值返回的数据中提取所有 NODE 和 RELATIONSHIP 值来生成虚拟子图。

过程

apoc.graph.validateDocument

apoc.graph.validateDocument(json ANY, config MAP<STRING, ANY>) - 验证 JSON 文件并返回验证结果。

过程

apoc.hashing.fingerprint

apoc.hashing.fingerprint(object ANY, excludedPropertyKeys LIST<STRING>) - 计算 NODE 或 RELATIONSHIP 的 MD5 校验和（相同的实体共享相同的校验和）。不适合加密用例。

函数

apoc.hashing.fingerprinting

apoc.hashing.fingerprinting(object ANY, config MAP<STRING, ANY>) - 计算 NODE 或 RELATIONSHIP 的 MD5 校验和（相同的实体共享相同的校验和）。与 apoc.hashing.fingerprint() 不同，此函数支持许多配置参数。不适合加密用例。

函数

apoc.hashing.fingerprintGraph

apoc.hashing.fingerprintGraph(propertyExcludes LIST<STRING>) - 计算整个图形的 MD5 校验和。此函数使用内存中数据结构。不适合加密用例。

函数

apoc.import.csv

apoc.import.csv(nodes LIST<MAP<STRING, ANY>>, rels LIST<MAP<STRING, ANY>>, config MAP<STRING, ANY>) - 从提供的 CSV 文件中导入具有给定标签和类型的 NODE 和 RELATIONSHIP 值。

过程

apoc.import.graphml

apoc.import.graphml(urlOrBinaryFile ANY, config MAP<STRING, ANY>) - 从提供的 GraphML 文件中导入图形。

过程

apoc.import.json

apoc.import.json(urlOrBinaryFile ANY, config MAP<STRING, ANY>) - 从提供的 JSON 文件中导入图形。

过程

apoc.import.xml

apoc.import.xml(urlOrBinary ANY, config MAP<STRING, ANY>) - 从提供的 XML 文件导入图。

过程

apoc.json.path

apoc.json.path(json STRING, path STRING, pathOptions LIST<STRING>) - 返回给定的 JSON 路径。

函数

apoc.label.exists

apoc.label.exists(node ANY, label STRING) - 根据给定的标签是否存在返回 true 或 false。

函数

apoc.load.arrow

apoc.load.arrow(file STRING, config MAP<STRING, ANY>) - 从提供的 arrow 文件中导入 NODE 和 RELATIONSHIP 值。

过程 在 Cypher 5 中已弃用 在 Cypher 25 中已移除

apoc.load.arrow.stream

apoc.load.arrow.stream(source LIST<INTEGER>, config MAP<STRING, ANY>) - 从提供的 arrow 字节数组中导入 NODE 和 RELATIONSHIP 值。

过程 在 Cypher 5 中已弃用 在 Cypher 25 中已移除

apoc.load.json

apoc.load.json(urlOrKeyOrBinary ANY, path STRING, config MAP<STRING, ANY>) - 如果给定的 JSON 文件是 LIST<ANY>，则将 JSON 文件作为值流导入。如果给定的 JSON 文件是 MAP，此过程则导入单个值。

过程

apoc.load.jsonArray

apoc.load.jsonArray(url STRING, path STRING, config MAP<STRING, ANY>) - 从 JSON URL（例如 web-API）加载数组，然后将给定的 JSON 文件作为值流导入。

过程

apoc.load.jsonParams

apoc.load.jsonParams(urlOrKeyOrBinary ANY, headers MAP<STRING, ANY>, payload STRING, path STRING, config MAP<STRING, ANY>) - 从 URL（例如 web-API）加载 JSON 文档。如果给定的 JSON 文档是 LIST<ANY>，则作为值流导入。如果给定的 JSON 文件是 MAP，此过程则导入单个值。

过程 在 Cypher 5 中已弃用 在 Cypher 25 中已移除

apoc.load.xml

apoc.load.xml(urlOrBinary ANY, path STRING, config MAP<STRING, ANY>, simple BOOLEAN) - 从 XML URL（例如 Web-API）加载单个嵌套的 MAP。

过程

apoc.lock.all

apoc.lock.all(nodes LIST<NODE>, rels LIST<RELATIONSHIP>) - 获取给定 NODE 和 RELATIONSHIP 值的写锁。

过程

apoc.lock.nodes

apoc.lock.nodes(nodes LIST<NODE>) - 获取给定 NODE 值的写锁。

过程

apoc.lock.read.nodes

apoc.lock.read.nodes(nodes LIST<NODE>) - 获取给定 NODE 值的读锁。

过程

apoc.lock.read.rels

apoc.lock.read.rels(rels LIST<RELATIONSHIP>) - 获取给定 RELATIONSHIP 值的读锁。

过程

apoc.lock.rels

apoc.lock.rels(rels LIST<RELATIONSHIP>) - 获取给定 RELATIONSHIP 值的写锁。

过程

apoc.log.stream

apoc.log.stream(path STRING, config MAP<STRING, ANY>) - 返回给定日志中的文件内容，可选地仅返回最后 n 行。此过程要求用户具有管理员角色。

过程 在 Cypher 5 中已弃用 在 Cypher 25 中已移除

apoc.map.clean

apoc.map.clean(map MAP<STRING, ANY>, keys LIST<STRING>, values LIST<ANY>) - 过滤给定 LIST<ANY> 值中包含的键和值。

函数

apoc.map.flatten

apoc.map.flatten(map MAP<STRING, ANY>, delimiter STRING) - 展平给定 MAP 中的嵌套项。此函数是 apoc.map.unflatten 函数的逆函数。

函数

apoc.map.fromLists

apoc.map.fromLists(keys LIST<STRING>, values LIST<ANY>) - 根据给定 LIST<ANY> 值中的键和值创建 MAP。

函数

apoc.map.fromNodes

apoc.map.fromNodes(label STRING, prop STRING) - 返回从给定属性到给定标签节点的 MAP。

函数

apoc.map.fromPairs

apoc.map.fromPairs(pairs LIST<LIST<key ANY, value ANY>>) - 根据给定的键值对 LIST<LIST<ANY>> 创建 MAP。

函数

apoc.map.fromValues

apoc.map.fromValues(values LIST<ANY>) - 根据给定 LIST<ANY> 中的交替键和值创建 MAP。

函数

apoc.map.get

apoc.map.get(map MAP<STRING, ANY>, key STRING, value ANY, fail BOOLEAN) - 返回给定键的值。如果给定键不存在或缺少默认值，此函数将抛出异常。

函数

apoc.map.groupBy

apoc.map.groupBy(values LIST<ANY>, key STRING) - 根据给定属性创建 LIST<ANY> 的 MAP，包含单个值。

函数

apoc.map.groupByMulti

apoc.map.groupByMulti(values LIST<ANY>, key STRING) - 根据给定属性创建 LIST<ANY> 值的 MAP，包含 LIST<ANY> 值。

函数

apoc.map.merge

apoc.map.merge(map1 MAP<STRING, ANY>, map2 MAP<STRING, ANY>) - 将两个给定的 MAP 值合并为一个 MAP。

函数

apoc.map.mergeList

apoc.map.mergeList(maps LIST<MAP<STRING, Value>>) - 将给定 LIST<MAP<STRING, ANY>> 中的所有 MAP 值合并为一个 MAP。

函数

apoc.map.mget

apoc.map.mget(map MAP<STRING, ANY>, keys LIST<STRING>, values LIST<ANY>, fail BOOLEAN) - 返回给定键的 LIST<ANY>。如果其中一个键不存在或缺少默认值，此函数将抛出异常。

函数

apoc.map.removeKey

apoc.map.removeKey(map MAP<STRING, ANY>, key STRING, config MAP<STRING, ANY>) - 从 MAP 中移除给定键（如果 recursive 为 true，则递归处理）。

函数

apoc.map.removeKeys

apoc.map.removeKeys(map MAP<STRING, ANY>, keys LIST<STRING>, config MAP<STRING, ANY>) - 从 MAP 中移除给定键（如果 recursive 为 true，则递归处理）。

函数

apoc.map.setEntry

apoc.map.setEntry(map MAP<STRING, ANY>, key STRING, value ANY) - 在 MAP 中添加或更新给定条目。

函数 在 Cypher 5 中已弃用 在 Cypher 25 中已移除

apoc.map.setKey

apoc.map.setKey(map MAP<STRING, ANY>, key STRING, value ANY) - 在 MAP 中添加或更新给定条目。

函数

apoc.map.setLists

apoc.map.setLists(map MAP<STRING, ANY>, keys LIST<STRING>, values LIST<ANY>) - 在 MAP 中添加或更新以 LIST<ANY> 格式（例如 [key1, key2],[value1, value2]）提供的键/值对。

函数

apoc.map.setPairs

apoc.map.setPairs(map MAP<STRING, ANY>, pairs LIST<LIST<key ANY, value ANY>>) - 在 MAP 中添加或更新给定的键/值对（例如 [key1,value1],[key2,value2]）。

函数

apoc.map.setValues

apoc.map.setValues(map MAP<STRING, ANY>, pairs LIST<key ANY, value ANY>) - 在 MAP 中添加或更新交替的键/值对（例如 [key1,value1,key2,value2]）。

函数

apoc.map.sortedProperties

apoc.map.sortedProperties(map MAP<STRING, ANY>, ignoreCase BOOLEAN) - 返回键/值对的 LIST<ANY>。对这些对按键的字母顺序进行排序，并可选择是否区分大小写。

函数

apoc.map.submap

apoc.map.submap(map MAP<STRING, ANY>, keys LIST<STRING>, values LIST<ANY>, fail BOOLEAN) - 返回给定键的子映射。如果其中一个键不存在或缺少默认值，此函数将抛出异常。

函数

apoc.map.unflatten

apoc.map.unflatten(map MAP<STRING, ANY>, delimiter STRING) - 将给定 MAP 中的项展开为嵌套项。此函数是 apoc.map.flatten 函数的逆函数。

函数

apoc.map.updateTree

apoc.map.updateTree(tree MAP<STRING, ANY>, key STRING, data LIST<LIST<key ANY, value ANY>>)- 在嵌套树的每一层添加数据 MAP，其中键值对匹配。

函数

apoc.map.values

apoc.map.values(map MAP<STRING, ANY>, keys LIST<STRING>, addNullsForMissing BOOLEAN) - 返回给定键指示的 LIST<ANY>（如果缺少给定键，则返回 null 值）。

函数

apoc.math.regr

apoc.math.regr(label STRING, propertyY STRING, propertyX STRING) - 返回给定标签中 propertyY 和 propertyX 值的确定系数（R 平方）。

过程

apoc.math.cosh

apoc.math.cosh(value FLOAT) - 返回双曲余弦值。

函数 (Function) Cypher 25 中已弃用

apoc.math.coth

apoc.math.coth(value FLOAT) - 返回双曲余切值。

函数 (Function) Cypher 25 中已弃用

apoc.math.csch

apoc.math.csch(value FLOAT) - 返回双曲余割值。

函数

apoc.math.maxByte

apoc.math.maxByte() - 返回字节的最大值。

函数

apoc.math.maxDouble

apoc.math.maxDouble() - 返回 double 类型的最大正有限值。

函数

apoc.math.maxInt

apoc.math.maxInt() - 返回整数的最大值。

函数

apoc.math.maxLong

apoc.math.maxLong() - 返回长整数的最大值。

函数

apoc.math.minByte

apoc.math.minByte() - 返回字节的最小值。

函数

apoc.math.minDouble

apoc.math.minDouble() - 返回 double 类型的最小正非零值。

函数

apoc.math.minInt

apoc.math.minInt() - 返回整数的最小值。

函数

apoc.math.minLong

apoc.math.minLong() - 返回长整数的最小值。

函数

apoc.math.sech

apoc.math.sech(value FLOAT) - 返回给定值的双曲正割值。

函数

apoc.math.sigmoid

apoc.math.sigmoid(value FLOAT) - 返回给定值的 sigmoid 值。

函数

apoc.math.sigmoidPrime

apoc.math.sigmoidPrime(value FLOAT) - 返回给定值的 sigmoid 原函数 [ sigmoid(val) * (1 - sigmoid(val)) ]。

函数

apoc.math.sinh

apoc.math.sinh(value FLOAT) - 返回给定值的双曲正弦值。

函数 (Function) Cypher 25 中已弃用

apoc.math.tanh

apoc.math.tanh(value FLOAT) - 返回给定值的双曲正切值。

函数 (Function) Cypher 25 中已弃用

apoc.merge.node

apoc.merge.node(labels LIST<STRING>, identProps MAP<STRING, ANY>, onCreateProps MAP<STRING, ANY>, onMatchProps MAP<STRING, ANY>) - 使用给定的动态标签合并给定的 NODE 值。

过程

apoc.merge.node.eager

apoc.merge.node.eager(labels LIST<STRING>, identProps MAP<STRING, ANY>, onCreateProps MAP<STRING, ANY>, onMatchProps MAP<STRING, ANY>) - 预先使用给定的动态标签合并给定的 NODE 值。

过程

apoc.merge.nodeWithStats

apoc.merge.nodeWithStats(labels LIST<STRING>, identProps MAP<STRING, ANY>, onCreateProps MAP<STRING, ANY>, onMatchProps MAP<STRING, ANY>) - 使用给定的动态标签合并给定的 NODE 值。结果中提供 queryStatistics。

过程

apoc.merge.nodeWithStats.eager

apoc.merge.nodeWithStats.eager(labels LIST<STRING>, identProps MAP<STRING, ANY>, onCreateProps MAP<STRING, ANY>, onMatchProps MAP<STRING, ANY>) - 预先使用给定的动态标签合并给定的 NODE 值。结果中提供 queryStatistics。

过程

apoc.merge.relationship

apoc.merge.relationship(startNode NODE, relType STRING, identProps MAP<STRING, ANY>, onCreateProps MAP<STRING, ANY>, endNode NODE, onMatchProps MAP<STRING, ANY>) - 使用给定的动态类型/属性合并给定的 RELATIONSHIP 值。

过程

apoc.merge.relationship.eager

apoc.merge.relationship.eager(startNode NODE, relType STRING, identProps MAP<STRING, ANY>, onCreateProps MAP<STRING, ANY>, endNode NODE, onMatchProps MAP<STRING, ANY>) - 预先使用给定的动态类型/属性合并给定的 RELATIONSHIP 值。

过程

apoc.merge.relationshipWithStats

apoc.merge.relationshipWithStats(startNode NODE, relType STRING, identProps MAP<STRING, ANY>, onCreateProps MAP<STRING, ANY>, endNode NODE, onMatchProps MAP<STRING, ANY>) - 使用给定的动态类型/属性合并给定的 RELATIONSHIP 值。结果中提供 queryStatistics。

过程

apoc.merge.relationshipWithStats.eager

apoc.merge.relationshipWithStats.eager(startNode NODE, relType STRING, identProps MAP<STRING, ANY>, onCreateProps MAP<STRING, ANY>, endNode NODE, onMatchProps MAP<STRING, ANY>) - 预先使用给定的动态类型/属性合并给定的 RELATIONSHIP 值。结果中提供 queryStatistics。

过程

apoc.meta.data

apoc.meta.data(config MAP<STRING, ANY>) - 检查整个图形并返回元数据表。

过程

apoc.meta.data.of

apoc.meta.data.of(graph ANY, config MAP<STRING, ANY>) - 检查给定的子图并返回元数据表。

过程

apoc.meta.graph

apoc.meta.graph(config MAP<STRING, ANY>) - 检查整个图形并返回元图。

过程

apoc.meta.graph.of

apoc.meta.graph.of(graph ANY, config MAP<STRING, ANY>) - 检查给定的子图并返回元图。

过程

apoc.meta.graphSample

apoc.meta.graphSample(config MAP<STRING, ANY>) - 检查整个图形并返回元图。与 apoc.meta.graph 不同，此过程不会过滤掉不存在的路径。

过程

apoc.meta.nodeTypeProperties

apoc.meta.nodeTypeProperties(config MAP<STRING, ANY>) - 检查整个图形并返回包含其中 NODE 值信息的元数据表。

过程

apoc.meta.relTypeProperties

apoc.meta.relTypeProperties(config MAP<STRING, ANY>) - 检查整个图形并返回包含其中 RELATIONSHIP 值信息的元数据表。

过程

apoc.meta.schema

apoc.meta.schema(config MAP<STRING, ANY>) - 检查给定的子图并以 MAP 形式返回元数据。

过程

apoc.meta.stats

apoc.meta.stats() - 返回存储在事务数据库统计信息中的元数据。

过程

apoc.meta.subGraph

apoc.meta.subGraph(config MAP<STRING, ANY>) - 检查给定的子图并返回元图。

过程

apoc.meta.cypher.isType

apoc.meta.cypher.isType(value ANY, type STRING) - 如果给定值匹配给定类型，则返回 true。

函数 (Function) Cypher 25 中已弃用

apoc.meta.cypher.type

apoc.meta.cypher.type(value ANY) - 返回给定值的类型名称。

函数 (Function) Cypher 25 中已弃用

apoc.meta.cypher.types

apoc.meta.cypher.types(props ANY) - 返回包含给定值类型名称的 MAP。

函数

apoc.meta.nodes.count

apoc.meta.nodes.count(nodes LIST<STRING>, config MAP<STRING, ANY>) - 返回 LIST<STRING> 中具有给定标签的 NODE 值的总和。

函数

apoc.neighbors.athop

apoc.neighbors.athop(node NODE, relTypes STRING, distance INTEGER) - 返回由给定 RELATIONSHIP 类型在指定距离处连接的所有 NODE 值。

过程

apoc.neighbors.athop.count

apoc.neighbors.athop.count(node NODE, relTypes STRING, distance INTEGER) - 返回由给定 RELATIONSHIP 类型在指定距离处连接的所有 NODE 值的计数。

过程

apoc.neighbors.byhop

apoc.neighbors.byhop(node NODE, relTypes STRING, distance INTEGER) - 返回由给定 RELATIONSHIP 类型在指定距离内连接的所有 NODE 值。返回 LIST<NODE> 值，其中 NODE 值的每个 PATH 代表 LIST<NODE> 值的一行。

过程

apoc.neighbors.byhop.count

apoc.neighbors.byhop.count(node NODE, relTypes STRING, distance INTEGER) - 返回由给定 RELATIONSHIP 类型在指定距离内连接的所有 NODE 值的计数。

过程

apoc.neighbors.tohop

apoc.neighbors.tohop(node NODE, relTypes STRING, distance INTEGER) - 返回由给定 RELATIONSHIP 类型在指定距离内连接的所有 NODE 值。每行单独返回 NODE 值。

过程

apoc.neighbors.tohop.count

apoc.neighbors.tohop.count(node NODE, relTypes STRING, distance INTEGER) - 返回由模式中的给定 RELATIONSHIP 值在指定距离内连接的所有 NODE 值的计数。

过程

apoc.node.degree

apoc.node.degree(node NODE, relTypes STRING) - 返回给定 NODE 的总度数。

函数 (Function) Cypher 25 中已弃用

apoc.node.degree.in

apoc.node.degree.in(node NODE, relTypes STRING) - 返回连接到给定 NODE 的传入 RELATIONSHIP 值的总数。

函数 (Function) Cypher 25 中已弃用

apoc.node.degree.out

apoc.node.degree.out(node NODE, relTypes STRING) - 返回从给定 NODE 发出的传出 RELATIONSHIP 值的总数。

函数 (Function) Cypher 25 中已弃用

apoc.node.id

apoc.node.id(node NODE) - 返回给定虚拟 NODE 的 ID。

函数

apoc.node.labels

apoc.node.labels(node NODE) - 返回给定虚拟 NODE 的标签。

函数

apoc.node.relationship.exists

apoc.node.relationship.exists(node NODE, relTypes STRING) - 根据给定 NODE 是否具有连接的 RELATIONSHIP（或者给定 NODE 是否具有给定类型和方向的连接 RELATIONSHIP）返回 BOOLEAN。

函数 (Function) Cypher 25 中已弃用

apoc.node.relationship.types

apoc.node.relationship.types(node NODE, relTypes STRING) - 为给定的 NODE 返回一个包含不同 RELATIONSHIP 类型的 LIST<STRING>。

函数

apoc.node.relationships.exist

apoc.node.relationships.exist(node NODE, relTypes STRING) - 根据给定的 NODE 是否具有连接的 RELATIONSHIP 值（或者给定的 NODE 是否具有指定类型和方向的连接 RELATIONSHIP 值）返回一个 BOOLEAN。

函数

apoc.nodes.collapse

apoc.nodes.collapse(nodes LIST<NODE>, config MAP<STRING, ANY>) - 将给定的 LIST<NODE> 中的 NODE 值合并在一起。这些 NODE 值随后合并为一个 NODE，并将之前所有 NODE 值的标签附加到其上，同时所有指向它们的 RELATIONSHIP 值也指向该新节点。

过程

apoc.nodes.cycles

apoc.nodes.cycles(nodes LIST<NODE>, config MAP<STRING, ANY>) - 检测给定 LIST<NODE> 中的所有 PATH 循环。此过程也可以在 RELATIONSHIP 值上进行限制。

过程

apoc.nodes.delete

apoc.nodes.delete(nodes ANY, batchSize INTEGER) - 删除所有具有给定 ID 的 NODE 值。

过程 (Procedure) Cypher 25 中已弃用

apoc.nodes.get

apoc.nodes.get(nodes ANY) - 返回所有具有给定 ID 的 NODE 值。

过程

apoc.nodes.group

apoc.nodes.group(labels LIST<STRING>, groupByProperties LIST<STRING>, aggregations LIST<MAP<STRING, ANY>>, config MAP<STRING, ANY>) - 允许基于给定属性对 NODE 值进行聚合。此过程返回虚拟 NODE 值。

过程

apoc.nodes.link

apoc.nodes.link(nodes LIST<NODE>, type STRING, config MAP<STRING, ANY>) - 创建一个由给定 RELATIONSHIP 类型连接的给定 NODE 值的链表。

过程

apoc.nodes.rels

apoc.nodes.rels(rels ANY) - 返回所有具有给定 ID 的 RELATIONSHIP 值。

过程

apoc.nodes.connected

apoc.nodes.connected(startNode NODE, endNode NODE, types STRING) - 当给定 NODE 直接连接到另一个给定 NODE 时返回 true。此函数针对密集节点进行了优化。

函数

apoc.nodes.isDense

apoc.nodes.isDense(node NODE) - 如果给定的 NODE 是一个密集节点，则返回 true。

函数

apoc.nodes.relationship.types

apoc.nodes.relationship.types(nodes ANY, types STRING) - 从给定的 LIST<NODE> 值中返回一个包含不同 RELATIONSHIP 类型的 LIST<STRING>。

函数

apoc.nodes.relationships.exist

apoc.nodes.relationships.exist(nodes ANY, types STRING) - 根据给定的 NODE 值是否具有给定的 RELATIONSHIP 值返回一个 BOOLEAN。

函数

apoc.number.arabicToRoman

apoc.number.arabicToRoman(number ANY) - 将给定的阿拉伯数字转换为罗马数字。

函数

apoc.number.exact.add

apoc.number.exact.add(stringA STRING, stringB STRING) - 返回将两个给定大数字相加的结果（使用 Java BigDecimal）。

函数

apoc.number.exact.div

apoc.number.exact.div(stringA STRING, stringB STRING, precision INTEGER, roundingMode STRING) - 返回一个大数字除以另一个大数字的结果（使用 Java BigDecimal）。

函数

apoc.number.exact.mul

apoc.number.exact.mul(stringA STRING, stringB STRING, precision INTEGER, roundingMode STRING) - 返回两个给定大数字相乘的结果（使用 Java BigDecimal）。

函数

apoc.number.exact.sub

apoc.number.exact.sub(stringA STRING, stringB STRING) - 返回一个大数字减去另一个大数字的结果（使用 Java BigDecimal）。

函数

apoc.number.exact.toExact

apoc.number.exact.toExact(number INTEGER) - 返回给定数字的精确值（使用 Java BigDecimal）。

函数

apoc.number.exact.toFloat

apoc.number.exact.toFloat(string STRING, precision INTEGER, roundingMode STRING) - 返回给定大数字的 FLOAT 值（使用 Java BigDecimal）。

函数

apoc.number.exact.toInteger

apoc.number.exact.toInteger(string STRING, precision INTEGER, roundingMode STRING) - 返回给定大数字的 INTEGER 值（使用 Java BigDecimal）。

函数

apoc.number.format

apoc.number.format(number ANY, pattern STRING, language STRING) - 使用给定的模式和语言格式化给定的 INTEGER 或 FLOAT，以生成 STRING。

函数

apoc.number.parseFloat

apoc.number.parseFloat(text STRING, pattern STRING, language STRING) - 使用给定的模式和语言解析给定的 STRING，以生成 FLOAT。

函数

apoc.number.parseInt

apoc.number.parseInt(text STRING, pattern STRING, language STRING) - 使用给定的模式和语言解析给定的 STRING，以生成 INTEGER。

函数

apoc.number.romanToArabic

apoc.number.romanToArabic(romanNumber STRING) - 将给定的罗马数字转换为阿拉伯数字。

函数

apoc.path.expand

apoc.path.expand(startNode ANY, relFilter STRING, labelFilter STRING, minDepth INTEGER, maxDepth INTEGER) - 返回从起始 NODE 扩展的 PATH 值，沿给定的 RELATIONSHIP 类型，从最小深度到最大深度。

过程

apoc.path.expandConfig

apoc.path.expandConfig(startNode ANY, config MAP<STRING, ANY>) - 返回从起始 NODE 扩展的 PATH 值，沿给定的 RELATIONSHIP 类型，从最小深度到最大深度。

过程

apoc.path.spanningTree

apoc.path.spanningTree(startNode ANY, config MAP<STRING, ANY>) - 返回从起始 NODE 扩展的生成树 PATH 值，沿给定的 RELATIONSHIP 类型直到最大深度。

过程

apoc.path.subgraphAll

apoc.path.subgraphAll(startNode ANY, config MAP<STRING, ANY>) - 返回从起始 NODE 开始，沿着给定的 RELATIONSHIP 类型扩展至最大深度的可达子图。

过程

apoc.path.subgraphNodes

apoc.path.subgraphNodes(startNode ANY, config MAP<STRING, ANY>) - 返回子图中可从起始 NODE 到达的 NODE 值，沿给定的 RELATIONSHIP 类型直到最大深度。

过程

apoc.path.combine

apoc.path.combine(path1 PATH, path2 PATH) - 将两个给定的 PATH 值合并为一个 PATH。

函数

apoc.path.create

apoc.path.create(startNode NODE, rels LIST<RELATIONSHIP>) - 从给定的起始 NODE 和 LIST<RELATIONSHIP> 返回一个 PATH。

函数

apoc.path.elements

apoc.path.elements(path PATH) - 将给定的 PATH 转换为 LIST<NODE | RELATIONSHIP>。

函数

apoc.path.slice

apoc.path.slice(path PATH, offset INTEGER, length INTEGER) - 返回一个新的指定长度的 PATH，取自给定 PATH 的指定偏移量处。

函数

apoc.paths.toJsonTree

apoc.paths.toJsonTree(paths LIST<PATH>, lowerCaseRels BOOLEAN, config MAP<STRING, ANY>) - 返回 MAP 值流，通过遍历输出关系将图表示为树。

过程

apoc.periodic.cancel

apoc.periodic.cancel(name STRING) - 取消给定的后台任务。后台任务通过 apoc.periodic.submit 创建。

过程

apoc.periodic.commit

apoc.periodic.commit(statement STRING, params MAP<STRING, ANY>) - 在单独的批量事务中运行给定的语句。

过程

apoc.periodic.countdown

apoc.periodic.countdown(name STRING, statement STRING, delay INTEGER) - 重复运行后台语句，直到返回 0。

过程

apoc.periodic.iterate

apoc.periodic.iterate(cypherIterate STRING, cypherAction STRING, config MAP<STRING, ANY>) - 对第一个语句返回的每一项运行第二个语句。此过程返回批次数和已处理行的总数。

过程

apoc.periodic.list

apoc.periodic.list() - 返回所有后台任务的 LIST<ANY>。

过程

apoc.periodic.repeat

apoc.periodic.repeat(name STRING, statement STRING, rate INTEGER, config MAP<STRING, ANY>) - 运行一个重复调用的后台任务。要停止此过程，请使用 apoc.periodic.cancel。

过程

apoc.periodic.submit

apoc.periodic.submit(name STRING, statement STRING, params MAP<STRING, ANY>) - 创建一个后台任务，运行一次给定的 Cypher 语句。

过程

apoc.periodic.truncate

apoc.periodic.truncate(config MAP<STRING, ANY>) - 使用 apoc.periodic.iterate 过程从数据库中删除所有实体（以及可选的索引和约束）。

过程

apoc.refactor.categorize

apoc.refactor.categorize(sourceKey STRING, type STRING, outgoing BOOLEAN, label STRING, targetKey STRING, copiedKeys LIST<STRING>, batchSize INTEGER) - 从图中具有指定 sourceKey 属性的 NODE 值创建新的分类 NODE 值。新的分类 NODE 值随后通过给定类型的 RELATIONSHIP 连接到原始 NODE 值。

过程 (Procedure) Cypher 25 中已弃用

apoc.refactor.cloneNodes

apoc.refactor.cloneNodes(nodes LIST<NODE>, withRelationships BOOLEAN, skipProperties LIST<STRING>) - 克隆给定的 NODE 值及其标签和属性。可以使用 skipProperties 跳过任何 NODE 属性（注意：这仅跳过 NODE 值上的属性，而不跳过其 RELATIONSHIP 值）。

过程

apoc.refactor.cloneSubgraph

apoc.refactor.cloneSubgraph(nodes LIST<NODE>, rels LIST<RELATIONSHIP>, config MAP<STRING, ANY>) - 克隆给定的 NODE 值及其标签和属性（可通过 config MAP 中的 skipProperties LIST<STRING> 可选地跳过任何属性），并克隆给定的 RELATIONSHIP 值。如果未提供 RELATIONSHIP 值，则将克隆给定 NODE 值之间所有现有的 RELATIONSHIP 值。

过程

apoc.refactor.cloneSubgraphFromPaths

apoc.refactor.cloneSubgraphFromPaths(paths LIST<PATH>, config MAP<STRING, ANY>) - 克隆由给定 LIST<PATH> 值定义的子图。可以通过 config MAP 中的 skipProperties LIST<STRING> 跳过任何 NODE 属性。

过程

apoc.refactor.collapseNode

apoc.refactor.collapseNode(nodes ANY, relType STRING) - 折叠给定的 NODE 并用给定类型的 RELATIONSHIP 替换它。

过程

apoc.refactor.deleteAndReconnect

apoc.refactor.deleteAndReconnect(path PATH, nodes LIST<NODE>, config MAP<STRING, ANY>) - 从 PATH 中删除给定的 NODE 值并重新连接剩余的 NODE 值。

过程

apoc.refactor.extractNode

apoc.refactor.extractNode(rels ANY, labels LIST<STRING>, outType STRING, inType STRING) - 将给定的 RELATIONSHIP 值展开为中间 NODE 值。中间 NODE 值通过给定的 outType 和 inType 连接。

过程

apoc.refactor.from

apoc.refactor.from(rel RELATIONSHIP, newNode NODE, config MAP<STRING, ANY>) - 将给定的 RELATIONSHIP 重定向到给定的起始 NODE。

过程

apoc.refactor.invert

apoc.refactor.invert(rel RELATIONSHIP, config MAP<STRING, ANY>) - 反转给定 RELATIONSHIP 的方向。

过程

apoc.refactor.mergeNodes

apoc.refactor.mergeNodes(nodes LIST<NODE>, config MAP<STRING, ANY>) - 将给定的 LIST<NODE> 合并到 LIST<NODE> 中的第一个 NODE 上。所有 RELATIONSHIP 值也会合并到该 NODE 上。

过程

apoc.refactor.mergeRelationships

apoc.refactor.mergeRelationships(rels LIST<RELATIONSHIP>, config MAP<STRING, ANY>) - 将给定的 LIST<RELATIONSHIP> 合并到 LIST<RELATIONSHIP> 中的第一个 RELATIONSHIP 上。

过程

apoc.refactor.normalizeAsBoolean

apoc.refactor.normalizeAsBoolean(entity ANY, propertyKey STRING, trueValues LIST<ANY>, falseValues LIST<ANY>) - 将给定属性重构为 BOOLEAN。

过程

apoc.refactor.rename.label

apoc.refactor.rename.label(oldLabel STRING, newLabel STRING, nodes LIST<NODE>) - 将所有 NODE 值的给定标签从 oldLabel 重命名为 newLabel。如果提供了 LIST<NODE>，则重命名仅应用于此 LIST<NODE> 内的 NODE 值。

过程 (Procedure) Cypher 25 中已弃用

apoc.refactor.rename.nodeProperty

apoc.refactor.rename.nodeProperty(oldName STRING, newName STRING, nodes LIST<NODE>, config MAP<STRING, ANY>) - 将所有 NODE 值的给定属性从 oldName 重命名为 newName。如果提供了 LIST<NODE>，则重命名仅应用于此 LIST<NODE> 内的 NODE 值。

过程 (Procedure) Cypher 25 中已弃用

apoc.refactor.rename.type

apoc.refactor.rename.type(oldType STRING, newType STRING, rels LIST<RELATIONSHIP>, config MAP<STRING, ANY>) - 将所有类型为 oldType 的 RELATIONSHIP 值重命名为 newType。如果提供了 LIST<RELATIONSHIP>，则重命名仅应用于此 LIST<RELATIONSHIP> 内的 RELATIONSHIP 值。

过程 (Procedure) Cypher 25 中已弃用

apoc.refactor.rename.typeProperty

apoc.refactor.rename.typeProperty(oldName STRING, newName STRING, rels LIST<RELATIONSHIP>, config MAP<STRING, ANY>) - 将所有 RELATIONSHIP 值的给定属性从 oldName 重命名为 newName。如果提供了 LIST<RELATIONSHIP>，则重命名仅应用于此 LIST<RELATIONSHIP> 内的 RELATIONSHIP 值。

过程 (Procedure) Cypher 25 中已弃用

apoc.refactor.setType

apoc.refactor.setType(rel RELATIONSHIP, newType STRING) - 更改给定 RELATIONSHIP 的类型。

过程 (Procedure) Cypher 25 中已弃用

apoc.refactor.to

apoc.refactor.to(rel RELATIONSHIP, endNode NODE, config MAP<STRING, ANY>) - 将给定的 RELATIONSHIP 重定向到给定的结束 NODE。

过程

apoc.rel.endNode

apoc.rel.endNode(rel RELATIONSHIP) - 返回给定虚拟 RELATIONSHIP 的结束 NODE。

函数

apoc.rel.id

apoc.rel.id(rel RELATIONSHIP) - 返回给定虚拟 RELATIONSHIP 的 ID。

函数

apoc.rel.startNode

apoc.rel.startNode(rel RELATIONSHIP) - 返回给定虚拟 RELATIONSHIP 的起始 NODE。

函数

apoc.rel.type

apoc.rel.type(rel RELATIONSHIP) - 返回给定虚拟 RELATIONSHIP 的类型。

函数

apoc.schema.assert

apoc.schema.assert(indexes MAP<STRING, LIST<ANY>>, constraints MAP<STRING, LIST<ANY>>, dropExisting BOOLEAN) - 当 dropExisting 为 true 时（默认值为 true），删除所有其他现有索引和约束。在操作结束时断言给定的索引和唯一约束已存在。

过程

apoc.schema.nodes

apoc.schema.nodes(config MAP<STRING, ANY>) - 返回数据库中所有 NODE 标签的索引和约束信息。可以在配置参数中定义要包含或排除的标签集。

过程

apoc.schema.properties.distinct

apoc.schema.properties.distinct(label STRING, key STRING) - 返回给定键的所有不同 NODE 属性值。

过程

apoc.schema.properties.distinctCount

apoc.schema.properties.distinctCount(label STRING, key STRING) - 返回给定键的所有不同属性值及其计数。

过程

apoc.schema.relationships

apoc.schema.relationships(config MAP<STRING, ANY>) - 返回数据库中所有关系类型的索引和约束信息。可以在配置参数中定义要包含或排除的关系类型集。

过程

apoc.schema.node.constraintExists

apoc.schema.node.constraintExists(labelName STRING, propertyName LIST<STRING>) - 根据给定 NODE 标签和给定属性名是否存在约束返回一个 BOOLEAN。

函数

apoc.schema.node.indexExists

apoc.schema.node.indexExists(labelName STRING, propertyName LIST<STRING>) - 根据给定 NODE 标签和给定属性名是否存在索引返回一个 BOOLEAN。

函数

apoc.schema.relationship.constraintExists

apoc.schema.relationship.constraintExists(type STRING, propertyName LIST<STRING>) - 根据给定 RELATIONSHIP 类型和给定属性名是否存在约束返回一个 BOOLEAN。

函数

apoc.schema.relationship.indexExists

apoc.schema.relationship.indexExists(type STRING, propertyName LIST<STRING>)- 根据给定 RELATIONSHIP 类型和给定属性名是否存在索引返回一个 BOOLEAN。

函数

apoc.scoring.existence

apoc.scoring.existence(score INTEGER, exists BOOLEAN) - 如果为 true 则返回给定分数，如果为 false 则返回 0。

函数

apoc.scoring.pareto

apoc.scoring.pareto(minimumThreshold INTEGER, eightyPercentValue INTEGER, maximumValue INTEGER, score INTEGER) - 对给定的 INTEGER 值应用帕累托评分函数。

函数

apoc.search.multiSearchReduced

apoc.search.multiSearchReduced(labelPropertyMap ANY, operator STRING, value STRING) - 返回在多个索引上进行并行搜索后找到的 NODE 值的简化表示。简化的 NODE 值表示包括：节点 ID、节点标签和搜索的属性。

过程

apoc.search.node

apoc.search.node(labelPropertyMap ANY, operator STRING, value STRING) - 返回在多个索引上进行并行搜索后找到的所有不同 NODE 值。

过程

apoc.search.nodeAll

apoc.search.nodeAll(labelPropertyMap ANY, operator STRING, value STRING) - 返回在多个索引上进行并行搜索后找到的所有 NODE 值。

过程

apoc.search.nodeAllReduced

apoc.search.nodeAllReduced(labelPropertyMap ANY, operator STRING, value ANY) - 返回在多个索引上进行并行搜索后找到的 NODE 值的简化表示。简化的 NODE 值表示包括：节点 ID、节点标签和搜索的属性。

过程

apoc.search.nodeReduced

apoc.search.nodeReduced(labelPropertyMap ANY, operator STRING, value STRING) - 返回在多个索引上进行并行搜索后找到的不同 NODE 值的简化表示。简化的 NODE 值表示包括：节点 ID、节点标签和搜索的属性。

过程

apoc.spatial.geocode

apoc.spatial.geocode(location STRING, maxResults INTEGER, quotaException BOOLEAN, config MAP<STRING, ANY>)) - 使用地理编码服务（默认：OpenStreetMap）返回给定地址的地理位置（纬度、经度和描述）。

过程

apoc.spatial.geocodeOnce

apoc.spatial.geocodeOnce(location STRING, config MAP<STRING, ANY>) - 使用地理编码服务（默认：OpenStreetMap）返回给定地址的地理位置（纬度、经度和描述）。此过程最多返回一个结果。

过程

apoc.spatial.reverseGeocode

apoc.spatial.reverseGeocode(latitude FLOAT, longitude FLOAT, quotaException BOOLEAN, config MAP<STRING, ANY>) - 使用地理编码服务（默认：OpenStreetMap）从给定的地理位置（纬度、经度）返回文本地址。此过程最多返回一个结果。

过程

apoc.spatial.sortByDistance

apoc.spatial.sortByDistance(paths LIST<PATH>) - 根据 NODE 值中的纬度/经度值，按距离之和对给定的 PATH 值集合进行排序。

过程

apoc.stats.degrees

apoc.stats.degrees(relTypes STRING) - 返回由给定 RELATIONSHIP 类型连接的 NODE 值上度的百分位分组。

过程

apoc.temporal.format

apoc.temporal.format(temporal ANY, format STRING) - 将给定的时间值格式化为指定的时间格式。

函数 (Function) Cypher 25 中已弃用

apoc.temporal.formatDuration

apoc.temporal.formatDuration(input ANY, format STRING) - 将给定的持续时间格式化为指定的时间格式。

函数 (Function) Cypher 25 中已弃用

apoc.temporal.toZonedTemporal

apoc.temporal.toZonedTemporal(time STRING, format STRING, timezone STRING) - 使用指定的格式将给定的日期 STRING 解析为指定时区。

函数 (Function) Cypher 25 中已弃用

apoc.text.phoneticDelta

apoc.text.phoneticDelta(text1 STRING, text2 STRING) - 返回两个给定 STRING 值之间的 US_ENGLISH soundex 字符差异。

过程

apoc.text.base64Decode

apoc.text.base64Decode(text STRING) - 解码给定的 Base64 编码 STRING。

函数

apoc.text.base64Encode

apoc.text.base64Encode(text STRING) - 使用 Base64 编码给定的 STRING。

函数

apoc.text.base64UrlDecode

apoc.text.base64UrlDecode(url STRING) - 解码给定的 Base64 编码 URL。

函数

apoc.text.base64UrlEncode

apoc.text.base64UrlEncode(url STRING) - 使用 Base64 编码给定的 URL。

函数

apoc.text.byteCount

apoc.text.byteCount(text STRING, charset STRING) - 返回给定 STRING 的字节大小。

函数

apoc.text.bytes

apoc.text.bytes(text STRING, charset STRING) - 以字节形式返回给定的 STRING。

函数

apoc.text.camelCase

apoc.text.camelCase(text STRING) - 将给定的 STRING 转换为驼峰式大小写。

函数

apoc.text.capitalize

apoc.text.capitalize(text STRING) - 将给定 STRING 的首字母大写。

函数

apoc.text.capitalizeAll

apoc.text.capitalizeAll(text STRING) - 将给定 STRING 中每个单词的首字母大写。

函数

apoc.text.charAt

apoc.text.charAt(text STRING, index INTEGER) - 返回给定索引处字符的 INTEGER 值。

函数

apoc.text.clean

apoc.text.clean(text STRING) - 从给定的 STRING 中除去除字母数字字符以外的所有内容，并将其转换为小写。

函数

apoc.text.code

apoc.text.code(codepoint INTEGER) - 将 INTEGER 值转换为 STRING。

函数

apoc.text.compareCleaned

apoc.text.compareCleaned(text1 STRING, text2 STRING) - 比较两个给定的 STRING 值（除去除字母数字字符以外的所有内容并转换为小写）。

函数

apoc.text.decapitalize

apoc.text.decapitalize(text STRING) - 将给定 STRING 的第一个字母从大写转换为小写。

函数

apoc.text.decapitalizeAll

apoc.text.decapitalizeAll(text STRING) - 将给定 STRING 中每个单词的第一个字母转换为小写。

函数

apoc.text.distance

apoc.text.distance(text1 STRING, text2 STRING) - 使用 Levenshtein 距离算法比较两个给定的 STRING 值。

函数

apoc.text.doubleMetaphone

apoc.text.doubleMetaphone(value STRING) - 返回给定 STRING 值中所有单词的 double metaphone 语音编码。

函数

apoc.text.format

apoc.text.format(text STRING, params LIST<ANY>, language STRING) - 使用给定的参数格式化给定的 STRING。

函数

apoc.text.fuzzyMatch

apoc.text.fuzzyMatch(text1 STRING, text2 STRING) - 对两个给定的 STRING 值执行模糊匹配搜索。

函数

apoc.text.hammingDistance

apoc.text.hammingDistance(text1 STRING, text2 STRING) - 使用 Hamming 距离算法比较两个给定的 STRING 值。

函数

apoc.text.hexCharAt

apoc.text.hexCharAt(text STRING, index INTEGER) - 返回给定 STRING 在给定索引处的十六进制值。

函数

apoc.text.hexValue

apoc.text.hexValue(value INTEGER) - 返回给定值的十六进制值。

函数

apoc.text.indexOf

apoc.text.indexOf(text STRING, lookup STRING, from INTEGER, to INTEGER) - 返回给定 STRING 中查找 STRING 的第一次出现，如果未找到则返回 -1。

函数

apoc.text.indexesOf

apoc.text.indexesOf(text STRING, lookup STRING, from INTEGER, to INTEGER) - 返回给定 STRING 中查找 STRING 的所有出现，如果未找到则返回空列表。

函数

apoc.text.jaroWinklerDistance

apoc.text.jaroWinklerDistance(text1 STRING, text2 STRING) - 使用 Jaro-Winkler 距离算法比较两个给定的 STRING 值。

函数

apoc.text.join

apoc.text.join(texts LIST<STRING>, delimiter STRING) - 使用给定的分隔符连接给定的 STRING 值。

函数

apoc.text.levenshteinDistance

apoc.text.levenshteinDistance(text1 STRING, text2 STRING) - 使用 Levenshtein 距离算法比较给定的 STRING 值。

函数 已弃用

apoc.text.levenshteinSimilarity

apoc.text.levenshteinSimilarity(text1 STRING, text2 STRING) - 根据 Levenshtein 距离算法返回两个给定 STRING 值之间的相似度（0 到 1 之间的值）。

函数

apoc.text.lpad

apoc.text.lpad(text STRING, count INTEGER, delimiter STRING) - 将给定的 STRING 向左填充到指定宽度。

函数

apoc.text.phonetic

apoc.text.phonetic(text STRING) - 返回 STRING 中所有单词的 US_ENGLISH phonetic soundex 编码。

函数

apoc.text.random

apoc.text.random(length INTEGER, valid STRING) - 使用长度参数和可选的有效字符 STRING 生成给定长度的随机 STRING。不适合加密用途。

函数

apoc.text.regexGroups

apoc.text.regexGroups(text STRING, regex STRING) - 返回给定文本中匹配给定正则表达式的所有组。

函数

apoc.text.regexGroupsByName

apoc.text.regexGroupsByName(text STRING, regex STRING) - 返回给定文本中组名匹配正则表达式的所有组。

函数

apoc.text.regreplace

apoc.text.regreplace(text STRING, regex STRING, replacement STRING) - 查找并用给定的替换内容替换给定正则表达式找到的所有匹配项。

函数 在 Cypher 5 中已弃用 在 Cypher 25 中已移除

apoc.text.repeat

apoc.text.repeat(item STRING, count INTEGER) - 返回给定项乘以给定计数的结果。

函数

apoc.text.replace

apoc.text.replace(text STRING, regex STRING, replacement STRING) - 查找并用给定的替换内容替换给定正则表达式找到的所有匹配项。

函数

apoc.text.rpad

apoc.text.rpad(text STRING, count INTEGER, delimiter STRING) - 将给定的 STRING 向右填充到指定宽度。

函数

apoc.text.slug

apoc.text.slug(text STRING, delimiter STRING) - 用给定的分隔符替换给定 STRING 中的空格。

函数

apoc.text.snakeCase

apoc.text.snakeCase(text STRING) - 将给定的 STRING 转换为蛇形命名法。

函数

apoc.text.sorensenDiceSimilarity

apoc.text.sorensenDiceSimilarity(text1 STRING, text2 STRING, languageTag STRING) - 使用带有提供的 IETF 语言标签的 Sørensen–Dice 系数公式比较两个给定的 STRING 值。

函数

apoc.text.split

apoc.text.split(text STRING, regex STRING, limit INTEGER) - 使用给定的正则表达式作为分隔符拆分给定的 STRING。

函数

apoc.text.swapCase

apoc.text.swapCase(text STRING) - 交换给定 STRING 中的大小写。

函数

apoc.text.toCypher

apoc.text.toCypher(value ANY, config MAP<STRING, ANY>) - 将给定值转换为 Cypher 属性 STRING。

函数

apoc.text.toUpperCase

apoc.text.toUpperCase(text STRING) - 将给定的 STRING 转换为大写。

函数

apoc.text.upperCamelCase

apoc.text.upperCamelCase(text STRING) - 将给定的 STRING 转换为大驼峰式大小写。

函数

apoc.text.urldecode

apoc.text.urldecode(text STRING) - 解码给定的 URL 编码 STRING。

函数

apoc.text.urlencode

apoc.text.urlencode(text STRING) - 编码给定的 URL STRING。

函数

apoc.trigger.add

apoc.trigger.add(name STRING, statement STRING, selector MAP<STRING, ANY>, config MAP<STRING, ANY>) - 为给定的 Cypher 语句添加触发器。此过程的选择器为 {phase:'before/after/rollback/afterAsync'}。

过程 在 Cypher 5 中已弃用 在 Cypher 25 中已移除

apoc.trigger.drop

apoc.trigger.drop(databaseName STRING, name STRING) - 最终删除给定的触发器。

过程

apoc.trigger.dropAll

apoc.trigger.dropAll(databaseName STRING) - 最终从给定数据库中删除所有触发器。

过程

apoc.trigger.install

apoc.trigger.install(databaseName STRING, name STRING, statement STRING, selector MAP<STRING, ANY>, config MAP<STRING, ANY>) - 最终为给定数据库添加一个触发器，该触发器在成功发生事务时调用。

过程

apoc.trigger.list

apoc.trigger.list() - 列出当前为会话数据库安装的所有触发器。

过程

apoc.trigger.pause

apoc.trigger.pause(name STRING) - 暂停给定的触发器。

过程 在 Cypher 5 中已弃用 在 Cypher 25 中已移除

apoc.trigger.remove

apoc.trigger.remove(name STRING) - 删除给定的触发器。

过程 在 Cypher 5 中已弃用 在 Cypher 25 中已移除

apoc.trigger.removeAll

apoc.trigger.removeAll() - 删除所有先前添加的触发器。

过程 在 Cypher 5 中已弃用 在 Cypher 25 中已移除

apoc.trigger.resume

apoc.trigger.resume(name STRING) - 恢复给定的暂停触发器。

过程 在 Cypher 5 中已弃用 在 Cypher 25 中已移除