memgraph

degree_centrality

get()

度中心性是中心性的基本度量，指的是与节点相邻的关系数。对于有向图，定义一个度内度量值，定义为传入边的数量，以及出度度量，定义为出界边的数量。

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
type: string (default="undirected")➡ 定义过程是使用“输入”、“输出”还是“无定向”关系。

输出：
node: Vertex➡ 图中的节点，计算其度中心性。
degree: float➡ 节点的计算度数。

CALL degree_centrality.get()
YIELD node, degree;

betweenness_centrality

get()

根据节点位于其他节点之间的最短路径，表示其对信息流的影响在网络内。这些节点具有很高的中间性，通常充当控制信息传输的看门人

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
directed: boolean (default=True)➡ 如果忽略关系的方向。False
normalized: boolean (default=True)➡ 如果中间值由 for 图和有向图进行归一化，则 是节点数。True2/((n-1)(n-2))1/((n-1)(n-2))n
threads: integer (default=half of the system’s available hardware threads)➡ 用于计算中间性的线程数 向心性。
输出：
betweenness_centrality: float➡ 给定节点的中间中心性值。
node: Vertex➡ 用于计算中间性的图形节点。

CALL betweenness_centrality.get()
YIELD node, betweenness_centrality;

可用的图形投影

MATCH p=(n)-[r]->(m)
WITH project(p) AS subgraph
RETURN subgraph;

community_detection

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
weight: string (default="weight")➡ 指定边属性的名称 包含边权重。如果用户没有用于存储权重的属性 在图形中的边上，算法会将所有权重设置为 ，导致 未加权图的情况。要将此算法用于加权 graph，边需要有一个存储其权重的属性。拥有属性 在边上，将 flag 设置为 when starting Memgraph。用户可以使用默认属性名称或设置另一个 自定义属性名称。如果他们为边上的权重设置了自定义属性名称， 在调用时，它们需要提供该属性名称作为位置参数 程序。1--storage-properties-on-edgesTrueweight
coloring: boolean (default=False)➡ 如果设置，请使用图形着色启发式方法进行有效的并行化。
min_graph_shrink: integer (default=100000)➡ 图粗化优化在将图缩小到这么多节点时停止。
community_alg_threshold: double (default=0.000001)➡ 控制算法迭代的时间。当模块化增益 低于阈值，迭代结束。 有效值介于 0 和 1 之间（不包括）。
coloring_alg_threshold: double (default=0.01)➡ 如果启用了着色，则控制算法迭代的时间。当 模块化增益低于此阈值，则使用该值执行最终迭代。 有效值介于 0 和 1 之间（不包括）。此参数的值应高于 。community_alg_thresholdcommunity_alg_threshold
num_of_threads: integer (default=half of the system’s available hardware threads)➡ 指定在算法的并行部分中用于并行执行的线程数。注意：OpenMP（omp）用于并行化，因此实际线程使用情况可能取决于系统设置和OpenMP配置。

输出：
node: Vertex➡ 执行算法并作为结果的一部分返回的图形节点。
community_id: integer➡ 社区 ID。默认为
1
−1如果节点不属于任何社区。

CALL community_detection.get()
YIELD node, community_id;

kmeans

get_clusters

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
n_clusters : int➡ 要形成的集群数。
embedding_property : str (default: "embedding")➡ 存储嵌入的节点属性。
init : str (default: "k-means")➡ 初始化方法。如果选择，则根据点对整体惯性贡献的经验概率分布对初始聚类质心进行采样。这种技术加速了收敛速度，并且在理论上被证明是最佳的。 如果 ，则为初始质心随机选择观测值（行）。k-means++O(logk)randomn_clusters
n_init : int (default: 10)➡ k-means 算法将使用不同的质心种子运行的次数。
max_iter : int (default: 10)➡ 采样游走的长度。
tol : float (default: 1e-4)➡ Frobenius 范数对连续迭代中簇中心差异的相对容差。用于确定收敛性。
algorithm : str (default: "auto")➡ 选项是 、 、 、 。描述在这里。lloydelkanautofull
random_state : int (default: 1998)➡ 算法的随机种子。
输出：
node: mgp.Vertex➡ Graph 节点。
cluster_id: mgp.Number➡ 上述节点的集群 ID。


CALL kmeans.get_clusters(2, "embedding", "k-means++", 10, 10, 0.0001, "auto", 1) YIELD node, cluster_id
RETURN node.id as node_id, cluster_id
ORDER BY node_id ASC;

