过程与函数

apoc.case

apoc.case(conditionals LIST<任意类型>, elseQuery 字符串, params MAP) - 对于给定LIST<任意类型>中的每对条件和只读查询，此过程将运行条件评估为真的第一个查询。如果所有条件都不为真，则将运行ELSE查询。

过程

apoc.help

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

过程

apoc.version

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

函数

apoc.when

apoc.when(condition 布尔值, ifQuery 字符串, elseQuery 字符串, params MAP<字符串, 任意类型>) - 如果条件评估为真，此过程将运行只读的ifQuery，否则将运行elseQuery。

过程

apoc.agg.first

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

函数

apoc.agg.graph

apoc.agg.graph(path 任意类型) - 将所有不同的节点和关系值收集到一个MAP中，其中包含键nodes和relationships。

函数

apoc.agg.last

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

函数

apoc.agg.maxItems

apoc.agg.maxItems(items 任意类型, value 任意类型, groupLimit 整数) - 返回一个MAP {items: LIST<任意类型>, value: 任意类型}，其中value键是存在的最大值，items表示所有具有相同值的项。项目列表的大小可以限制在给定的最大大小。

函数

apoc.agg.median

apoc.agg.median(value 任意类型) - 返回所有非空整数和浮点数值的数学中位数。

函数

apoc.agg.minItems

apoc.agg.minItems(items 任意类型, value 任意类型, groupLimit 整数) - 返回一个MAP {items: LIST<任意类型>, value: 任意类型}，其中value键是存在的最小值，items表示所有具有相同值的项。项目列表的大小可以限制在给定的最大大小。

函数

apoc.agg.nth

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

函数

apoc.agg.percentiles

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

函数

apoc.agg.product

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

函数

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* 搜索算法，使用给定的 RELATIONSHIP 属性名称作为成本函数，查找两个 NODE 值之间的最优路径。

过程

apoc.algo.aStarConfig

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

过程

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 值。

过程

apoc.algo.dijkstra

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

过程

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> 值压缩在一起的结果，每对压缩值一行。

过程

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）。

函数

apoc.coll.containsAll

apoc.coll.containsAll(coll1 LIST<ANY>, coll2 LIST<ANY>) - 返回给定集合中是否包含所有给定值（使用 HashSet）。

函数

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>。

函数

apoc.coll.flatten

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

函数

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> 中首次出现的索引。

函数

apoc.coll.insert

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

函数

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>) - 如果两个集合包含相同元素且基数相同，无论顺序如何（使用 HashMap），则返回 true。

函数

apoc.coll.max

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

函数

apoc.coll.min

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

函数

apoc.coll.occurrences

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

函数

apoc.coll.pairs

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

函数

apoc.coll.pairsMin

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

函数

apoc.coll.pairWithOffset

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

函数

apoc.coll.partition

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

函数

apoc.coll.randomItem

apoc.coll.randomItem(coll LIST<ANY>) - 从 LIST<ANY> 中返回一个随机项，或在 LIST<NOTHING> 或 LIST<NULL> 时返回 null。

函数

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> 中移除一系列值，从给定长度值的索引位置开始。

函数

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> 按升序排序。

函数

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> 按节点的属性降序排序。

函数

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。

函数

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 的总和。

函数

apoc.coll.sumLongs

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

函数

apoc.coll.toSet

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

函数

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> 值的完整并集（包含重复项）。

函数

apoc.coll.zip

apoc.coll.zip(list1 LIST<ANY>, list2 LIST<ANY>) - 将两个给定 LIST<ANY> 值压缩为 LIST<LIST<ANY>>。

函数

apoc.convert.setJsonProperty

过程

apoc.convert.toTree

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

Procedure Deprecated

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>。

函数

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> 的集合。

函数

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 值。

过程

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。

过程

apoc.create.nodes

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

过程

apoc.create.relationship

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

过程

apoc.create.removeLabels

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

过程

apoc.create.removeProperties

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

过程

apoc.create.removeRelProperties

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

过程

apoc.create.setLabels

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

过程

apoc.create.setProperties

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

过程

apoc.create.setProperty

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

过程

apoc.create.setRelProperties

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

过程

apoc.create.setRelProperty

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

过程

apoc.create.uuids

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

Procedure Deprecated

apoc.create.vNode

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

Procedure Function

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。

Procedure Function

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。

Function Deprecated

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) - 将给定时间戳从一个时间单位转换为不同时间单位的时间戳。

函数

apoc.date.convertFormat

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

函数

apoc.date.currentTimestamp

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

函数

apoc.date.field

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

函数

apoc.date.fields

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

函数

apoc.date.format

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

函数

apoc.date.fromISO8601

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

函数

apoc.date.parse

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

函数

apoc.date.systemTimezone

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

函数

apoc.date.toISO8601

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

函数

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> 中的每对条件查询，此过程将运行条件评估为 true 的第一个查询。如果所有条件都不为 true，则将运行 ELSE 查询。