+-------------------------+-------------------------+
| node_id                 | cluster_id              |
+-------------------------+-------------------------+
| 0                       | 1                       |
| 1                       | 1                       |
| 2                       | 1                       |
| 4                       | 1                       |
| 5                       | 1                       |
| 6                       | 0                       |
| 7                       | 0                       |
| 8                       | 0                       |
| 9                       | 0                       |
+-------------------------+-------------------------+

set_clusters()

该过程通过将集群 ID 写入来设置每个节点所属的集群

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
n_clusters : int➡ 要形成的集群数。
embedding_property : str (default: "embedding")➡ 存储嵌入的节点属性。
cluster_property: str (default: "cluster_id")➡ 节点属性，将存储的位置。cluster_id
init : str (default: "k-means")➡ 初始化方法。如果选择，则根据点对整体惯性贡献的经验概率分布对初始聚类质心进行采样。该技术加快了收敛速度，并且在理论上被证明是最优的。如果 ，则为初始质心随机选择观测值（节点）。k-means++O(logk)randomn_clusters
n_init : int (default: 10)➡ k-means 算法将使用不同的质心种子运行的次数。
max_iter : int (default: 10)➡ 采样游走的长度。
tol : float (default: 1e-4)➡ Frobenius 范数对连续迭代中簇中心差异的相对容差。用于确定收敛性。
algorithm : str (default: "auto")➡ 选项是 、 、 、 。描述在这里。lloydelkanautofull
random_state : int (default: 1998)➡ 算法的随机种子。
输出：
node: mgp.Vertex➡ Graph 节点。
cluster_id: mgp.Number➡ 上述节点的集群 ID。

CALL kmeans.set_clusters(2, "embedding", "cluster_id", "k-means++", 10, 10, 0.0001, "auto", 1) YIELD node, cluster_id
RETURN node.id as node_id, cluster_id
ORDER BY node_id ASC;

algo

all_simple_paths()

该过程返回每个简单路径（不访问同一节点的路径两次）从满足给定的关系过滤器。

选择	解释
`TYPE`	路径将随着这种类型的传出或传入关系而扩展。
`<TYPE`	路径将随着此类传入关系而扩展。
`TYPE>`	路径将随着这种类型的传出关系而扩展。
`<TYPE>`	如果同一两个节点之间同时存在这种类型的传入和传出关系，则路径将扩展。
`>`	路径将随着所有传出关系而扩展。
`<`	路径将扩展所有传入的关系。

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
start_node: Node➡ 返回路径的第一个节点。
end_node: Node➡ 返回路径的最后一个节点。
relationship_types: List[String]➡ 关系过滤器列表，如下所述。
max_length: int➡ 最大路径长度。
输出：
path: Path➡ 满足给定条件的路径。

MATCH (n:Node1) MATCH (m:Node3)
CALL algo.all_simple_paths(n, m, [], 2) 
YIELD path AS result RETURN result;

cover()

该过程返回列表中每两个节点之间的关系，包括任何自我引用关系。

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
nodes: List[Node]➡ 所有输入节点的列表。
输出：
rel: Relationship➡ 为节点之间的每个关系创建单独的记录，并返回一个关系。

MATCH (d:Dog),(ho:House),(h:Human)
CALL algo.cover([d, ho, h]) YIELD rel
RETURN startNode(rel), rel, endNode(rel);

astar()

在起始节点和目标节点之间运行 A * 搜索算法。支持距离和启发式属性的或数据类型。NumericDuration 默认启发式方法的工作假设是图形中的节点表示地理空间点，并且它们已定义纬度和经度属性。在这种情况下，每个节点的启发式方法是当前节点> 与地球上目标节点之间的半正弦距离，并以公里为单位返回。如果您不想使用地理空间类型，或者想要自定义启发式方法，请检查下面支持的配置。

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
start: Node➡ 起始节点。
target: Node➡ 目标节点。
config: Map➡ 配置映射。
输出：
path: Path➡ 算法计算的结果最短路径。
weight: float➡ 最短路径的权重。

MATCH (c1:City1), (c5:City5)
CALL algo.astar(c1,c5, {}) YIELD path, weight
RETURN path, weight;

MATCH (c1:City1), (c5:City5 )
CALL algo.astar(c1,c5, {relationships_filter:["RIVER>"]})
YIELD path, weight
RETURN path, weight;


MATCH (c1:City1), (c5:City5)
CALL algo.astar(c1,c5, {blacklisted_labels: ["MO1", "MO2","MO4"]})
YIELD path, weight
RETURN path, weight;

igraphalg

get_all_simple_paths()

返回图形中从源到目标的所有简单路径。一条简单的路径是没有重复节点的路径。G

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
v: Vertex➡ 路径的起始节点。
to: Vertex➡ 路径的结束节点。
cutoff: int (default=-1)➡ 所考虑路径的最大长度。如果为负数，则考虑所有长度的路径。
输出：
path: List[Vertex]➡ 特定路径的顶点列表。如果在给定的截止值内源和目标之间没有路径，则没有输出。



MATCH (n:Label), (m:Label)
CALL igraphalg.get_all_simple_paths(n, m, 5) 
YIELD path
RETURN path;

spanning_tree()

返回图形上的最小生成树。最小生成树是连接图关系的子集，它连接所有节点，没有任何循环。G

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
weights: string (default=NULL)➡ 用于关系权重的属性。
directed: bool (default=False)➡ 如果图形是有向的，否则它是无向的。True
输出：
tree: List[List[Vertex]]➡ 最小生成树或林。

CALL igraphalg.spanning_tree() 
YIELD tree
RETURN tree;

pagerank()

PageRank 根据传入关系的结构计算图 G 中节点的排名。

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
damping: double (default=0.85)➡ PageRank 的阻尼参数。
weights: string (default="weight")➡ 用作权重的属性。如果 ，权重设置为 1。None
directed: bool (default=True)➡ 如果图形是有向的，否则它是无向的。True
implementation: string (default="prpack")➡ 用于计算的算法 PageRank 值。该算法可以是 ，它使用 PRPACK 库或使用 ARPACK 库。prpackarpack
输出：
node: Vertex➡ 计算 PageRank 的节点。
rank: double➡ 节点的 PageRank 值。


CALL igraphalg.pagerank() 
YIELD node, rank
RETURN node, rank;

get_shortest_path()

计算图形中的最短路径。

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
source: Vertex (default=NULL)➡ 路径的起始节点。
target: Vertex (default=NULL)➡ 路径的结束节点。
weights: string (default=NULL)➡ 如果 ，每段关系都有 重量/距离/成本 1.如果值是属性名称，则将该属性用作 关系权重。如果关系没有该属性，则 值默认为 1。None
directed: bool (default=True)➡ 如果 ，则图是有向的，否则， 这是无方向的。True
输出：
path: List[Vertex]➡ 节点和节点之间的路径。sourcetarget


MATCH (n:Label), (m:Label)
CALL igraphalg.get_shortest_path(n, m) 
YIELD path
RETURN path;

maxflow()

最大流量问题包括通过图形找到流量，使其成为最大可能流量。

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
source: Vertex➡ 从中计算最大流量的源节点。
target: Vertex➡ 计算最大流量的接收器节点。
capacity: string (default="weight")➡ 关系属性，用作关系的流容量。
输出：
max_flow: Number➡ 网络的最大流量，从源到汇。


MATCH (source {id: 0}), (sink {id: 5})
CALL igraphalg.maxflow(source, sink, "weight")
YIELD max_flow
RETURN max_flow;

community_leiden()

使用 Traag、van Eck 和 Waltman 的莱顿算法查找图的群落结构。

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
objective_function: string (default="CPM")➡ 是否使用 Constant 波茨模型 （CPM） 或模块化。必须是 或 。CPMmodularity
weights: string (default=NULL)➡ 如果存在字符串，请使用此属性 作为关系权重，如果不是，则权重默认为 1。
resolution_parameter: float (default=1.0)➡ 更高的分辨率导致 较小的社区，而较低的分辨率会导致较大的社区较少。
beta: float (default=0.01)➡ 影响 莱顿算法。这仅影响算法的细化步骤。
initial_membership: List[int](default=NULL)➡ 如果提供，莱顿 algorithm 将尝试改进此提供的成员资格。如果没有参数 前提是，该算法只是从单例分区开始。
n_iterations: int (default=2)➡ 迭代的迭代次数 莱顿算法。每次迭代都可以进一步改进分区。
vertex_weights: List[float] (default=NULL)➡ 中使用的节点权重 莱顿算法。如果未提供，将自动确定 基于 .objective_function
输出：
node: Vertex➡ 图中的节点。
community_id: int➡ 所属社区的 ID。node

CALL igraphalg.community_leiden() 
YIELD node, community_id
RETURN node, community_id;

all_shortest_path_lengths()