过程

apoc.do.when

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

过程

apoc.example.movies

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

过程

apoc.export.arrow.all

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

Procedure Deprecated

apoc.export.arrow.graph

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

Procedure Deprecated

apoc.export.arrow.query

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

Procedure Deprecated

apoc.export.arrow.stream.all

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

Procedure Deprecated

apoc.export.arrow.stream.graph

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

Procedure Deprecated

apoc.export.arrow.stream.query

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

Procedure Deprecated

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 值。

Procedure Deprecated

apoc.load.arrow.stream

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

Procedure Deprecated

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>) - 如果给定 JSON 文档是 LIST<ANY>，则从 URL（例如 Web API）加载 JSON 文档作为值流。如果给定 JSON 文件是 MAP，则此过程改为导入单个值。

Procedure Deprecated

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 行。此过程要求用户具有管理员角色。

Procedure Deprecated

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 中添加或更新给定条目。

Function Deprecated

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) - 返回双曲余弦。

函数

apoc.math.coth

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

函数

apoc.math.csch

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

函数

apoc.math.maxByte

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

函数

apoc.math.maxDouble

apoc.math.maxDouble() - 返回双精度浮点型最大正有限值。

函数

apoc.math.maxInt

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

函数

apoc.math.maxLong

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

函数

apoc.math.minByte

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

函数

apoc.math.minDouble

apoc.math.minDouble() - 返回双精度浮点型最小正非零值。

函数

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) - 返回给定值的双曲正弦。

函数

apoc.math.tanh

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

函数

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 值。在结果中提供查询统计信息。

过程

apoc.merge.nodeWithStats.eager

apoc.merge.nodeWithStats.eager(labels LIST<STRING>, identProps MAP<STRING, ANY>, onCreateProps MAP<STRING, ANY>, onMatchProps MAP<STRING, ANY>) - 立即合并具有给定动态标签的给定 NODE 值。在结果中提供查询统计信息。

过程

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 值。在结果中提供查询统计信息。

过程

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 值。在结果中提供查询统计信息。

过程

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。

函数

apoc.meta.cypher.type

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

函数

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 的总度数。

函数

apoc.node.degree.in

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

函数

apoc.node.degree.out

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

函数

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) - 返回一个 BOOLEAN，表示给定 NODE 是否具有连接 RELATIONSHIP（或给定 NODE 是否具有给定类型和方向的连接 RELATIONSHIP）。

函数

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) - 返回一个 BOOLEAN，表示给定 NODE 是否具有连接 RELATIONSHIP 值（或给定 NODE 是否具有给定类型和方向的连接 RELATIONSHIP 值）。

函数

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 值。

过程

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 沿给定 RELATIONSHIP 类型从最小深度到最大深度扩展的 PATH 值。

过程

apoc.path.expandConfig

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

过程

apoc.path.spanningTree

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

过程

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 沿给定 RELATIONSHIP 类型到最大深度可达的子图中的 NODE 值。

过程

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 值。

过程

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 值。

过程

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 值。

过程

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 值。

过程

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 值。

过程

apoc.refactor.setType

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

过程

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) - 将给定时间值格式化为给定时间格式。

函数

apoc.temporal.formatDuration

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

函数

apoc.temporal.toZonedTemporal

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

函数

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 值中所有单词的双音位语音编码。

函数

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) - 使用汉明距离算法比较两个给定 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 值。

Function Deprecated

apoc.text.levenshteinSimilarity

apoc.text.levenshteinSimilarity(text1 STRING, text2 STRING) - 返回两个给定 STRING 值之间基于 Levenshtein 距离算法的相似度（一个介于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 语音声码编码。

函数

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) - 查找并替换给定正则表达式找到的所有匹配项。

Function Deprecated

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) - 使用 Sørensen–Dice 系数公式和提供的 IETF 语言标签比较两个给定 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'}。

Procedure Deprecated

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) - 暂停给定触发器。

Procedure Deprecated

apoc.trigger.remove

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

Procedure Deprecated

apoc.trigger.removeAll

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

Procedure Deprecated

apoc.trigger.resume

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

Procedure Deprecated

apoc.trigger.show

apoc.trigger.show(databaseName STRING) - 列出数据库的所有最终安装触发器。

过程

apoc.trigger.start

apoc.trigger.start(databaseName STRING, name STRING) - 最终重新启动给定暂停的触发器。

过程

apoc.trigger.stop

apoc.trigger.stop(databaseName STRING, name STRING) - 最终停止给定触发器。

过程

apoc.util.sleep

apoc.util.sleep(duration INTEGER) - 使当前运行的 Cypher 休眠给定毫秒持续时间（事务终止将得到遵守）。

过程

apoc.util.validate

apoc.util.validate(predicate BOOLEAN, message STRING, params LIST<ANY>) - 如果给定谓词为true，则抛出异常。

过程