计算图形中的所有最短路径长度。

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
weights: string (default=NULL)➡ 如果 ，每段关系都有 重量/距离/成本 1.如果值是属性名称，则将该属性用作 关系权重。如果关系没有属性，则值 默认为 1。None
directed: bool (default=True)➡ 如果 ，则图是有向的，否则， 这是无方向的。True
输出：
src_node: Vertex➡ 源节点。
dest_node: Vertex➡ 目标节点。
length: double➡ 如果 ，则图形是有向的，否则，它是无向的。True

CALL igraphalg.all_shortest_path_length()
  YIELD src_node, dest_node, length
  RETURN src_node, dest_node, length;

max_flow

get_flow()

使用该过程计算最大流量

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
start_v: Vertex➡ 从中计算最大流量的源节点。
end_v: Vertex➡ 计算最大流量的接收器节点。
edge_property: string (default="weight")➡ 用作流的关系属性 关系的能力。
输出：
max_flow: Number➡ 从源节点到接收器节点的网络最大流量。


MATCH (source {id: 0}), (sink {id: 5})
CALL max_flow.get_flow(source, sink, "weight")
YIELD max_flow
RETURN max_flow;

get_paths()

该过程返回属于流量最大流量的流一部分的路径。

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
start_v: Vertex➡ 从中计算最大流量的源节点。
end_v: Vertex➡ 计算最大流量的接收器节点。
edge_property: string (default="weight")➡ 用作流的关系属性 关系的能力。
输出：
path: Path➡ 流量为最大流量的路径。
flow: Number➡ 与该路径对应的流量。

MATCH (source {id: 0}), (sink {id: 5})
CALL max_flow.get_paths(source, sink, "weight")
YIELD path, flow
RETURN path, flow;

node2vec

get_embeddings

该过程返回计算的嵌入和相应的嵌入列表。

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
is_directed : boolean➡ 如果 ，则将图视为有向，否则 它被视为无定向True
p : float➡ 返回用于计算转换概率的超参数。
q : float➡ 用于计算转换概率的输入输出超参数。
num_walks : integer➡ 遍历采样中每个节点的遍历数。
walk_length : integer➡ 步行抽样中一次步行的长度。
vector_size : integer➡ 词向量的维度。
alpha : float (default=0.025)➡ 初始学习率。
window : integer➡ 当前单词和预测单词之间的最大距离在句子内。
min_count : integer➡ 忽略总频率低于此值的所有单词。
seed : integer➡ 随机数生成器的种子。每个单词的初始向量单词用单词 + 串联的哈希值播种。str(seed)
workers : integer➡ 使用这些工作线程来训练模型（=更快使用多核机器进行训练）。
min_alpha : float➡ 学习率将线性下降到培训进展。min_alpha
sg : {0, 1}➡ 训练算法：1 为跳过克;否则 CBOW。
hs : {0, 1}➡ 如果为 1，则分层 softmax 将用于模型训练。 如果 0，并且> 0，则将使用负抽样。negative
negative : integer➡ 如果> 0，则将使用负采样，则 negative 指定应该绘制多少个“噪音词”（通常 5-20 之间）。如果设置为 0，则不使用负采样。必须> 0 或必须设置为 1。negativehs
epochs : integer (default=5)
edge_weight_property : string (default="weight")

输出：
nodes: mgp.List[mgp.Vertex]➡ 嵌入的节点列表 计算
embeddings: mgp.List[mgp.List[mgp.Number]]➡ 对应列表 嵌入


CALL node2vec.get_embeddings(False, 2.0, 0.5, 4, 5, 100, 0.025, 5, 1, 1, 1, 0.0001, 1, 0, 5, 5, "weight");

set_embeddings()

该过程计算嵌入，在节点上创建类型属性替换为嵌入值，并返回相应的嵌入列表

subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
is_directed : boolean➡ 如果 ，则将图形视为有向，否则则不 指示True
p : float➡ 返回用于计算转换概率的超参数。
q : float➡ 用于计算转换概率的输入输出超参数。
num_walks : integer➡ 遍历采样中每个节点的遍历数。
walk_length : integer➡ 步行抽样的一次步行长度。
vector_size : integer➡ 词向量的维度。
alpha : float➡ 初始学习率。
window : integer➡ 当前单词和预测单词之间的最大距离在句子内。
min_count : integer➡ 忽略总频率低于此值的所有单词。
seed : integer➡ 随机数生成器的种子。每个单词的初始向量单词用单词 + 串联的哈希值播种。str(seed)
workers : integer➡ 使用这些工作线程来训练模型（=更快使用多核机器进行训练）。
min_alpha : float➡ 学习率将线性下降到培训进展。min_alpha
sg : {0, 1}➡ 训练算法：1 为跳过克;否则 CBOW。
hs : {0, 1}➡ 如果为 1，则分层 softmax 将用于模型训练。 如果 0，并且为非零，则将使用负采样。negative
negative : integer➡ 如果> 0，将使用负采样，则 int negative 指定应该绘制多少个“噪音词”（通常 5-20 之间）。如果设置为 0，则不使用负采样。
epochs : integer (default=5)
edge_weight_property : string (default="weight")
输出：
nodes: mgp.List[mgp.Vertex]➡ 嵌入的节点列表 计算
embeddings: mgp.List[mgp.List[mgp.Number]]➡ 对应列表 嵌入


CALL node2vec.set_embeddings(False, 2.0, 0.5, 4, 5, 100, 0.025, 5, 1, 1, 1, 0.0001, 1, 0, 5, 5, "weight");

MATCH (n)
RETURN n.id as node, n.embedding as embedding
ORDER BY n.id;

node_similarity

jaccard()

以下过程将计算所有节点对之间的 Jaccard 相似度。

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
输出：
node1: Vertex➡ 第一个节点。
node2: Vertex➡ 第二个节点。
similarity: float➡ 第一个节点和第二个节点之间的 Jaccard 相似度。


CALL node_similarity.jaccard() YIELD node1, node2, similarity
RETURN node1, node2, similarity;

overlap()

以下过程将计算所有节点对之间的重叠相似度。

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
输出：
node1: Vertex➡ 第一个节点。
node2: Vertex➡ 第二个节点。
similarity: float➡ 第一个节点和第二个节点之间的重叠相似度。


CALL node_similarity.overlap() YIELD node1, node2, similarity
RETURN node1, node2, similarity;

cosine()

以下过程将计算所有节点对之间的余弦相似度。

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
node1: Vertex➡ 第一个节点。
node2: Vertex➡ 第二个节点。
property: str➡ 计算余弦相似度所依据的属性。如果属性不是向量类型，则会引发错误。

输出：
node1: Vertex➡ 第一个节点。
node2: Vertex➡ 第二个节点。
similarity: float➡ 第一个节点和第二个节点之间的余弦相似度。


CALL node_similarity.cosine("score") YIELD node1, node2, similarity
RETURN node1, node2, similarity

pairwise

MATCH (m)
WHERE m.id < 3
WITH COLLECT(m) AS nodes1
MATCH (n)
WHERE n.id > 2
WITH COLLECT(n) AS nodes2, nodes1
CALL node_similarity.jaccard_pairwise(nodes1, nodes2) YIELD node1, node2, similarity AS jaccard_similarity
RETURN node1, node2, jaccard_similarity;

collections

union()

将两个列表合并为一个，消除重复项。

输入：
first: List[Any]➡ 元素的第一个列表。
second: List[Any]➡ 第二个元素列表。
输出：
List[Any]➡ 两个输入列表的并集。


RETURN collections.union([0, 1, 2, 3], [2, 2, 3, 4, 5]) AS union;

union_all()

返回两个输入列表（包括重复项）的并集。

输入：
first: List[Any]➡ 第一个列表。
second: List[Any]➡ 第二个列表。
输出：
List[Any]➡ 两个列表的并集，包括重复项。


RETURN collections.union_all([1,1,2,3],[3,"a","b","c"]) AS return_list;

remove_all()

从输入列表中删除定义的元素。如果不存在的元素是传递，它将被忽略。

输入：
first: List[Any]➡ 需要从中删除元素的列表。
second: List[Any]➡ 需要删除的元素列表。
输出：
List[Any]➡ 删除指定元素后的输入列表。
用法：
以下查询将从 1-5 的数字列表中删除 1、2、3 、 7。

RETURN collections.remove_all([1, 2, 3, 4, 5], [1, 2, 3, 7]) AS removed;

contains()

输入：
coll: List[Any]➡ 输入列表检查了某个值。
value: Any➡ 在列表中搜索的输入值。
输出：
boolean➡ 如果该值存在于列表中，否则 。true false

RETURN collections.contains([1,2,3], "e") AS output;

contains_all()

检查列表是否包含另一个列表中的所有值。

输入：
coll: List[Any]➡ 用于搜索值的目标列表。
values: List[Any]➡ 在目标列表中搜索的值。
输出：
boolean➡ 如果参数中指定的所有元素都包含在列表中。true values collection

RETURN collections.contains_all([1, 2, 3, "pero"], [1, 1, 1, 1, 2, 3]) AS contained;

intersection()

返回两个列表的唯一交集。

输入：
first: List[Any]➡ 第一个列表。
second: List[Any]➡ 第二个列表。
输出：
List[Any]➡ 两个列表的唯一交集。

RETURN collections.intersection([1, 1, 2, 3, 4, 5], [1, 1, 3, 5, 7, 9]) AS intersection;

flatten()

返回提供的输入的扁平化列表。

输入：
list: List[Any]➡ 该列表曾经扁平化。
输出：
List[Any]➡ 包含输入列表中元素的列表。

WITH [1] as nums,
      ["text", 2.5] as mixed,
      [true, false] as bools
WITH COLLECT(nums) + [mixed] + [bools] + COLLECT(null) as input_list
RETURN collections_module.flatten(input_list) as result

pairs()

在输入列表中创建相邻元素对。

输入：
list: List[Any]➡ 用于创建配对的列表。
输出：
List[Any]➡ 包含输入列表中元素对的列表。

RETURN collections.pairs([3, "s", 4.4, [1, 2]]) AS pairs;

+---------------------------------------------------------+
| pairs                                                   |
+---------------------------------------------------------+
| [[3, "s"], ["s", 4.4], [4.4, [1, 2]], [[1, 2], null]]   |
+---------------------------------------------------------+

to_set()

将输入列表转换为集合。

输入：
values: List[Any]➡ 将转换为集合的列表。
输出：
List[Any]➡ 作为数据类型返回的集合。mgp::List


RETURN collections.to_set([1,2,1,2,3]) AS result;


+---------------------------------------------------------+
| result                                                  |
+---------------------------------------------------------+
| [3,2,1]                                                 |
+---------------------------------------------------------+

sum()/avg/max/min

计算列出的元素的总和，如果它们属于相同类型并且可以 summed（元素必须是数字）。列出不同数据的元素类型或无法求和的数据类型将抛出异常。

CREATE (:A {id:5});
MATCH (a:A) 
RETURN collections.sum([1, 2.3, -4, a.id]) AS sum;

cycles

get()

在图论中，循环表示图中的一条路径，其中只有起始节点和结束节点相等。此外，循环可以双连接相邻节点或自循环之间的链接。循环检测算法在 MAGE 中实现的在无向图上工作，并且不能保证节点顺序

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
输出：
cycle_id: integer➡ 某个节点的增量循环 ID。不保证 节点在周期内将如何排序。循环可以表示 至少有一个 ID，其中它代表自循环。
node: Vertex➡ Vertex 对象，其所有属性都将与它所属的循环 ID 相关。

CALL cycles.get()
YIELD cycle_id, node;

+-----------------+-----------------+
| cycle_id        | node            |
+-----------------+-----------------+
| 0               | (:Node {id: 2}) |
| 0               | (:Node {id: 0}) |
| 0               | (:Node {id: 1}) |
| 1               | (:Node {id: 4}) |
| 1               | (:Node {id: 2}) |
| 1               | (:Node {id: 3}) |
+-----------------+-----------------+

深度路径遍历

DFS

DFS 返回给定节点之间找到的所有路径，并且最适合确定图中两个节点之间的路径存在。如果输出算法为空，节点之间没有可用路径。如果 output 不为 null，则 DFS 算法将提供所有可能的路径，因为一个结果。

#以下查询将显示从节点到节点的所有路径：nm
MATCH path=(n {id: 0})-[*]->(m {id: 8})
RETURN path;

#要获取所有关系的列表，请在方括号中添加一个变量，然后返回它作为结果：
MATCH (n {id: 0})-[relationships *]->(m {id: 8})
RETURN relationships;

#要获取路径节点列表，请使用函数：nodes()
MATCH path=(n {id: 0})-[*]->(m {id: 8})
RETURN path,nodes(path),relationships(path);

BFS

BFS 非常适合在未加权的图形或起始节点与图形中的任何其他节点之间。由于它遍历在移动到下一级之前，给定深度的所有节点，它确保找到最短路径。

MATCH path=(n {id: 0})-[*BFS]->(m {id: 8})
RETURN path;

MATCH (n {id: 0})-[relationships *BFS]->(m {id: 8})
RETURN relationships;

限制路径的长度

#路径长度的约束在 *BFS 之后定义。以下内容 查询仅当路径等于或小于 5 个跃点时才会返回结果：
MATCH (n {id: 0})-[relationships:CloseTo *BFS ..5]->(m {id: 8})
RETURN relationships;

#仅当路径等于或长于 3 时才会返回结果，并且 等于或小于 5 个跃点：
MATCH (n {id: 0})-[relationships:CloseTo *BFS 3..5]-(m {id: 15})
RETURN relationships;

根据属性值约束扩展

广度优先扩展允许任意表达式过滤器，该过滤器确定是否允许通过特定关系扩展到特定节点。这 filter 定义为和上的 lambda 函数，它表示关系扩展，节点扩展到广度优先搜索。r n


MATCH path=(n {id: 0})-[*BFS (r, n | r.eu_border = false AND n.drinks_USD < 15)]-(m {id: 8})
RETURN path;

加权最短路径

在图论中，加权最短路径问题是找到路径的问题图中的两个节点之间的关系权重之和连接节点，或路径上某个节点属性的权重之和，是最小化。


MATCH path=(n {name: "A"})-[:ConnectedTo *WSHORTEST (r, n | r.weight)]-(m {name: "E"})
RETURN path;

限制路径的长度

Memgraph 对 Dijkstra 算法的实现使用修改后的该算法可以处理长度限制，并且基于关系扩展语法。长度限制参数是可选的，当它不是 set，它会增加算法执行的复杂度。重要的是要注意在这种情况下，术语“长度”表示遍历的次数关系，而不是它们权重的总和。


MATCH path=(n {id: 0})-[:CloseTo *WSHORTEST 4 (r, n | n.total_USD) total_weight]-(m {id: 46})
RETURN path,total_weight;

所有最短路径

找到所有最短路径是加权最短路径问题的扩展。目标找到最短路径是从一个节点到另一个节点。但是，可能存在多个相同权重的路径，并且该算法把它们都拿来。

MATCH path=(n {name: "A"})-[:ConnectedTo *ALLSHORTEST (r, n | r.weight)]-(m {name: "E"})
RETURN path;

所有最短路径,限制路径的长度

所有最短路径都允许上限路径限制。如果从跃点多于设置上限的路由中获得不受限制的最短路径，则此添加会显着修改算法的结果。查找具有路径限制的所有最短路径归结为找到最大长度为的最小加权路径

MATCH path=(n {id: 0})-[:CloseTo *ALLSHORTEST 4 (r, n | n.total_USD) total_weight]-(m {id: 46})
RETURN path,total_weight;

K 个最短路径

K 最短路径算法按顺序查找两个节点之间的 K 条最短路径长度增加。当您需要寻找替代方案时，此算法非常有用路由或分析图中的路径多样性。

MATCH (source), (target)
WITH source, target
MATCH path=(source)-[*KSHORTEST]->(target)
RETURN path;

#您还可以使用以下语法限制返回的路径数：|
MATCH (source), (target)
WITH source, target
MATCH path=(source)-[*KSHORTEST|3]->(target)
RETURN path;

路径长度约束

MATCH (a:Node {name: "A"}), (e:Node {name: "E"})
WITH a, e
MATCH path=(a)-[*KSHORTEST 2..4]->(e)
RETURN path;

neighbors

at_hop()

返回与给定节点保持特定距离的节点.

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
node: Node➡ 邻域分析的目标节点。
rel_type: List[string]➡ 要浏览的关系类型列表。 如果 该列表为空，则该过程将返回所有类型的关系。
distance: int➡ 节点之间的跃点数。
如果在关系类型前面添加<，则仅检查传入节点的关系（例如，“<KNOWS”），而如果在关系类型的末尾添加>，则只有来自节点的关系才会被选中（例如，“KNOWS>”）。此外，如果关系类型不相关，可以只输入<或>来检查传入或传出 关系。
输出：
nodes: Node➡ 与给定节点保持特定距离的节点。

MATCH (p:Person)
CALL neighbors.at_hop(p, ["KNOWS"], 3) YIELD nodes RETURN nodes;

by_hop()

返回与给定节点处于任何距离或最远特定距离的节点

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
node: Node➡ 邻域分析的目标节点。
rel_type: List[string]➡ 要浏览的关系类型列表。 如果 该列表为空，则该过程将返回所有类型的关系。
distance: int➡ 节点之间的最大跃点数。
如果在关系类型前面添加<，则只有即将到来的关系 将检查到节点中（例如，<KNOWS），而如果>在 end 关系类型的关系，则只有来自节点的关系才会 选中（例如，“KNOWS>”）。此外，如果关系类型不相关， 可以只输入<或>来检查进货或传出货 关系。
输出：
nodes: List[Node]➡ 与给定节点有特定距离的节点列表，从距离 1 开始到提供的距离。


MATCH (p:Person)
CALL neighbors.by_hop(p, ["KNOWS"], 3) YIELD nodes RETURN nodes;

graph_util

ancestors()

查找输入节点的祖先节点。祖先节点是来自其中有一条通往输入节点的路径。

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
node: Vertex➡ 要查找祖先的节点。
输出：
ancestors: List[Vertex]➡ 具有源节点路径的祖先节点列表。

MATCH (n {id:1})
CALL graph_util.ancestors(n)
YIELD ancestors
UNWIND ancestors AS ancestor
RETURN ancestor;

descendants()

找到输入节点的后代节点。后代节点是所有节点替换为来自输入节点的现有路径。

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
node: Vertex➡ 我们要查找后代的节点。
输出：
descendants: List[Vertex]➡ 具有源节点路径的后代列表。

MATCH (n {id:1})
CALL graph_util.descendants(n)
YIELD descendants
UNWIND descendants AS descendant
RETURN descendant;

chain_nodes()

在输入列表中的每个相邻节点之间创建关系。每个关系从第二个输入参数获取关系类型。nodesedge_type

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
nodes: List[Vertex]➡ 我们要在它们之间创建相应关系的节点列表。
edge_type: String➡ 将在节点之间创建的关系的名称。

输出：
connections: List[Edge]➡ 连接节点的关系列表。每个节点都使用指定为第二个输入参数的关系类型与输入列表中紧随其后的节点连接。


MATCH (n)
WITH collect(n) AS nodes
CALL graph_util.chain_nodes(nodes, "MY_EDGE")
YIELD connections
RETURN nodes, connections;

connect_nodes()

返回连接输入节点列表的关系列表。通常用于从返回的节点创建子图。

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
nodes: List[Vertex]➡ 我们要查找相应连接的节点列表，即它们之间的关系。
输出：
connections: List[Edge]➡ 连接起始图的输入节点的关系列表。


MATCH (n)
WITH collect(n) AS nodes
CALL graph_util.connect_nodes(nodes)
YIELD connections
RETURN nodes, connections;

topological_sort()

拓扑排序算法采用有向图并返回一个每个节点出现在它指向的所有节点之前的节点。这数组中节点的排序称为拓扑排序。排序是在整个图上完成，也可以在图投影上完成。

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
输出：
sorted_nodes: List[Vertex]➡ 节点排序，其中每个节点出现在它指向的所有节点之前。

MATCH p=(sl:SomeLabel)-[*bfs]->(al:AnotherLabel)
WITH project(p) AS graph
CALL graph_util.topological_sort(graph) YIELD sorted_nodes
UNWIND sorted_nodes AS nodes
RETURN nodes.name;

导出

json

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
path: string➡ 包含导出的图形数据库的 JSON 文件的路径。
config: Map➡ 使用以下键映射配置：
stream: boolean (default=False)➡ 数据是导出到流而不是文件。
write_properties: boolean (default=True)➡ 是否也导出了属性。
输出：
path: string➡ 导出文件的路径。
data: string➡ 如果标志设置为 ，则导出数据。streamTrue


CALL export_util.json(path);

json_graph 将给定的节点和关系导出为 JSON 格式。关系中的所有节点也必须包含在节点中。

输入：
subgraph: Graph (可选）➡ 一个特定的子图，它是函数返回的 Graph 类型的对象，算法在其上运行。 如果未指定 subgraph，则默认情况下在整个图上计算算法。project()
nodes: List[Node]➡ 需要导出的节点列表。
relationships: List[Relationship]➡ 需要导出的关系列表。
path: string➡ 包含导出数据的 JSON 文件的路径。
config: Map➡ 使用以下键映射配置：

stream: boolean (default=False)➡ 数据是导出到流而不是文件。
write_properties: boolean (default=True)➡ 是否也导出了属性。
输出：
path: string➡ 导出文件的路径。
data: string➡ 如果标志设置为 ，则导出数据。streamTrue

csv_graph/graphml

CALL export_util.graphml("/users/my_user/export_folder/export.graphml, {useTypes: true}) 
YIELD status RETURN status;