From ae1822e08c245f8c73ae535e632a5e473f5bec05 Mon Sep 17 00:00:00 2001 From: Hal Eisen Date: Mon, 7 Oct 2024 11:37:28 -0700 Subject: [PATCH 01/31] Adding bugfix #2361 to release notes --- pages/release-notes.mdx | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/pages/release-notes.mdx b/pages/release-notes.mdx index f9c7e135..b205a670 100644 --- a/pages/release-notes.mdx +++ b/pages/release-notes.mdx @@ -152,6 +152,17 @@ Memgraph (v2.11.1 and lower). +## Memgraph v2.21.0 - Nov 6, 2024 + +{

New features and improvements

} + +- TBD + +{

Bug fixes

} + +- Closing instance would crash due to streams and/or TTL running in the background. [#2361](https://github.com/memgraph/memgraph/pull/2361) + + ## Memgraph v2.20.0 - Sep 25, 2024 {

New features and improvements

} From 0edda5a10dbefb8721003238e5f61bbe84e9b298 Mon Sep 17 00:00:00 2001 From: Hal Eisen Date: Mon, 7 Oct 2024 11:47:39 -0700 Subject: [PATCH 02/31] Added changelog for #2352, #2366 and #2371 --- pages/release-notes.mdx | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/pages/release-notes.mdx b/pages/release-notes.mdx index 7d90bcb0..50146e67 100644 --- a/pages/release-notes.mdx +++ b/pages/release-notes.mdx @@ -177,6 +177,11 @@ Memgraph (v2.11.1 and lower). {

Bug fixes

} - Closing instance would crash due to streams and/or TTL running in the background. [#2361](https://github.com/memgraph/memgraph/pull/2361) +- Add backticks around property keys in any {key: value} patterns. [#2371](https://github.com/memgraph/memgraph/pull/2371/) +- When replica gets promoted to main upon failover, it will use correctly incremented durable timestamp. [#2366](https://github.com/memgraph/memgraph/pull/2366) +- schema.assert will throw an exception if ran inside the explicit transaction. [@2352](https://github.com/memgraph/memgraph/pull/2352) + + ## Lab v2.17.0 - Sep 25, 2024 From 50858b2b0cc62f3f6aeedf84500c5f56215ba94a Mon Sep 17 00:00:00 2001 From: Hal Eisen Date: Mon, 7 Oct 2024 11:48:25 -0700 Subject: [PATCH 03/31] Typo --- pages/release-notes.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pages/release-notes.mdx b/pages/release-notes.mdx index 50146e67..a4200765 100644 --- a/pages/release-notes.mdx +++ b/pages/release-notes.mdx @@ -179,7 +179,7 @@ Memgraph (v2.11.1 and lower). - Closing instance would crash due to streams and/or TTL running in the background. [#2361](https://github.com/memgraph/memgraph/pull/2361) - Add backticks around property keys in any {key: value} patterns. [#2371](https://github.com/memgraph/memgraph/pull/2371/) - When replica gets promoted to main upon failover, it will use correctly incremented durable timestamp. [#2366](https://github.com/memgraph/memgraph/pull/2366) -- schema.assert will throw an exception if ran inside the explicit transaction. [@2352](https://github.com/memgraph/memgraph/pull/2352) +- schema.assert will throw an exception if ran inside the explicit transaction. [#2352](https://github.com/memgraph/memgraph/pull/2352) From 16b6392a58ad1ff883d0d2755dc079646bed4586 Mon Sep 17 00:00:00 2001 From: Hal Eisen Date: Mon, 7 Oct 2024 19:18:22 -0700 Subject: [PATCH 04/31] Remove trailing slash in URL --- pages/release-notes.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pages/release-notes.mdx b/pages/release-notes.mdx index a4200765..287792bf 100644 --- a/pages/release-notes.mdx +++ b/pages/release-notes.mdx @@ -177,7 +177,7 @@ Memgraph (v2.11.1 and lower). {

Bug fixes

} - Closing instance would crash due to streams and/or TTL running in the background. [#2361](https://github.com/memgraph/memgraph/pull/2361) -- Add backticks around property keys in any {key: value} patterns. [#2371](https://github.com/memgraph/memgraph/pull/2371/) +- Add backticks around property keys in any {key: value} patterns. [#2371](https://github.com/memgraph/memgraph/pull/2371) - When replica gets promoted to main upon failover, it will use correctly incremented durable timestamp. [#2366](https://github.com/memgraph/memgraph/pull/2366) - schema.assert will throw an exception if ran inside the explicit transaction. [#2352](https://github.com/memgraph/memgraph/pull/2352) From 2f4e8a1551fea00c7276cf4d42fcd5461884cbc9 Mon Sep 17 00:00:00 2001 From: Hal Eisen Date: Mon, 7 Oct 2024 19:37:45 -0700 Subject: [PATCH 05/31] Escaping curly braces --- pages/release-notes.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pages/release-notes.mdx b/pages/release-notes.mdx index 287792bf..a15b278c 100644 --- a/pages/release-notes.mdx +++ b/pages/release-notes.mdx @@ -177,7 +177,7 @@ Memgraph (v2.11.1 and lower). {

Bug fixes

} - Closing instance would crash due to streams and/or TTL running in the background. [#2361](https://github.com/memgraph/memgraph/pull/2361) -- Add backticks around property keys in any {key: value} patterns. [#2371](https://github.com/memgraph/memgraph/pull/2371) +- Add backticks around property keys in any \{key: value\} patterns. [#2371](https://github.com/memgraph/memgraph/pull/2371) - When replica gets promoted to main upon failover, it will use correctly incremented durable timestamp. [#2366](https://github.com/memgraph/memgraph/pull/2366) - schema.assert will throw an exception if ran inside the explicit transaction. [#2352](https://github.com/memgraph/memgraph/pull/2352) From 2839e3d6a0c72f2ef6295d3d619ba541396a9069 Mon Sep 17 00:00:00 2001 From: Hal Eisen Date: Fri, 18 Oct 2024 13:48:27 -0700 Subject: [PATCH 06/31] HA bugfixes from Andi (2421 and 2422) --- pages/release-notes.mdx | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/pages/release-notes.mdx b/pages/release-notes.mdx index a15b278c..20dfa59d 100644 --- a/pages/release-notes.mdx +++ b/pages/release-notes.mdx @@ -180,7 +180,8 @@ Memgraph (v2.11.1 and lower). - Add backticks around property keys in any \{key: value\} patterns. [#2371](https://github.com/memgraph/memgraph/pull/2371) - When replica gets promoted to main upon failover, it will use correctly incremented durable timestamp. [#2366](https://github.com/memgraph/memgraph/pull/2366) - schema.assert will throw an exception if ran inside the explicit transaction. [#2352](https://github.com/memgraph/memgraph/pull/2352) - +- All data instances now use one type of callbacks to simplify state reconciliation. [#2421](https://github.com/memgraph/memgraph/pull/2421) +- Incomplete storage reset when MAIN force reset or applied snapshots to REPLICA. [#2422](https://github.com/memgraph/memgraph/pull/2422) From 87b2747dcc1102ef21c66dee3ce5a0f4aa2f91a0 Mon Sep 17 00:00:00 2001 From: Hal Eisen Date: Fri, 18 Oct 2024 14:23:51 -0700 Subject: [PATCH 07/31] changelog for mgp::memory deprecation --- pages/release-notes.mdx | 1 + 1 file changed, 1 insertion(+) diff --git a/pages/release-notes.mdx b/pages/release-notes.mdx index 225bfafd..af8b06c5 100644 --- a/pages/release-notes.mdx +++ b/pages/release-notes.mdx @@ -193,6 +193,7 @@ Memgraph (v2.11.1 and lower). - schema.assert will throw an exception if ran inside the explicit transaction. [#2352](https://github.com/memgraph/memgraph/pull/2352) - All data instances now use one type of callbacks to simplify state reconciliation. [#2421](https://github.com/memgraph/memgraph/pull/2421) - Incomplete storage reset when MAIN force reset or applied snapshots to REPLICA. [#2422](https://github.com/memgraph/memgraph/pull/2422) +- Modifying mgp::memory is prohibited; use MemoryDispatcherGuard instead. [#2424](https://github.com/memgraph/memgraph/pull/2424) From d1094329a171b9175afb6cf88cd525c0299173f2 Mon Sep 17 00:00:00 2001 From: Hal Eisen Date: Fri, 18 Oct 2024 14:26:57 -0700 Subject: [PATCH 08/31] Re-ordering 2.21 and 2.20.1 --- pages/release-notes.mdx | 24 +++++++++++------------- 1 file changed, 11 insertions(+), 13 deletions(-) diff --git a/pages/release-notes.mdx b/pages/release-notes.mdx index af8b06c5..34a838dd 100644 --- a/pages/release-notes.mdx +++ b/pages/release-notes.mdx @@ -166,19 +166,6 @@ Memgraph (v2.11.1 and lower). -## Memgraph v2.20.1 - Oct 10, 2024 - -{

Bug fixes

} - -- When a replica gets promoted to main upon [failover](/clustering/high-availability#failover), it will now use correctly incremented durable timestamp. [#2366](https://github.com/memgraph/memgraph/pull/2366) -- Replica will now take MAIN's [uuid](/clustering/high-availability#how-replica-knows-which-main-to-listen) only when REPLICA's current sequence number is 0. [#2388](https://github.com/memgraph/memgraph/pull/2388) -- Eliminated deadlock caused by concurrent calls to Stop method on the Scheduler. Eliminated deadlock caused by calling Pause after Stop from different threads. [#2398](https://github.com/memgraph/memgraph/pull/2398) -- Fixed a problem where [EdgeType index](/fundamentals/indexes#edge-type-index) would assign every element as obsolete which then caused the index to be incorrectly emptied by the GC. Fixed another problem where [EdgeTypeProperty index](/fundamentals/indexes#edge-type-property-index) never ran its GC. Now properly prevents edge index creation when properties-on-edges is disabled - the user must explicitly [provide](/database-management/configuration#storage) --storage-properties-on-edges. Now correctly prevents Edge indices being recovered when properties-on-edges is disabled by causing an assert during recovery. [Replication](/clustering/replication) now updates edge indices. [#2390](https://github.com/memgraph/memgraph/pull/2390) -- Replica now correctly reflects database registration success or failure. When replica receives a request for registering replica, it will now return status code NOT_MAIN. If attempting to undo an incomplete registration fails, then the Memgraph instance will be intentionally crashed because the system is in unrecoverable state. Main instance can now deal with stale RPC message GetReplicaUUID without crashing the instance. [#2373](https://github.com/memgraph/memgraph/pull/2373) -- Closing instance no longer crashes due to [streams](/data-streams) and/or [TTL](/querying/time-to-live) running in the background. [#2361](https://github.com/memgraph/memgraph/pull/2361) - - - ## Memgraph v2.21.0 - Nov 6, 2024 {

New features and improvements

} @@ -196,6 +183,17 @@ Memgraph (v2.11.1 and lower). - Modifying mgp::memory is prohibited; use MemoryDispatcherGuard instead. [#2424](https://github.com/memgraph/memgraph/pull/2424) +## Memgraph v2.20.1 - Oct 10, 2024 + +{

Bug fixes

} + +- When a replica gets promoted to main upon [failover](/clustering/high-availability#failover), it will now use correctly incremented durable timestamp. [#2366](https://github.com/memgraph/memgraph/pull/2366) +- Replica will now take MAIN's [uuid](/clustering/high-availability#how-replica-knows-which-main-to-listen) only when REPLICA's current sequence number is 0. [#2388](https://github.com/memgraph/memgraph/pull/2388) +- Eliminated deadlock caused by concurrent calls to Stop method on the Scheduler. Eliminated deadlock caused by calling Pause after Stop from different threads. [#2398](https://github.com/memgraph/memgraph/pull/2398) +- Fixed a problem where [EdgeType index](/fundamentals/indexes#edge-type-index) would assign every element as obsolete which then caused the index to be incorrectly emptied by the GC. Fixed another problem where [EdgeTypeProperty index](/fundamentals/indexes#edge-type-property-index) never ran its GC. Now properly prevents edge index creation when properties-on-edges is disabled - the user must explicitly [provide](/database-management/configuration#storage) --storage-properties-on-edges. Now correctly prevents Edge indices being recovered when properties-on-edges is disabled by causing an assert during recovery. [Replication](/clustering/replication) now updates edge indices. [#2390](https://github.com/memgraph/memgraph/pull/2390) +- Replica now correctly reflects database registration success or failure. When replica receives a request for registering replica, it will now return status code NOT_MAIN. If attempting to undo an incomplete registration fails, then the Memgraph instance will be intentionally crashed because the system is in unrecoverable state. Main instance can now deal with stale RPC message GetReplicaUUID without crashing the instance. [#2373](https://github.com/memgraph/memgraph/pull/2373) +- Closing instance no longer crashes due to [streams](/data-streams) and/or [TTL](/querying/time-to-live) running in the background. [#2361](https://github.com/memgraph/memgraph/pull/2361) + ## Lab v2.17.0 - Sep 25, 2024 From 559a30e6d9f985ceb9e76ac1bd36653e3bc9fcbb Mon Sep 17 00:00:00 2001 From: Hal Eisen Date: Tue, 22 Oct 2024 17:08:20 -0700 Subject: [PATCH 09/31] Remove toolchain-v4 and obsolete versions of Linux --- .../getting-started/build-memgraph-from-source.mdx | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-) diff --git a/pages/getting-started/build-memgraph-from-source.mdx b/pages/getting-started/build-memgraph-from-source.mdx index 6dade5f9..c53c7cf9 100644 --- a/pages/getting-started/build-memgraph-from-source.mdx +++ b/pages/getting-started/build-memgraph-from-source.mdx @@ -111,13 +111,10 @@ to install the appropriate toolchain for your distribution. Download the toolchain for your operating system from one of the following links: - [CentOS 7](https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v5/toolchain-v5-binaries-centos-7-x86_64.tar.gz) -- [CentOS 8](https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v4/toolchain-v4-binaries-centos-8-x86_64.tar.gz) - [CentOS 9](https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v5/toolchain-v5-binaries-centos-9-x86_64.tar.gz) - [Fedora 39](https://s3.eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v5/toolchain-v5-binaries-fedora-39-amd64.tar.gz) -- [Debian 10](https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v4/toolchain-v4-binaries-debian-10-amd64.tar.gz) - [Debian 11 (x86_64)](https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v5/toolchain-v5-binaries-debian-11-amd64.tar.gz) - [Debian 11 (arm64)](https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v5/toolchain-v5-binaries-debian-11-arm64.tar.gz) -- [Ubuntu 18.04](https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v4/toolchain-v4-binaries-ubuntu-18.04-amd64.tar.gz) - [Ubuntu 20.04](https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v5/toolchain-v5-binaries-ubuntu-20.04-amd64.tar.gz) - [Ubuntu 22.04 (x86_64)](https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v5/toolchain-v5-binaries-ubuntu-22.04-amd64.tar.gz) - [Ubuntu 22.04 (arm64)](https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v5/toolchain-v5-binaries-ubuntu-22.04-arm64.tar.gz) @@ -131,7 +128,7 @@ sudo tar xzvfm {{toolchain-archive}}.tar.gz -C /opt After you have installed the toolchain, you should read the instructions for the -toolchain in the toolchain install directory (`/opt/toolchain-vXYZ/README.md`) +toolchain in the toolchain install directory (`/opt/toolchain-v5/README.md`) and install dependencies that are necessary to run the toolchain. @@ -146,12 +143,7 @@ sudo ./environment/os/install_deps.sh install TOOLCHAIN_RUN_DEPS - Based on your OS, version and architecture, execute appropriate scripts (e.g., on **Debian 10**, NOTE: the following commands/scripts are located under [memgraph repository](https://github.com/memgraph/memgraph)): - - ```bash - sudo ./environment/os/debian-10.sh check TOOLCHAIN_RUN_DEPS - sudo ./environment/os/debian-10.sh install TOOLCHAIN_RUN_DEPS - ``` + Based on your OS, version and architecture, execute appropriate scripts (NOTE: the following commands/scripts are located under [memgraph repository](https://github.com/memgraph/memgraph)): For ARM look for `-arm` in script name (e.g. on Ubuntu 22.04 with Apple M processor): @@ -168,7 +160,7 @@ prepared toolchain activation script that is also described in the toolchain You must activate the toolchain every time you want to compile Memgraph: ```bash -source /opt/toolchain-vXYZ/activate +source /opt/toolchain-v5/activate ``` In case you need to deactivate the toolchain, you can run: From 34e253334f5e564b20bb98a3e31023c2bad96f8b Mon Sep 17 00:00:00 2001 From: Hal Eisen Date: Thu, 24 Oct 2024 18:50:57 -0700 Subject: [PATCH 10/31] Changelog for 2430 (coordinators using only 1 log type --- pages/release-notes.mdx | 2 ++ 1 file changed, 2 insertions(+) diff --git a/pages/release-notes.mdx b/pages/release-notes.mdx index 34a838dd..76884f66 100644 --- a/pages/release-notes.mdx +++ b/pages/release-notes.mdx @@ -181,6 +181,8 @@ Memgraph (v2.11.1 and lower). - All data instances now use one type of callbacks to simplify state reconciliation. [#2421](https://github.com/memgraph/memgraph/pull/2421) - Incomplete storage reset when MAIN force reset or applied snapshots to REPLICA. [#2422](https://github.com/memgraph/memgraph/pull/2422) - Modifying mgp::memory is prohibited; use MemoryDispatcherGuard instead. [#2424](https://github.com/memgraph/memgraph/pull/2424) +- Coordinators now use one type of Raft logs to remove the need for distributed locks. Coordinator log store needs to be started from scratch, hence this change is a breaking one. [#2430](https://github.com/memgraph/memgraph/pull/2430) + ## Memgraph v2.20.1 - Oct 10, 2024 From 11b1223dd7153488c1a8a28d8dc4feee20753654 Mon Sep 17 00:00:00 2001 From: Hal Eisen Date: Thu, 24 Oct 2024 18:55:49 -0700 Subject: [PATCH 11/31] Add callout for breaking change (coordinator log store) --- pages/release-notes.mdx | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/pages/release-notes.mdx b/pages/release-notes.mdx index 76884f66..7741a252 100644 --- a/pages/release-notes.mdx +++ b/pages/release-notes.mdx @@ -18,6 +18,17 @@ New releases might affect your existing code, queries or configuration. Ensure they're updated to align with the latest updates and changes. +### Upgrading to Memgraph v2.21.0 + + + +{

Breaking change

} + +Coordinator log store needs to be started from scratch. + + + + ### Upgrading to Memgraph v2.20.0 @@ -33,6 +44,7 @@ supported Enterprise-licensed feature. + ### Upgrading to Memgraph v2.18.0 From 74e4e5bd3b3a626eaed550a5cb8b31a714ec59fb Mon Sep 17 00:00:00 2001 From: Gareth Andrew Lloyd Date: Sun, 3 Nov 2024 01:18:02 +0000 Subject: [PATCH 12/31] C++ API remove mgp::memory usage note (#1016) --- pages/custom-query-modules/cpp/cpp-api.md | 36 +++++++++++-------- .../custom-query-modules/cpp/cpp-example.mdx | 15 ++++---- 2 files changed, 30 insertions(+), 21 deletions(-) diff --git a/pages/custom-query-modules/cpp/cpp-api.md b/pages/custom-query-modules/cpp/cpp-api.md index 37bcb12c..4700d923 100644 --- a/pages/custom-query-modules/cpp/cpp-api.md +++ b/pages/custom-query-modules/cpp/cpp-api.md @@ -6,30 +6,36 @@ description: Get your hands on the API documentation for mgp.hpp, covering decla # Query modules C++ API This is the API documentation for `mgp.hpp`, which contains declarations of all -functions in the C++ API for implementing query module procedures and functions. -The source file can be found in the Memgraph installation directory, under -`/usr/include/memgraph`. +functions in the C++ API for implementing query module procedures and +functions. The source file can be found in the Memgraph installation directory, +under `/usr/include/memgraph`. -To see how to implement query modules in C++, take a look at -[the example we provided](/custom-query-modules/python/python-example). +To see how to implement query modules in C++, take a look at [the example we +provided](/custom-query-modules/python/python-example). If you install any C++ modules after running Memgraph, you’ll need to [load -them into Memgraph](/custom-query-modules/manage-query-modules#loading-query-modules) or restart -Memgraph in order to use them. +them into +Memgraph](/custom-query-modules/manage-query-modules#loading-query-modules) or +restart Memgraph in order to use them. ## Functions and procedures -With this API it’s possible to extend your Cypher queries with **functions** and **procedures** with -`AddProcedure` and `AddFunction`. +With this API it’s possible to extend your Cypher queries with **functions** +and **procedures** with `AddProcedure` and `AddFunction`. -The API needs memory access to add procedures and functions, this can be done with either `mgp::MemoryDispatcherGuard guard(memory);` or `mgp::memory = memory;`, where the use of the former is advised since `mgp::memory = memory;` is not thread-safe and will be deprecated in the future. +The API needs memory access to add procedures and functions, this can be done +with `mgp::MemoryDispatcherGuard guard(memory);`. Old code used `mgp::memory = +memory;`, but this is not thread-safe and has been deprecated. v2.18.1 onwards +you should modify your C++ modules and recompile. v2.21 onwards setting +`mgp::memory` will cause a compilation error, so the guard has to be used. -Functions are simple operations that return a single value and can be used in any expression or predicate. - -Procedures are more complex computations that may modify the graph, and their output is available to -later processing steps in your query. A procedure may only be run from `CALL` clauses. -The output is a stream of **records** that is made accessible with a `YIELD` clause. +Functions are simple operations that return a single value and can be used in +any expression or predicate. +Procedures are more complex computations that may modify the graph, and their +output is available to later processing steps in your query. A procedure may +only be run from `CALL` clauses. The output is a stream of **records** that is +made accessible with a `YIELD` clause. ### AddProcedure diff --git a/pages/custom-query-modules/cpp/cpp-example.mdx b/pages/custom-query-modules/cpp/cpp-example.mdx index b5598766..aa29847f 100644 --- a/pages/custom-query-modules/cpp/cpp-example.mdx +++ b/pages/custom-query-modules/cpp/cpp-example.mdx @@ -392,13 +392,16 @@ void RandomWalk(mgp_list *args, mgp_graph *memgraph_graph, mgp_result *result, m -As `mgp::memory` is a global object, that means all of the procedures and +`mgp::memory` was a global object, that meant all of the procedures and functions in a single shared library will refer to the same `mgp::memory` -object. As a result, calling such callables simultaneously from multiple threads -will lead to incorrect memory usage. This also includes the case when the same -callable is called from different user sessions. This is a constraint when using -`mgp::memory` so the use of the thread-safe `MemoryDispatcherGuard guard(memory)` -is advised instead. +object. As a result, calling such callables simultaneously from multiple +threads will lead to incorrect memory usage. This also includes the case when +the same callable is called from different user sessions. For some versions of +memgraph this was deprecated and the use of the thread-safe +`MemoryDispatcherGuard guard(memory)` is advised instead. Its has now been +removed and C++ modules should be recompiled for v2.18.1+. v2.21 onwards +setting `mgp::memory` will cause a compilation error, so the guard has to be +used. From 42d1d8de986726fd628dd81d43ca5441c4a98397 Mon Sep 17 00:00:00 2001 From: Marko Budiselic Date: Sat, 2 Nov 2024 18:28:17 -0700 Subject: [PATCH 13/31] Add changelog item for the query module memory guard --- pages/release-notes.mdx | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/pages/release-notes.mdx b/pages/release-notes.mdx index 7741a252..8ffb82b9 100644 --- a/pages/release-notes.mdx +++ b/pages/release-notes.mdx @@ -192,8 +192,15 @@ Memgraph (v2.11.1 and lower). - schema.assert will throw an exception if ran inside the explicit transaction. [#2352](https://github.com/memgraph/memgraph/pull/2352) - All data instances now use one type of callbacks to simplify state reconciliation. [#2421](https://github.com/memgraph/memgraph/pull/2421) - Incomplete storage reset when MAIN force reset or applied snapshots to REPLICA. [#2422](https://github.com/memgraph/memgraph/pull/2422) -- Modifying mgp::memory is prohibited; use MemoryDispatcherGuard instead. [#2424](https://github.com/memgraph/memgraph/pull/2424) +- Modifying `mgp::memory` is prohibited; use `MemoryDispatcherGuard` instead. + Under C++ query modules, if module tries to set `mgp::memory` there will be a + compilation error. Usually at the beginning of the `mgp_init_module` + implementation there should be the `mgp::MemoryDispatcherGuard + guard(memory);`. Usage examples could be found under [MAGE C++ + modules](https://github.com/memgraph/mage/tree/main/cpp). + [#2424](https://github.com/memgraph/memgraph/pull/2424) - Coordinators now use one type of Raft logs to remove the need for distributed locks. Coordinator log store needs to be started from scratch, hence this change is a breaking one. [#2430](https://github.com/memgraph/memgraph/pull/2430) +- Compilation error if module tries to set mgp::memory [#2424]() From 81c334db7f150a898adf71b86eceb4a066dd08ea Mon Sep 17 00:00:00 2001 From: Marko Budiselic Date: Sun, 3 Nov 2024 14:47:41 -0800 Subject: [PATCH 14/31] Iteration under the release notes --- pages/release-notes.mdx | 61 ++++++++++++++++++++++++++++++----------- 1 file changed, 45 insertions(+), 16 deletions(-) diff --git a/pages/release-notes.mdx b/pages/release-notes.mdx index 8ffb82b9..a205b638 100644 --- a/pages/release-notes.mdx +++ b/pages/release-notes.mdx @@ -18,23 +18,19 @@ New releases might affect your existing code, queries or configuration. Ensure they're updated to align with the latest updates and changes. -### Upgrading to Memgraph v2.21.0 +### Upgrading to Memgraph v2.21.0 breaking change -{

Breaking change

} - Coordinator log store needs to be started from scratch. -### Upgrading to Memgraph v2.20.0 +### Upgrading to Memgraph v2.20.0 breaking change -{

Breaking change

} - In this version of Memgraph, we have removed the experimental classification for system replication. Going forward, the `--experimental-enabled` configuration flag no longer recognizes the `system-replication` argument which was introduced @@ -178,20 +174,28 @@ Memgraph (v2.11.1 and lower). -## Memgraph v2.21.0 - Nov 6, 2024 +## Memgraph v2.21.0 and MAGE v1.21.0 - Nov 6, 2024 {

New features and improvements

} -- TBD +- Added planner optimization to replace `point.distance` filter with an index + scan. Queries like `WITH point({x:0,y:0}) AS a MATCH (m:L1) WHERE + point.distance(m.prop, a) < 1 RETURN m;`, should run faster if there is the + point index created. If you are dealing with spatial data, there is a high + chance you need such indexes to run your queries faster. + [#2362](https://github.com/memgraph/memgraph/pull/2362) {

Bug fixes

} -- Closing instance would crash due to streams and/or TTL running in the background. [#2361](https://github.com/memgraph/memgraph/pull/2361) -- Add backticks around property keys in any \{key: value\} patterns. [#2371](https://github.com/memgraph/memgraph/pull/2371) -- When replica gets promoted to main upon failover, it will use correctly incremented durable timestamp. [#2366](https://github.com/memgraph/memgraph/pull/2366) -- schema.assert will throw an exception if ran inside the explicit transaction. [#2352](https://github.com/memgraph/memgraph/pull/2352) -- All data instances now use one type of callbacks to simplify state reconciliation. [#2421](https://github.com/memgraph/memgraph/pull/2421) -- Incomplete storage reset when MAIN force reset or applied snapshots to REPLICA. [#2422](https://github.com/memgraph/memgraph/pull/2422) +- Closing instance would crash due to streams and/or TTL running in the + background. [#2361](https://github.com/memgraph/memgraph/pull/2361) +- Add backticks around property keys in any \{key: value\} patterns. + [#2371](https://github.com/memgraph/memgraph/pull/2371) +- When replica gets promoted to main upon failover, it will use correctly + incremented durable timestamp. + [#2366](https://github.com/memgraph/memgraph/pull/2366) +- `schema.assert` will throw an exception if ran inside the explicit transaction. + [#2352](https://github.com/memgraph/memgraph/pull/2352) - Modifying `mgp::memory` is prohibited; use `MemoryDispatcherGuard` instead. Under C++ query modules, if module tries to set `mgp::memory` there will be a compilation error. Usually at the beginning of the `mgp_init_module` @@ -199,10 +203,35 @@ Memgraph (v2.11.1 and lower). guard(memory);`. Usage examples could be found under [MAGE C++ modules](https://github.com/memgraph/mage/tree/main/cpp). [#2424](https://github.com/memgraph/memgraph/pull/2424) -- Coordinators now use one type of Raft logs to remove the need for distributed locks. Coordinator log store needs to be started from scratch, hence this change is a breaking one. [#2430](https://github.com/memgraph/memgraph/pull/2430) -- Compilation error if module tries to set mgp::memory [#2424]() +{

High-availability automatic failover improvements

} + +There are a lot of efforts to make Memgraph HA rock-solid in the production +environments. Under this release, the feature is still experimental, but +getting very close to put the stable flag next to it. The full list if issues +and improvements can be found +[HERE](https://github.com/memgraph/memgraph/issues?q=label%3Ajepsen) (GH issues +labeled with `jepsen`). + +- All data instances now use one type of callbacks to simplify state + reconciliation. [#2421](https://github.com/memgraph/memgraph/pull/2421) +- Incomplete storage reset when MAIN force reset or applied snapshots to + REPLICA. [#2422](https://github.com/memgraph/memgraph/pull/2422) +- Coordinators now use one type of Raft logs to remove the need for distributed + locks. Coordinator log store needs to be started from scratch, hence this + change is a breaking one. + [#2430](https://github.com/memgraph/memgraph/pull/2430) + +### MAGE v1.21.0 + +{

New features and improvements

} +- Added Leiden algorithm. The implementation is "static" in a sense that it's + operating on the whole graph. Leiden is a modern community detection + algorithm that in Memgraph's implementation provides hierarchies of + communities. A big use-cases for Leiden community detection is + [GraphRAG](/ai-ecosystem/graph-rag). + [#508](https://github.com/memgraph/mage/pull/508) ## Memgraph v2.20.1 - Oct 10, 2024 From c16deabc65ac39eee433969d2349c65110df5a30 Mon Sep 17 00:00:00 2001 From: David Ivekovic Date: Mon, 4 Nov 2024 00:18:53 +0100 Subject: [PATCH 15/31] Add Leiden static community detection algorithm (#1014) --- .../available-algorithms.md | 3 +- .../leiden_community_detection.mdx | 268 ++++++++++++++++++ 2 files changed, 270 insertions(+), 1 deletion(-) create mode 100644 pages/advanced-algorithms/available-algorithms/leiden_community_detection.mdx diff --git a/pages/advanced-algorithms/available-algorithms.md b/pages/advanced-algorithms/available-algorithms.md index dc76509e..7bda7041 100644 --- a/pages/advanced-algorithms/available-algorithms.md +++ b/pages/advanced-algorithms/available-algorithms.md @@ -24,7 +24,7 @@ library](/advanced-algorithms/install-mage). | Algorithms | Lang | Description | |------------------------------------------------------------------------------------------------------|--------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| [algo](/advanced-algorithms/available-algorithms/algo) | C++ | The algo module provides users with a powerful set of graph algorithms, enabling users to perform complex graph-based operations and computations, such as graph traversal, edge detection, and more. | +| [algo](/advanced-algorithms/available-algorithms/algo) | C++ | The algo module provides users with a powerful set of graph algorithms, enabling users to perform complex graph-based operations and computations, such as graph traversal, edge detection, and more. | | [betweenness_centrality](/advanced-algorithms/available-algorithms/betweenness_centrality) | C++ | The betweenness centrality of a node is defined as the sum of the of all-pairs shortest paths that run through the node, divided by the number of all-pairs shortest paths in the graph. The algorithm has O(nm) time complexity. | | [biconnected_components](/advanced-algorithms/available-algorithms/biconnected_components) | C++ | Algorithm for calculating maximal biconnected subgraph. A biconnected subgraph is a subgraph with a property that if any vertex were to be removed, the graph will remain connected. | | [bipartite_matching](/advanced-algorithms/available-algorithms/bipartite_matching) | C++ | Algorithm for calculating maximum bipartite matching, where matching is a set of nodes chosen in such a way that no two edges share an endpoint. | @@ -36,6 +36,7 @@ library](/advanced-algorithms/install-mage). | [graph_coloring](/advanced-algorithms/available-algorithms/graph_coloring) | Python | Algorithm for assigning labels to the graph elements subject to certain constraints. In this form, it is a way of coloring the graph vertices such that no two adjacent vertices are of the same color. | | [katz_centrality](/advanced-algorithms/available-algorithms/katz_centrality) | C++ | Katz centrality is a centrality measurement that outputs a node's influence based on the number of shortest paths and their weighted length. | | [kmeans_clustering](/advanced-algorithms/available-algorithms/kmeans_clustering) | Python | An algorithm for clustering given data. | +| [leiden_community_detection](/advanced-algorithms/available-algorithms/leiden_community_detection) | C++ | The Leiden method for community detection is an improvement over the Louvain method, designed to find communities with maximum modularity in a graph while addressing issues of disconnected communities. Runs in _O_(L\*E) time and _O_(V\*E) space, where *L* is the number of iterations of the algorithm, E is the number of edges, V is the number of nodes. | | [max_flow](/advanced-algorithms/available-algorithms/max_flow) | Python | An algorithm for finding a flow through a graph such that it is the maximum possible flow. | | [node_similarity](/advanced-algorithms/available-algorithms/node_similarity) | C++ | A module that contains similarity measures for calculating the similarity between two nodes. | | [pagerank](/advanced-algorithms/available-algorithms/pagerank) | C++ | Algorithm that yields the influence measurement based on the recursive information about the connected nodes influence. | diff --git a/pages/advanced-algorithms/available-algorithms/leiden_community_detection.mdx b/pages/advanced-algorithms/available-algorithms/leiden_community_detection.mdx new file mode 100644 index 00000000..bea2be72 --- /dev/null +++ b/pages/advanced-algorithms/available-algorithms/leiden_community_detection.mdx @@ -0,0 +1,268 @@ +--- +title: leiden_community_detection +description: Explore Memgraph's Leiden community detection capabilities and learn how to analyze the structure of complex networks. Access tutorials and comprehensive documentation to enhance your understanding of Leiden community detection algorithm. +--- + +import { Steps } from 'nextra/components' +import { Callout } from 'nextra/components' +import { Card, Cards } from 'nextra/components' +import GitHub from '/components/icons/GitHub' + +# leiden_community_detection + +Community in graphs mirrors real-world communities, like social circles. In a +graph, communities are sets of nodes. M. Girvan and M. E. J. Newman note that +nodes in a community connect more intensely with each other than with outside +nodes. + +This module employs the [Leiden +algorithm](https://en.wikipedia.org/wiki/Leiden_algorithm) for community +detection based on paper [*From Louvain to Leiden: guaranteeing well-connected +communities*](https://arxiv.org/abs/1810.08473). The Leiden algorithm is a +hierarchical clustering algorithm, that recursively merges communities into +single nodes by greedily optimizing the modularity and the process repeats in +the condensed graph. It enhances the Louvain algorithm by addressing its +limitations, particularly in situations where some identified communities are +not well-connected. This improvement is made by periodically subdividing +communities into smaller, well-connected groups. With an $\mathcal{O}(Lm)$ +runtime for $m$ edges and $L$ number of iterations, it suits large graphs. The +space complexity if $\mathcal{O}(VE)$ for $V$ nodes and $E$ edges. + + + } + title="Source code" + href="https://github.com/memgraph/mage/blob/main/cpp/leiden_community_detection_module/leiden_community_detection_module.cpp" + /> + + +| Trait | Value | +| ------------------------ | --------------------- | +| **Module type** | algorithm | +| **Implementation** | C++ | +| **Graph direction** | undirected | +| **Relationship weights** | weighted / unweighted | +| **Parallelism** | parallel | + +## Procedures + + +You can execute this algorithm on [graph projections, subgraphs or portions of +the graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph). + + +### `get()` + +Computes graph communities using the Leiden algorithm. For more information on +specific algorithm parameters and their use, refer to the paper [*From Louvain +to Leiden: guaranteeing well-connected +communities*](https://arxiv.org/abs/1810.08473). + +{

Input:

} + +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object + of type + Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) + returned by the `project()` function, on which the algorithm is run. If + subgraph is not specified, the algorithm is computed on the entire graph by + default. +- `weight: string (default=null)` ➡ Specifies the name of the property + containing the edge weight. Users can set their own weight property; if this + property is not specified, the algorithm uses the `weight` edge attribute by + default. If neither is set, each edge's weight defaults to `1`. To utilize a + custom weight property, the user must set the + `--storage-properties-on-edges=true` flag. +- `gamma: double (default=1.0)` ➡ Resolution parameter used when computing the + modularity. Higher resolutions lead to more smaller communities, while lower + resolutions lead to fewer larger communities. +- `theta: double (default=0.01)` ➡ Controls the randomness while breaking a + community into smaller ones. +- `resolution_parameter: double (default=0.01)` ➡ Minimum change in modularity + that must be achieved when merging nodes within the same community. +- `max_iterations: int (default=inf)` ➡ Maximum number of iterations the + algorithm will perform. If set to infinity, the algorithm will run until + convergence is reached. + +{

Output:

} + +- `node: Vertex` ➡ A graph node for which the algorithm was performed and + returned as part of the results. +- `community_id: integer` ➡ Community ID. Defaults to $-1$ if the node does not + belong to any community. +- `communities: list` ➡ List representing the hierarchy of communities that a + node has belonged to across iterations. + +{

Usage:

} + +Use the following query to detect communities: + +```cypher +CALL leiden_community_detection.get() +YIELD node, community_id, communities; +``` + +### `get_subgraph()` + +Computes graph communities over a subgraph using the Leiden method. + +{

Input:

} + +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object + of type + Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) + returned by the `project()` function, on which the algorithm is run. If + subgraph is not specified, the algorithm is computed on the entire graph by + default. +- `subgraph_nodes: List[Node]` ➡ List of nodes in the subgraph. +- `subgraph_relationships: List[Relationship]` ➡ List of relationships in the + subgraph. +- `weight: string (default=null)` ➡ Specifies the name of the property + containing the edge weight. Users can set their own weight property; if this + property is not specified, the algorithm uses the `weight` edge attribute by + default. If neither is set, each edge's weight defaults to `1`. To utilize a + custom weight property, the user must set the + `--storage-properties-on-edges=true` flag. +- `gamma: double (default=1.0)` ➡ Resolution parameter used when computing the + modularity. Higher resolutions lead to more smaller communities, while lower + resolutions lead to fewer larger communities. +- `theta: double (default=0.01)` ➡ Controls the randomness while breaking a + community into smaller ones. +- `resolution_parameter: double (default=0.01)` ➡ Minimum change in modularity + that must be achieved when merging nodes within the same community. +- `max_iterations: int (default=inf)` ➡ Maximum number of iterations the + algorithm will perform. If set to infinity, the algorithm will run until + convergence is reached. + +{

Output:

} + +- `node: Vertex` ➡ A graph node for which the algorithm was performed and + returned as part of the results. +- `community_id: int` ➡ Community ID. Defaults to $-1$ if the node does not + belong to any community. +- `communities: list` ➡ List representing the hierarchy of communities that a + node has belonged to across iterations. + +{

Usage:

} + +Use the following query to compute communities in a subgraph: + +```cypher +MATCH (a)-[e]-(b) +WITH COLLECT(a) AS nodes, COLLECT (e) AS relationships +CALL leiden_community_detection.get_subgraph(nodes, relationships) +YIELD node, community_id, communities; +``` + +## Single Iteration Example + + + +{

Database state

} + +The database contains the following data: + +![](/pages/advanced-algorithms/available-algorithms/community_detection/community-detection-1.png) + +Created with the following Cypher queries: + +```cypher +MERGE (a: Node {id: 0}) MERGE (b: Node {id: 1}) CREATE (a)-[r: Relation]->(b); +MERGE (a: Node {id: 0}) MERGE (b: Node {id: 2}) CREATE (a)-[r: Relation]->(b); +MERGE (a: Node {id: 1}) MERGE (b: Node {id: 2}) CREATE (a)-[r: Relation]->(b); +MERGE (a: Node {id: 2}) MERGE (b: Node {id: 3}) CREATE (a)-[r: Relation]->(b); +MERGE (a: Node {id: 3}) MERGE (b: Node {id: 4}) CREATE (a)-[r: Relation]->(b); +MERGE (a: Node {id: 3}) MERGE (b: Node {id: 5}) CREATE (a)-[r: Relation]->(b); +MERGE (a: Node {id: 4}) MERGE (b: Node {id: 5}) CREATE (a)-[r: Relation]->(b); +``` + +{

Detect communities

} + +Get communities using the following query: + +```cypher +CALL leiden_community_detection.get() +YIELD node, community_id, communities +RETURN node.id AS node_id, community_id, communities +ORDER BY node_id; +``` + +Results show which nodes belong to community 0, and which to community 1. + +```plaintext ++--------------+--------------+--------------+ +| node_id | community_id | communities | ++--------------+--------------+--------------+ +| 0 | 0 | [0] | +| 1 | 0 | [0] | +| 2 | 0 | [0] | +| 3 | 1 | [1] | +| 4 | 1 | [1] | +| 5 | 1 | [1] | ++--------------+--------------+--------------+ +``` + + + +## Multiple Iterations Example + + + +{

Database state

} + +The database contains the following data: + +![](/pages/advanced-algorithms/available-algorithms/katz_centrality/memgraph-katz.png) + +Created with the following Cypher queries: + +```cypher +MERGE (a:Node {id: 1}) MERGE (b:Node {id: 0}) CREATE (a)-[:RELATION]->(b); +MERGE (a:Node {id: 1}) MERGE (b:Node {id: 10}) CREATE (a)-[:RELATION]->(b); +MERGE (a:Node {id: 2}) MERGE (b:Node {id: 1}) CREATE (a)-[:RELATION]->(b); +MERGE (a:Node {id: 2}) MERGE (b:Node {id: 8}) CREATE (a)-[:RELATION]->(b); +MERGE (a:Node {id: 2}) MERGE (b:Node {id: 10}) CREATE (a)-[:RELATION]->(b); +MERGE (a:Node {id: 3}) MERGE (b:Node {id: 10}) CREATE (a)-[:RELATION]->(b); +MERGE (a:Node {id: 4}) MERGE (b:Node {id: 10}) CREATE (a)-[:RELATION]->(b); +MERGE (a:Node {id: 4}) MERGE (b:Node {id: 2}) CREATE (a)-[:RELATION]->(b); +MERGE (a:Node {id: 5}) MERGE (b:Node {id: 10}) CREATE (a)-[:RELATION]->(b); +MERGE (a:Node {id: 5}) MERGE (b:Node {id: 2}) CREATE (a)-[:RELATION]->(b); +MERGE (a:Node {id: 6}) MERGE (b:Node {id: 2}) CREATE (a)-[:RELATION]->(b); +MERGE (a:Node {id: 7}) MERGE (b:Node {id: 2}) CREATE (a)-[:RELATION]->(b); +MERGE (a:Node {id: 8}) MERGE (b:Node {id: 2}) CREATE (a)-[:RELATION]->(b); +MERGE (a:Node {id: 8}) MERGE (b:Node {id: 10}) CREATE (a)-[:RELATION]->(b); +MERGE (a:Node {id: 9}) MERGE (b:Node {id: 10}) CREATE (a)-[:RELATION]->(b); +MERGE (a:Node {id: 10}) MERGE (b:Node {id: 9}) CREATE (a)-[:RELATION]->(b); +``` + +{

Detect communities

} + +Get communities using the following query: + +```cypher +CALL leiden_community_detection.get() +YIELD node, community_id, communities +RETURN node.id AS node_id, community_id, communities +ORDER BY node_id; +``` + +The results show which nodes belong to community 0 and which to community 1, as well as how nodes changed communities across iterations. + +```plaintext ++--------------+--------------+--------------+ +| node_id | community_id | communities | ++--------------+--------------+--------------+ +| 0 | 1 | [0, 1] | +| 1 | 1 | [0, 1] | +| 2 | 0 | [1, 0] | +| 3 | 1 | [2, 1] | +| 4 | 1 | [3, 1] | +| 5 | 0 | [4, 0] | +| 6 | 0 | [1, 0] | +| 7 | 0 | [1, 0] | +| 8 | 0 | [1, 0] | +| 9 | 1 | [2, 1] | +| 10 | 1 | [2, 1] | ++--------------+--------------+--------------+ +``` + + From 4c418e5673ec3aa3b2b04bf5d64c450b6df8ce51 Mon Sep 17 00:00:00 2001 From: Marko Budiselic Date: Sun, 3 Nov 2024 15:29:35 -0800 Subject: [PATCH 16/31] Add the show schema info changelog item --- pages/release-notes.mdx | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/pages/release-notes.mdx b/pages/release-notes.mdx index a205b638..a5a320d7 100644 --- a/pages/release-notes.mdx +++ b/pages/release-notes.mdx @@ -184,6 +184,10 @@ Memgraph (v2.11.1 and lower). point index created. If you are dealing with spatial data, there is a high chance you need such indexes to run your queries faster. [#2362](https://github.com/memgraph/memgraph/pull/2362) +- Significantly improved schema retrieval performance in both TRANSACTIONAL and + ANALYTICAL setups. Feel free to use `--schema-info-enabled=True` to get + schema instantly by running the `SHOW SCHEMA INFO;` query. + [#2383](https://github.com/memgraph/memgraph/pull/2383) {

Bug fixes

} From ce2a29d894e5f67096e255983c75833d2e28c93d Mon Sep 17 00:00:00 2001 From: Marko Budiselic Date: Sun, 3 Nov 2024 18:06:07 -0800 Subject: [PATCH 17/31] Add all changelog items, Grammarly check TBD --- pages/release-notes.mdx | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/pages/release-notes.mdx b/pages/release-notes.mdx index a5a320d7..990dc752 100644 --- a/pages/release-notes.mdx +++ b/pages/release-notes.mdx @@ -188,6 +188,9 @@ Memgraph (v2.11.1 and lower). ANALYTICAL setups. Feel free to use `--schema-info-enabled=True` to get schema instantly by running the `SHOW SCHEMA INFO;` query. [#2383](https://github.com/memgraph/memgraph/pull/2383) +- Added query metadata when logging incoming query. It's possible now, e.g., to + filter certain database log entries or search for specific items in the log. + [#2404](https://github.com/memgraph/memgraph/pull/2404) {

Bug fixes

} @@ -207,6 +210,20 @@ Memgraph (v2.11.1 and lower). guard(memory);`. Usage examples could be found under [MAGE C++ modules](https://github.com/memgraph/mage/tree/main/cpp). [#2424](https://github.com/memgraph/memgraph/pull/2424) +- Fixed incorrect usage of cv and stop token in scheduler and thread pool. + [#2452](https://github.com/memgraph/memgraph/pull/2452) +- Fixed unreleased deltas counter. There was a missing case of tracking when + deltas were actually released. This gave the appearance in `SHOW STORAGE + INFO;` that we were not actually releasing them. + [#2446](https://github.com/memgraph/memgraph/pull/2446) +- Fixed edge index not removing deleted edges. Edge index would not remove + deleted (obsolete) entries, while the GC would delete the edge object. Edge + type index was impacted, while the property type would detect that the object + was deleted due to it checking the property. + [#2439](https://github.com/memgraph/memgraph/pull/2439) +- Removed usage of RTLD_DEEPBIND under query modules. Query modules, especially + the Python ones should work better in terms of correct module loading. + [#2347](https://github.com/memgraph/memgraph/pull/2347) {

High-availability automatic failover improvements

} From 39c37ac0bbe0ab6b2e46398b95dcb4c8af03dd28 Mon Sep 17 00:00:00 2001 From: Andi Skrgat Date: Mon, 4 Nov 2024 08:54:16 +0100 Subject: [PATCH 18/31] Improve breaking change --- pages/release-notes.mdx | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/pages/release-notes.mdx b/pages/release-notes.mdx index 990dc752..6df3c57a 100644 --- a/pages/release-notes.mdx +++ b/pages/release-notes.mdx @@ -22,7 +22,8 @@ Ensure they're updated to align with the latest updates and changes. -Coordinator log store needs to be started from scratch. +Coordinator log store directory in `--data-directory` needs to be started from scratch since new type of Raft log is added and some old ones +were deleted. Memgraph could crash without deleting old logs from log store directory. From 0c6849d86763cab6b0915429877e8fae83cbe806 Mon Sep 17 00:00:00 2001 From: David Ivekovic Date: Mon, 4 Nov 2024 19:56:16 +0100 Subject: [PATCH 19/31] Add explanation for exception handling in Leiden community detection algorithm (#1027) * explain when algorithms throws exception * slight adjustment --- .../available-algorithms/leiden_community_detection.mdx | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/pages/advanced-algorithms/available-algorithms/leiden_community_detection.mdx b/pages/advanced-algorithms/available-algorithms/leiden_community_detection.mdx index bea2be72..39e8ad0d 100644 --- a/pages/advanced-algorithms/available-algorithms/leiden_community_detection.mdx +++ b/pages/advanced-algorithms/available-algorithms/leiden_community_detection.mdx @@ -101,6 +101,11 @@ CALL leiden_community_detection.get() YIELD node, community_id, communities; ``` + +The algorithm throws an exception if no communities are detected. This can happen if in the first iteration +all nodes merge into a single community or if each node forms its own. If this occurs, try adjusting the algorithm's `gamma` parameter. + + ### `get_subgraph()` Computes graph communities over a subgraph using the Leiden method. From 9820a5581a769755fd7351cdc499c5149bdba1c0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ivan=20Milinovi=C4=87?= <44698587+imilinovic@users.noreply.github.com> Date: Tue, 5 Nov 2024 03:37:58 +0100 Subject: [PATCH 20/31] Spatial index and data type docs (#1018) --- pages/fundamentals/data-types.mdx | 171 ++++++++++++++++++++++++++++++ pages/fundamentals/indexes.mdx | 35 ++++++ pages/querying/functions.mdx | 7 ++ pages/querying/query-plan.mdx | 1 + 4 files changed, 214 insertions(+) diff --git a/pages/fundamentals/data-types.mdx b/pages/fundamentals/data-types.mdx index f538ec70..58eb51ea 100644 --- a/pages/fundamentals/data-types.mdx +++ b/pages/fundamentals/data-types.mdx @@ -51,6 +51,7 @@ the supported types. Below is a table of supported data types. | [`LocalDateTime`](#localdatetime) | Date and time without the timezone. | | [`ZonedDateTime`](#zoneddatetime) | Date and time in a specific timezone. | | [`Enum`](#enum) | An enumeration value. | +| [`Point`](#point) | 2D or 3D point either in Cartesian or WGS format. | @@ -772,6 +773,176 @@ and display it nicely in the client-side results. +## Point + +Point is a spatial data type consisting of 2D or 3D locations in the Cartesian +or WGS84 system. The coordinates of the location are stored as a 64-bit `Float` +numbers. Each point type has an associated coordinate reference system (CRS) +and a spatial reference identifier (SRID). Points can be created with the +[point function](#point-functions). For fast queries, points can +leverage the [point index](/fundamentals/indexes#point-index). + +### Coordinate Reference Systems (CRS) + +Memgraph supports four Coordinate Reference Systems (CRS) for spatial data, divided into two categories: + +1. **WGS-84 CRS** models points on the Earth’s surface using longitude and latitude based on the [WGS84](https://epsg.io/4326) system. +2. **Cartesian CRS** models points in Euclidean space using standard Cartesian coordinates. + + + +**CRS compatibility** - Points in different CRSs cannot be directly compared or converted into one another, even if they share the same type (e.g., both WGS-84 or Cartesian). For example, a 2D point cannot be used in a 3D range query. + + + +#### WGS-84 + +A WGS-84 point consists of longitude, latitude, and height if the point is 3D. +Longitude and latitude are specified in degrees while height is specified in meters. +Longitude has to be in the [-180, 180] range, latitude in the [-90, 90] range and height can be any `Float` value. + +| Point type | SRID | CRS | +| :---------------: | :----------: | :--------: | +| WGS-84 2D | 4326 | wgs-84 | +| WGS-84 3D | 4979 | wgs-84-3d | + + +#### Cartesian + +Two types of Cartesian Coordinate Reference Systems (CRS) are supported, defining points in a flat, Euclidean space. +Cartesian points can be either 2D or 3D. They consist of coordinates x, y, and z if the point is 3D. All coordinates can be any `Float` value. + +| Point type | SRID | CRS | +| :---------------: | :----------: | :-----------: | +| Cartesian 2D | 7203 | cartesian | +| Cartesian 3D | 9157 | cartesian-3d | + + +### Point functions + +#### point(parameters: map) -> [null, point] + +Point function is used to create the point data type. It takes in a map of parameters to create the type. The point type can be specified using its `crs` or `srid`. +If any of the parameters evaluates to null the point function returns null. Here are the examples of how to create a point, depending on the`crs` and `srd`: + +- **WGS-84 2D** - A 2D geographic point in the **WGS-84 CRS** can be created in one of two ways: + + - **longitude** and **latitude** (if these are specified, and the `crs` is not, then the `crs` is assumed to be `WGS-84`). + ```cypher + RETURN point({longitude:-73.93, latitude:40.73}) AS new_york; + ``` + - **x** and **y** (in this case, the `crs` or `srid` must be specified or will be assumed to be Cartesian). + ```cypher + RETURN point({x:-73.93, y:40.73, crs:'wgs-84'}) AS new_york; + ``` + +- **WGS 84 3D** - A 3D geographic point in the **WGS-84 CRS** can be created in one of two ways: + + - **longitude**, **latitude**, and either **height** or **z** (if these are specified, and the `crs` is not, then the `crs` is assumed to be `WGS-84-3D`). + ```cypher + RETURN point({longitude:-73.93, latitude:40.73, height:10}) AS new_york; + RETURN point({longitude:-73.93, latitude:40.73, z:10}) AS new_york; + ``` + - **x**, **y**, and **z** (in this case, the `crs` or `srid` must be specified, or will be assumed to be Cartesian-3D). + ```cypher + RETURN point({x:-73.93, y:40.73, z:10, srid:4979}) AS new_york; + ``` + +- **Cartesian 2D** - A 2D Cartesian point can be created by providing: + + - **x** and **y** (when provided, the point is assumed to reside in a two-dimensional Cartesian system). + ```cypher + RETURN point({x:0, y:1}) AS cartesian_point; + ``` + +- **Cartesian 3D** - A 3D Cartesian point can be created by providing: + + - **x**, **y**, and **z** (when provided, the point is assumed to reside in a three-dimensional Cartesian system). + ```cypher + RETURN point({x:0, y:1, z:2}) AS cartesian_point; + ``` + +#### point.distance(x: [null, point], y: [null, point]) -> [null, float] + +The point.distance function returns the distance between two points. Distance can only be calculated between points of the same type. +For WGS-84 points the distance is calculated in meters and is calculated using the [Haversine](https://en.wikipedia.org/wiki/Haversine_formula) formula. +For WGS-84 3D points the Haversine formula is applied to longitude and latitude and then the Pythagorean theorem is applied between the calculated distance and the height. +For Cartesian points, the Pythagorean theorem is applied. +If any of the arguments of the point.distance function evaluates to null or the point types don't match then the function returns null. + +{
Usage:
} + +Example of the distance between two points in WGS-84 2D: +```cypher + WITH point({longitude: 51.51, latitude: -0.12}) as london, + point({longitude: 45.82, latitude: 15.97}) as zagreb + RETURN point.distance(london, zagreb) AS result; +``` +```plaintext ++----------------------------+ +| result | ++----------------------------+ +| 1.88621e+06 | ++----------------------------+ +``` + +Example of the distance between two points in 2D Cartesian space: +```cypher + RETURN point.distance( + point({x: 0, y: 0}), + point({x: 3, y: 3}) + ) AS result; +``` +```plaintext ++----------------------------+ +| result | ++----------------------------+ +| 4.24264 | ++----------------------------+ +``` + + +#### point.withinbbox(point: [null, point], lower_left_corner: [null, point], upper_right_corner: [null, point]) -> [null, boolean] + +The point.withinbbox function returns whether the given `point` is inside or on the edge of the bounding box created by `lower_left_corner` and `upper_right_corner`. +For WGS-84 points this also works if crossing the the international date line. + +{
Usage:
} + +Example of a point inside the bounding box: +```cypher + RETURN point.withinbbox( + point({x: 0, y: 0}), + point({x: -1, y: -1}), + point({x: 1, y: 1}) + ) AS result; +``` +```plaintext ++----------------------------+ +| result | ++----------------------------+ +| true | ++----------------------------+ +``` + +Example of crossing the international date line: +```cypher + RETURN point.withinbbox( + point({longitude: 180, latitude: 58.0}), + point({longitude: 179, latitude: 57.0}), + point({longitude: -179, latitude: 59.0}) + ) AS result; +``` +```plaintext ++----------------------------+ +| result | ++----------------------------+ +| true | ++----------------------------+ +``` + +If any of the arguments of the point.withinbbox function evaluates to null or the point types don't match then the function returns null. + ## Procedures API Data types are also used within query modules. Check out the documentation for diff --git a/pages/fundamentals/indexes.mdx b/pages/fundamentals/indexes.mdx index 56b0fb63..347bd486 100644 --- a/pages/fundamentals/indexes.mdx +++ b/pages/fundamentals/indexes.mdx @@ -187,6 +187,41 @@ Named parameters are not supported for edge-type property indexes. +### Point index + +To run queries such as: +```cypher +WITH point({x:1, y:1}) AS p +MATCH (node:Label) WHERE point.distance(p, node.property) < 1 +RETURN node; +``` +in a performant way, feel free to create a new point index as follows: +```cypher +CREATE POINT INDEX ON :Label(property); +``` + + + +From Memgraph 2.21, to utilize the point index in queries using the point.distance function, the comparison point +needs to exist as a variable first. For example, instead of: +```cypher +MATCH (node:Label) WHERE point.distance(point({x:1, y:1}), node.property) < 1 +RETURN node; +``` +do: +```cypher +WITH point({x:1, y:1}) AS p +MATCH (node:Label) WHERE point.distance(p, node.property) < 1 +RETURN node; +``` + + + +To drop the point index use: +```cypher +DROP POINT INDEX ON :Label(property); +``` + ### Analyze graph When multiple label-property indexes exist, the database can sometimes select a diff --git a/pages/querying/functions.mdx b/pages/querying/functions.mdx index 3cc94dbb..e43273e2 100644 --- a/pages/querying/functions.mdx +++ b/pages/querying/functions.mdx @@ -96,6 +96,13 @@ This section contains the list of supported functions. | `ToEnum` | `ToEnum(value: string) -> (enum)` | Gets enum value matching string of form `name::value`. | | `ToEnum` | `ToEnum(name: string, value: string) -> (enum)` | Gets enum value passing name and value as separate strings. | +### Spatial + + | Name | Signature | Description | + | ----------------- | ----------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | + | [`point`](/fundamentals/data-types#pointparameters-map---null-point) | `point(parameters: map) -> (null\|point)` | Creates a point data type from the given map. | + | [`point.distance`](/fundamentals/data-types#pointdistancex-null-point-y-null-point---null-float) | `point.distance(x: null\|point, y: null\|point) -> (null\|float)` | Returns the distance between two points. | + | [`point.withinbbox`](/fundamentals/data-types#pointwithinbboxpoint-null-point-lower_left_corner-null-point-upper_right_corner-null-point---null-boolean)| `point.withinbbox(point: null\|point, lower_left_corner: null\|point, upper_right_corner: null\|point) -> (null\|boolean)` | Returns whether the given point is contained within the bounding box made from `lower_left_corner` and `upper_right_corner`. | ### Math functions diff --git a/pages/querying/query-plan.mdx b/pages/querying/query-plan.mdx index 0099e6c6..942e0479 100644 --- a/pages/querying/query-plan.mdx +++ b/pages/querying/query-plan.mdx @@ -256,6 +256,7 @@ The following table lists all the operators currently supported by Memgraph: | `ScanAllByLabelProperty` | Produces nodes with a certain label and property. | | `ScanAllByLabelPropertyRange` | Produces nodes with a certain label and property value within the given range (both inclusive and exclusive). | | `ScanAllByLabelPropertyValue` | Produces nodes with a certain label and property value. | +| `ScanAllByPointDistance` | Produces nodes with a certain distance from a given [Point](/fundamentals/data-types#point). | | `SetLabels` | Sets node labels of variable length. | | `SetProperty` | Sets a node or relationship property. | | `SetProperties` | Sets a list of node or relationship properties. | From d8b60014770f4676ed7ec80d2593e781ed80eb1b Mon Sep 17 00:00:00 2001 From: Marko Budiselic Date: Mon, 4 Nov 2024 19:43:13 -0700 Subject: [PATCH 21/31] Update the changelog --- pages/release-notes.mdx | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/pages/release-notes.mdx b/pages/release-notes.mdx index 6df3c57a..a00d09d1 100644 --- a/pages/release-notes.mdx +++ b/pages/release-notes.mdx @@ -243,6 +243,12 @@ labeled with `jepsen`). locks. Coordinator log store needs to be started from scratch, hence this change is a breaking one. [#2430](https://github.com/memgraph/memgraph/pull/2430) +- Fixed deadlock when demoting data instance. When a coordinator sends a + request for promotion or demotion, the lock on replication state is taken so + that it cannot be interleaved with commit. If main became a replica and was + executing write transaction, the transaction will be aborted. Scheduler is + now stopped before thread pool in RPC client. + [#2447](https://github.com/memgraph/memgraph/pull/2447) ### MAGE v1.21.0 From 4beeac24696b181fd9d1a94a4ddadd1d4b68e520 Mon Sep 17 00:00:00 2001 From: Marko Budiselic Date: Mon, 4 Nov 2024 19:56:41 -0700 Subject: [PATCH 22/31] Improve getting building from soruce --- pages/getting-started/build-memgraph-from-source.mdx | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/pages/getting-started/build-memgraph-from-source.mdx b/pages/getting-started/build-memgraph-from-source.mdx index c53c7cf9..3caf7621 100644 --- a/pages/getting-started/build-memgraph-from-source.mdx +++ b/pages/getting-started/build-memgraph-from-source.mdx @@ -118,6 +118,8 @@ Download the toolchain for your operating system from one of the following links - [Ubuntu 20.04](https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v5/toolchain-v5-binaries-ubuntu-20.04-amd64.tar.gz) - [Ubuntu 22.04 (x86_64)](https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v5/toolchain-v5-binaries-ubuntu-22.04-amd64.tar.gz) - [Ubuntu 22.04 (arm64)](https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v5/toolchain-v5-binaries-ubuntu-22.04-arm64.tar.gz) +- [Ubuntu 24.04 (x86_64)](https://s3.eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v5/toolchain-v5-binaries-ubuntu-24.04-amd64.tar.gz) +- [Ubuntu 24.04 (arm64)](https://s3.eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v5/toolchain-v5-binaries-ubuntu-24.04-arm64.tar.gz) Extract the toolchain with the following command: @@ -143,7 +145,12 @@ sudo ./environment/os/install_deps.sh install TOOLCHAIN_RUN_DEPS - Based on your OS, version and architecture, execute appropriate scripts (NOTE: the following commands/scripts are located under [memgraph repository](https://github.com/memgraph/memgraph)): + Based on your OS, version and architecture, execute appropriate scripts (e.g., on Debian 11, NOTE: the following commands/scripts are located under [memgraph repository](https://github.com/memgraph/memgraph)): + + ```bash + sudo ./environment/os/debian-11.sh check TOOLCHAIN_RUN_DEPS + sudo ./environment/os/debian-11.sh install TOOLCHAIN_RUN_DEPS + ``` For ARM look for `-arm` in script name (e.g. on Ubuntu 22.04 with Apple M processor): From e5b7d7bafb5e507f8858fb306d529ca605bbc3ab Mon Sep 17 00:00:00 2001 From: Marko Budiselic Date: Mon, 4 Nov 2024 20:13:53 -0700 Subject: [PATCH 23/31] Improve changelog --- .../build-memgraph-from-source.mdx | 2 +- pages/release-notes.mdx | 24 +++++++++---------- 2 files changed, 13 insertions(+), 13 deletions(-) diff --git a/pages/getting-started/build-memgraph-from-source.mdx b/pages/getting-started/build-memgraph-from-source.mdx index 3caf7621..f4a55af2 100644 --- a/pages/getting-started/build-memgraph-from-source.mdx +++ b/pages/getting-started/build-memgraph-from-source.mdx @@ -147,7 +147,7 @@ sudo ./environment/os/install_deps.sh install TOOLCHAIN_RUN_DEPS Based on your OS, version and architecture, execute appropriate scripts (e.g., on Debian 11, NOTE: the following commands/scripts are located under [memgraph repository](https://github.com/memgraph/memgraph)): - ```bash + ```bash sudo ./environment/os/debian-11.sh check TOOLCHAIN_RUN_DEPS sudo ./environment/os/debian-11.sh install TOOLCHAIN_RUN_DEPS ``` diff --git a/pages/release-notes.mdx b/pages/release-notes.mdx index a00d09d1..ce9cedea 100644 --- a/pages/release-notes.mdx +++ b/pages/release-notes.mdx @@ -17,17 +17,16 @@ informed and prepared. New releases might affect your existing code, queries or configuration. Ensure they're updated to align with the latest updates and changes. - ### Upgrading to Memgraph v2.21.0 breaking change -Coordinator log store directory in `--data-directory` needs to be started from scratch since new type of Raft log is added and some old ones -were deleted. Memgraph could crash without deleting old logs from log store directory. +Coordinator log store directory in `--data-directory` needs to be started from +scratch since new type of Raft log is added and some old ones were deleted. +Memgraph could crash without deleting old logs from log store directory. - ### Upgrading to Memgraph v2.20.0 breaking change @@ -182,9 +181,9 @@ Memgraph (v2.11.1 and lower). - Added planner optimization to replace `point.distance` filter with an index scan. Queries like `WITH point({x:0,y:0}) AS a MATCH (m:L1) WHERE point.distance(m.prop, a) < 1 RETURN m;`, should run faster if there is the - point index created. If you are dealing with spatial data, there is a high - chance you need such indexes to run your queries faster. - [#2362](https://github.com/memgraph/memgraph/pull/2362) + [point index](/fundamentals/indexes#point-index) created. If you are dealing + with spatial data, there is a high chance you need such indexes to run your + queries faster. [#2362](https://github.com/memgraph/memgraph/pull/2362) - Significantly improved schema retrieval performance in both TRANSACTIONAL and ANALYTICAL setups. Feel free to use `--schema-info-enabled=True` to get schema instantly by running the `SHOW SCHEMA INFO;` query. @@ -254,11 +253,12 @@ labeled with `jepsen`). {

New features and improvements

} -- Added Leiden algorithm. The implementation is "static" in a sense that it's - operating on the whole graph. Leiden is a modern community detection - algorithm that in Memgraph's implementation provides hierarchies of - communities. A big use-cases for Leiden community detection is - [GraphRAG](/ai-ecosystem/graph-rag). +- Added [Leiden + algorithm](/advanced-algorithms/available-algorithms/leiden_community_detection). + The implementation is "static" in a sense that it's operating on the whole + graph. Leiden is a modern community detection algorithm that in Memgraph's + implementation provides hierarchies of communities. A big use-cases for + Leiden community detection is [GraphRAG](/ai-ecosystem/graph-rag). [#508](https://github.com/memgraph/mage/pull/508) ## Memgraph v2.20.1 - Oct 10, 2024 From 0ca7b7c62dd39e211ee8bb650c62e280481bef5a Mon Sep 17 00:00:00 2001 From: Marko Budiselic Date: Mon, 4 Nov 2024 20:17:57 -0700 Subject: [PATCH 24/31] Add Debian 12 toolchain link --- pages/getting-started/build-memgraph-from-source.mdx | 2 ++ 1 file changed, 2 insertions(+) diff --git a/pages/getting-started/build-memgraph-from-source.mdx b/pages/getting-started/build-memgraph-from-source.mdx index f4a55af2..daa251c0 100644 --- a/pages/getting-started/build-memgraph-from-source.mdx +++ b/pages/getting-started/build-memgraph-from-source.mdx @@ -115,6 +115,8 @@ Download the toolchain for your operating system from one of the following links - [Fedora 39](https://s3.eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v5/toolchain-v5-binaries-fedora-39-amd64.tar.gz) - [Debian 11 (x86_64)](https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v5/toolchain-v5-binaries-debian-11-amd64.tar.gz) - [Debian 11 (arm64)](https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v5/toolchain-v5-binaries-debian-11-arm64.tar.gz) +- [Debian 12 (x86_64)](https://s3.eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v5/toolchain-v5-binaries-debian-12-amd64.tar.gz) +- [Debian 12 (arm64)](https://s3.eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v5/toolchain-v5-binaries-debian-12-arm64.tar.gz) - [Ubuntu 20.04](https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v5/toolchain-v5-binaries-ubuntu-20.04-amd64.tar.gz) - [Ubuntu 22.04 (x86_64)](https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v5/toolchain-v5-binaries-ubuntu-22.04-amd64.tar.gz) - [Ubuntu 22.04 (arm64)](https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/toolchain-v5/toolchain-v5-binaries-ubuntu-22.04-arm64.tar.gz) From 3198a170897c4c17b3288debe44a8256456705b0 Mon Sep 17 00:00:00 2001 From: katarinasupe Date: Tue, 5 Nov 2024 13:51:40 +0100 Subject: [PATCH 25/31] update changelog titles --- pages/release-notes.mdx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pages/release-notes.mdx b/pages/release-notes.mdx index ce9cedea..23d29c25 100644 --- a/pages/release-notes.mdx +++ b/pages/release-notes.mdx @@ -174,7 +174,7 @@ Memgraph (v2.11.1 and lower). -## Memgraph v2.21.0 and MAGE v1.21.0 - Nov 6, 2024 +## Memgraph v2.21.0 - Nov 6, 2024 {

New features and improvements

} @@ -249,7 +249,7 @@ labeled with `jepsen`). now stopped before thread pool in RPC client. [#2447](https://github.com/memgraph/memgraph/pull/2447) -### MAGE v1.21.0 +## MAGE v1.21.0 - Nov 6, 2024 {

New features and improvements

} From 7bb479d947bc272c6cdd75406423d614b223ef33 Mon Sep 17 00:00:00 2001 From: David Ivekovic Date: Tue, 5 Nov 2024 14:16:01 +0100 Subject: [PATCH 26/31] update algorithm pages (#1020) Co-authored-by: Katarina Supe <61758502+katarinasupe@users.noreply.github.com> --- .../available-algorithms/algo.mdx | 10 +- .../betweenness_centrality.mdx | 4 +- .../biconnected_components.mdx | 4 +- .../bipartite_matching.mdx | 4 +- .../available-algorithms/bridges.mdx | 4 +- .../community_detection.mdx | 24 +- .../community_detection_online.mdx | 22 +- .../available-algorithms/create.mdx | 40 ++- .../available-algorithms/cugraph.mdx | 18 +- .../available-algorithms/cycles.mdx | 4 +- .../degree_centrality.mdx | 8 +- .../distance_calculator.mdx | 8 +- .../elasticsearch_synchronization.mdx | 28 +- .../available-algorithms/export_util.mdx | 20 +- .../gnn_link_prediction.mdx | 24 +- .../gnn_node_classification.mdx | 28 +- .../available-algorithms/graph_analyzer.mdx | 8 +- .../available-algorithms/graph_coloring.mdx | 8 +- .../available-algorithms/graph_util.mdx | 16 +- .../available-algorithms/igraphalg.mdx | 40 ++- .../katz_centrality_online.mdx | 12 +- .../kmeans_clustering.mdx | 8 +- .../available-algorithms/llm_util.mdx | 4 +- .../available-algorithms/max_flow.mdx | 8 +- .../available-algorithms/merge.mdx | 4 +- .../available-algorithms/meta_util.mdx | 4 +- .../available-algorithms/node.mdx | 20 +- .../available-algorithms/node2vec.mdx | 8 +- .../available-algorithms/node2vec_online.mdx | 16 +- .../available-algorithms/node_similarity.mdx | 24 +- .../available-algorithms/nodes.mdx | 16 +- .../available-algorithms/nxalg.mdx | 308 +++++++++++++----- .../available-algorithms/pagerank.mdx | 4 +- .../available-algorithms/pagerank_online.mdx | 12 +- .../available-algorithms/path.mdx | 20 +- .../available-algorithms/refactor.mdx | 64 +++- .../available-algorithms/set_cover.mdx | 8 +- .../available-algorithms/set_property.mdx | 16 +- .../available-algorithms/tgn.mdx | 28 +- .../available-algorithms/tsp.mdx | 4 +- .../available-algorithms/union_find.mdx | 4 +- .../available-algorithms/uuid_generator.mdx | 4 +- .../available-algorithms/vrp.mdx | 4 +- .../weakly_connected_components.mdx | 4 +- .../available-algorithms/xml_module.mdx | 8 +- 45 files changed, 689 insertions(+), 245 deletions(-) diff --git a/pages/advanced-algorithms/available-algorithms/algo.mdx b/pages/advanced-algorithms/available-algorithms/algo.mdx index 0039dd34..7a58746d 100644 --- a/pages/advanced-algorithms/available-algorithms/algo.mdx +++ b/pages/advanced-algorithms/available-algorithms/algo.mdx @@ -42,7 +42,8 @@ filters. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. - `start_node: Node` ➡ The first node of the returned path. - `end_node: Node` ➡ The final node of the returned path. - `relationship_types: List[String]` ➡ A list of relationship filters, explained below. @@ -103,7 +104,9 @@ including any self-referencing relationships. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `nodes: List[Node]` ➡ A list of all the input nodes. {

Output:

} @@ -146,7 +149,8 @@ In case you don't want to use geospatial types, or you want a custom heuristic, {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. - `start: Node` ➡ The starting node. - `target: Node` ➡ The target node. - `config: Map` ➡ The configuration map. diff --git a/pages/advanced-algorithms/available-algorithms/betweenness_centrality.mdx b/pages/advanced-algorithms/available-algorithms/betweenness_centrality.mdx index 446ed9c8..d60f5a7a 100644 --- a/pages/advanced-algorithms/available-algorithms/betweenness_centrality.mdx +++ b/pages/advanced-algorithms/available-algorithms/betweenness_centrality.mdx @@ -52,7 +52,9 @@ The procedure returns the betweenness centrality values. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `directed: boolean (default=True)` ➡ If `False` the direction of the relationships is ignored. - `normalized: boolean (default=True)` ➡ If `True` the betweenness values are normalized by `2/((n-1)(n-2))` for graphs, and `1/((n-1)(n-2))` for directed graphs where diff --git a/pages/advanced-algorithms/available-algorithms/biconnected_components.mdx b/pages/advanced-algorithms/available-algorithms/biconnected_components.mdx index 519f91c6..61d1e080 100644 --- a/pages/advanced-algorithms/available-algorithms/biconnected_components.mdx +++ b/pages/advanced-algorithms/available-algorithms/biconnected_components.mdx @@ -46,7 +46,9 @@ The procedure finds biconnected components. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} diff --git a/pages/advanced-algorithms/available-algorithms/bipartite_matching.mdx b/pages/advanced-algorithms/available-algorithms/bipartite_matching.mdx index 6f8e00a0..c9992a46 100644 --- a/pages/advanced-algorithms/available-algorithms/bipartite_matching.mdx +++ b/pages/advanced-algorithms/available-algorithms/bipartite_matching.mdx @@ -48,7 +48,9 @@ relationship connects nodes between these sets. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} diff --git a/pages/advanced-algorithms/available-algorithms/bridges.mdx b/pages/advanced-algorithms/available-algorithms/bridges.mdx index eadda75b..d9054e7f 100644 --- a/pages/advanced-algorithms/available-algorithms/bridges.mdx +++ b/pages/advanced-algorithms/available-algorithms/bridges.mdx @@ -45,7 +45,9 @@ creates two disjoint graph components. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} diff --git a/pages/advanced-algorithms/available-algorithms/community_detection.mdx b/pages/advanced-algorithms/available-algorithms/community_detection.mdx index ce70b59f..27d0e6c8 100644 --- a/pages/advanced-algorithms/available-algorithms/community_detection.mdx +++ b/pages/advanced-algorithms/available-algorithms/community_detection.mdx @@ -56,10 +56,12 @@ Computes graph communities using the Louvain method. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. -- `weight: string (default=null)` ➡ Specifies the default relationship weight. If not set, - the algorithm uses the `weight` relationship attribute when present and otherwise - treats the graph as unweighted. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + +- `weight: string (default=null)` ➡ Specifies the name of the property containing the edge weight. Users can set their own weight property; +if this property is not specified, the algorithm uses the `weight` edge attribute by default. If neither is set, each edge's weight defaults to `1`. +To utilize a custom weight property, the user must set the `--storage-properties-on-edges=true` flag. - `coloring: boolean (default=False)` ➡ If set, use the graph coloring heuristic for effective parallelization. - `min_graph_shrink: integer (default=100000)` ➡ The graph coarsening optimization stops upon shrinking the graph to this many nodes. - `community_alg_threshold: double (default=0.000001)` ➡ Controls how long the algorithm iterates. When the gain in modularity @@ -72,7 +74,7 @@ Computes graph communities using the Louvain method. {

Output:

} -- `node: Vertex` ➡ Graph node. +- `node: Vertex` ➡ A graph node for which the algorithm was performed and returned as part of the results. - `community_id: integer` ➡ Community ID. Defaults to $-1$ if the node does not belong to any community. {

Usage:

} @@ -90,12 +92,14 @@ Computes graph communities over a subgraph using the Louvain method. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `subgraph_nodes: List[Node]` ➡ List of nodes in the subgraph. - `subgraph_relationships: List[Relationship]` ➡ List of relationships in the subgraph. -- `weight: str (default=null)` ➡ Specifies the default relationship weight. If not set, - the algorithm uses the `weight` relationship attribute when present and otherwise - treats the graph as unweighted. +- `weight: string (default=null)` ➡ Specifies the name of the property containing the edge weight. Users can set their own weight property; +if this property is not specified, the algorithm uses the `weight` edge attribute by default. If neither is set, each edge's weight defaults to `1`. +To utilize a custom weight property, the user must set the `--storage-properties-on-edges=true` flag. - `coloring: bool (default=False)` ➡ If set, use the graph coloring heuristic for effective parallelization. - `min_graph_shrink: int (default=100000)` ➡ The graph coarsening optimization stops upon shrinking the graph to this many nodes. - `community_alg_threshold: double (default=0.000001)` ➡ Controls how long the algorithm iterates. When the gain in modularity @@ -108,7 +112,7 @@ Computes graph communities over a subgraph using the Louvain method. {

Output:

} -- `node: Vertex` ➡ Graph node. +- `node: Vertex` ➡ A graph node for which the algorithm was performed and returned as part of the results. - `community_id: int` ➡ Community ID. Defaults to $-1$ if the node does not belong to any community. {

Usage:

} diff --git a/pages/advanced-algorithms/available-algorithms/community_detection_online.mdx b/pages/advanced-algorithms/available-algorithms/community_detection_online.mdx index 3b18fffe..6f713122 100644 --- a/pages/advanced-algorithms/available-algorithms/community_detection_online.mdx +++ b/pages/advanced-algorithms/available-algorithms/community_detection_online.mdx @@ -65,7 +65,9 @@ the user should check if that is indeed the case. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `directed: boolean (default=False)` ➡ Specifies whether the graph is directed. If not set, the graph is treated as undirected. - `weighted: boolean (default=False)` ➡ Specifies whether the graph is weighted. If not set, @@ -88,7 +90,7 @@ the user should check if that is indeed the case. {

Output:

} -- `node: Vertex` ➡ Graph node. +- `node: Vertex` ➡ A graph node for which the algorithm was performed and returned as part of the results. - `community_id: integer` ➡ Community ID. If the node is not associated with any community, defaults to $-1$. @@ -108,11 +110,13 @@ are none, defaults to calling `set()` with default parameters. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} -- `node: Vertex` ➡ Graph node. +- `node: Vertex` ➡ A graph node for which the algorithm was performed and returned as part of the results. - `community_id: integer` ➡ Community ID. Defaults to $-1$ if the node does not belong to any community. {

Usage:

} @@ -131,7 +135,9 @@ changes applied in the latest graph update and returns the results. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `createdVertices: mgp.List[mgp.Vertex]` ➡ Nodes created in the latest graph update. - `createdEdges: mgp.List[mgp.Edge]` ➡ Relationships created in the latest graph update. @@ -144,7 +150,7 @@ changes applied in the latest graph update and returns the results. {

Output:

} -- `node: Vertex` ➡ Graph node. +- `node: Vertex` ➡ A graph node for which the algorithm was performed and returned as part of the results. - `community_id: integer` ➡ Community ID. If the node is not associated with any community, defaults to $-1$. @@ -182,7 +188,9 @@ Resets the algorithm to its initial state. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} diff --git a/pages/advanced-algorithms/available-algorithms/create.mdx b/pages/advanced-algorithms/available-algorithms/create.mdx index c3050da1..32e9aadd 100644 --- a/pages/advanced-algorithms/available-algorithms/create.mdx +++ b/pages/advanced-algorithms/available-algorithms/create.mdx @@ -43,7 +43,9 @@ and sent as a list or map. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `label: List[string]` ➡ A list of all the labels to be added to the new node. - `props: Map` ➡ A map with key/value pairs to be added as new node's properties. @@ -86,7 +88,9 @@ Create nodes with given labels and properties. For each property map, a separate {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `label: List[string]` ➡ A list with labels of the new nodes. - `props: List[Map]` ➡ A list of property maps for new nodes, for each map, a separate node is created. @@ -145,7 +149,9 @@ thrown. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `nodes: any` ➡ Input node(s) - can be a node, node's ID, or a list of nodes and IDs. - `key: string` ➡ The name of the property which is about to be set. - `value: any` ➡ The new value of the property. @@ -200,7 +206,9 @@ Adds the provided properties to the node(s). {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `input_nodes: Any` ➡ Input node(s) - can be a node, node's ID, or a list of nodes and IDs. - `input_keys: List[string]` ➡ A list of all the property keys to be added to the node(s). - `input_values: List[Any]` ➡ A list of all the corresponding property values to be added to the node(s). @@ -261,7 +269,9 @@ thrown. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `nodes: any` ➡ Input node(s) - can be a node, node's ID, or a list of nodes and IDs. - `keys: List[string]` ➡ A list of properties which are to be removed. @@ -312,7 +322,9 @@ Adds the provided property to the relationship(s). {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `input_rel: Any` ➡ Input relationship(s) - can be a relationship, elationship's ID, or a list of relationships and IDs. - `input_key: string` ➡ Property key that needs to be added to the relationship(s). - `input_value: Any` ➡ The corresponding property value that needs to be added to the relationship(s). @@ -357,7 +369,9 @@ Removes the provided labels from the node(s). {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `nodes: Any` ➡ Input node(s) - can be a node, node's ID or a list of nodes and nodes' IDs. - `label: List[string]` ➡ A list of labels to be removed (if exist) from the nodes(s). @@ -402,7 +416,9 @@ to. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `from: Node` ➡ The tail node. - `relationshipType: string` ➡ The relationship type. - `properties: Map` ➡ Properties of the new relationship(s). @@ -451,7 +467,9 @@ relationships. If the property already exists it is modified. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `relationships: int|Relationship|List[int|Relationship]` ➡ Relationships that need to be modified are indicated using their object or ID. - `keys: List[string]` ➡ A list of all the property keys that need to be added to the relationship(s). - `values: List[Any]` ➡ A list of all the corresponding property values that need to be added to the relationship(s). @@ -503,7 +521,9 @@ nothing happens. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `relationships: int|Relationship|List[int|Relationship]` ➡ Relationships that need to be modified. - `keys: List[string]` ➡ A list of property names that need to be removed from the given relationships. diff --git a/pages/advanced-algorithms/available-algorithms/cugraph.mdx b/pages/advanced-algorithms/available-algorithms/cugraph.mdx index 7cafb218..69d92b3d 100644 --- a/pages/advanced-algorithms/available-algorithms/cugraph.mdx +++ b/pages/advanced-algorithms/available-algorithms/cugraph.mdx @@ -64,7 +64,7 @@ Procedure for finding the balanced cut clustering of the graph’s nodes. {

Output:

} -- `node: Vertex` ➡ Graph node. +- `node: Vertex` ➡ A graph node for which the algorithm was performed and returned as part of the results. - `cluster: integer` ➡ Cluster of a node. {

Usage:

} @@ -91,7 +91,7 @@ Procedure for finding betweenness centrality scores for all nodes in the graph. {

Output:

} -- `node: Vertex` ➡ Graph node. +- `node: Vertex` ➡ A graph node for which the algorithm was performed and returned as part of the results. - `betweenness_centrality: float` ➡ Betweenness centrality score of a node. {

Usage:

} @@ -164,7 +164,7 @@ graphs. {

Output:

} -- `node: Vertex` ➡ Graph node. +- `node: Vertex` ➡ A graph node for which the algorithm was performed and returned as part of the results. - `hubs: float` ➡ Hub value of a node. - `authorities: float` ➡ Authority value of a node. @@ -197,7 +197,7 @@ Find Katz centrality scores for all nodes in the graph. {

Output:

} -- `node: Vertex` ➡ Graph node. +- `node: Vertex` ➡ A graph node for which the algorithm was performed and returned as part of the results. - `katz_centrality: float` ➡ Katz centrality score of a node. {

Usage:

} @@ -223,7 +223,7 @@ Partition the graph into communities using the Leiden method. {

Output:

} -- `node: Vertex` ➡ Graph node. +- `node: Vertex` ➡ A graph node for which the algorithm was performed and returned as part of the results. - `partition: integer` ➡ Partition of a node. {

Usage:

} @@ -250,7 +250,7 @@ Partition the graph into communities using the Louvain method. {

Output:

} -- `node: Vertex` ➡ Graph node. +- `node: Vertex` ➡ A graph node for which the algorithm was performed and returned as part of the results. - `partition: integer` ➡ Partition of a node. {

Usage:

} @@ -284,7 +284,7 @@ Find PageRank scores for all nodes in the graph. {

Output:

} -- `node: Vertex` ➡ Graph node. +- `node: Vertex` ➡ A graph node for which the algorithm was performed and returned as part of the results. - `pagerank: float` ➡ PageRank score of a node. {

Usage:

} @@ -322,7 +322,7 @@ Find personalized PageRank scores for all nodes in the graph. {

Output:

} -- `node: Vertex` ➡ Graph node. +- `node: Vertex` ➡ A graph node for which the algorithm was performed and returned as part of the results. - `pagerank: float` ➡ PageRank score of a node. {

Usage:

} @@ -356,7 +356,7 @@ Find the spectral clustering of the graph’s nodes. {

Output:

} -- `node: Vertex` ➡ Graph node. +- `node: Vertex` ➡ A graph node for which the algorithm was performed and returned as part of the results. - `cluster: integer` ➡ Cluster of a node. {

Usage:

} diff --git a/pages/advanced-algorithms/available-algorithms/cycles.mdx b/pages/advanced-algorithms/available-algorithms/cycles.mdx index a0a29a9f..e7b8993e 100644 --- a/pages/advanced-algorithms/available-algorithms/cycles.mdx +++ b/pages/advanced-algorithms/available-algorithms/cycles.mdx @@ -48,7 +48,9 @@ You can execute this algorithm on [graph projections, subgraphs or portions of t {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} diff --git a/pages/advanced-algorithms/available-algorithms/degree_centrality.mdx b/pages/advanced-algorithms/available-algorithms/degree_centrality.mdx index 4afe662b..9faa5725 100644 --- a/pages/advanced-algorithms/available-algorithms/degree_centrality.mdx +++ b/pages/advanced-algorithms/available-algorithms/degree_centrality.mdx @@ -49,7 +49,9 @@ The procedure calculates the degree centrality for each node in the graph. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `type: string (default="undirected")` ➡ Defines whether the procedure is using "in", "out", or "undirected" relationships. @@ -73,7 +75,9 @@ The procedure calculates degree centrality for each node of the given subgraph. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `nodes: list[node]` ➡ Nodes that will be used in the algorithm. - `relationships: list[relationship]` ➡ Relationships that will be considered for degree calculation. diff --git a/pages/advanced-algorithms/available-algorithms/distance_calculator.mdx b/pages/advanced-algorithms/available-algorithms/distance_calculator.mdx index b648321d..6bea3f8c 100644 --- a/pages/advanced-algorithms/available-algorithms/distance_calculator.mdx +++ b/pages/advanced-algorithms/available-algorithms/distance_calculator.mdx @@ -48,7 +48,9 @@ Measures a distance from the start node to the end node. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `start: Vertex` ➡ Starting point to measure distance. Required to have `lng` and `lat` properties. * `end: Vertex` ➡ Ending point to measure distance. Required to have `lng` and `lat` properties. * `metrics: string` ➡ Can be either "m" or "km". These stand for meters and kilometers respectively. @@ -78,7 +80,9 @@ the nodes from an end list. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `start_points: List[Vertex]` ➡ Starting points to measure distance collected in a list. Required to have `lng` and `lat` properties. Must be of the same size as `end_points`. * `end_points: List[Vertex]` ➡ Ending points to measure distance collected in a list. Required to have `lng` and `lat` properties. Must be of the same size as `start_points`. * `metrics: string` ➡ Can be either "m" or "km". These stand for metres and kilometres respectively. diff --git a/pages/advanced-algorithms/available-algorithms/elasticsearch_synchronization.mdx b/pages/advanced-algorithms/available-algorithms/elasticsearch_synchronization.mdx index 3b7f5a94..13989744 100644 --- a/pages/advanced-algorithms/available-algorithms/elasticsearch_synchronization.mdx +++ b/pages/advanced-algorithms/available-algorithms/elasticsearch_synchronization.mdx @@ -74,7 +74,9 @@ certificate**. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `elastic_url: string` -> URL for connecting to the Elasticsearch instance. - `ca_certs: string` -> Path to the certificate file. - `elastic_user: string` -> The user trying to connect to Elasticsearch. @@ -100,7 +102,9 @@ The procedure used for creating Elasticsearch indexes. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `index_name: string` -> Name of the index that needs to be created. - `schema_path: string` -> Path to the schema from where the index will be loaded. - `schema_parameters: Dict[string, Any]` @@ -134,7 +138,9 @@ documents. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `node_index: string` -> The name of the **node index**. Can be used for both **streaming and parallel bulk**. - `edge_index: string` -> The name of the **edge index**. Can be used for both **streaming and parallel bulk**. - `thread_count: int` -> **Size of the threadpool** to use for the bulk requests. @@ -171,7 +177,9 @@ it shouldn't be called by a user explicitly. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `createdObjects: List[Dict[string, Object]]` -> Objects that are captured by a create trigger. - `node_index: string` -> The name of the **node index**. Can be used for both **streaming and parallel bulk**. - `edge_index: string` -> The name of the **edge index**. Can be used for both **streaming and parallel bulk**. @@ -210,7 +218,9 @@ specified differently, all documents will be reindexed. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `updatatedObjects: List[Dict[string, Any]]` -> List of all objects that **were updated and then sent as arguments to this procedure** with the help of the update trigger. - `source_index: Union[string, List[string]])` -> Identifies **source index (or more of them)** from where documents need to be indexed. - `target_index: string` -> Identifies **target index** to where documents need to be indexed. @@ -240,7 +250,9 @@ query. Supports pagination. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `index_name: string` -> Name of the index. - `query: string` -> Query written as JSON. - `scroll: int` -> Specifies how long **a consistent view** of the index should be maintained for scrolled search. @@ -279,7 +291,9 @@ aggregations. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `index_name: string` -> A name of the index. - `query: string` -> Query written as JSON. - `size: int` -> Size (per shard) of the batch sent at each iteration. diff --git a/pages/advanced-algorithms/available-algorithms/export_util.mdx b/pages/advanced-algorithms/available-algorithms/export_util.mdx index 3df56e5f..674ae302 100644 --- a/pages/advanced-algorithms/available-algorithms/export_util.mdx +++ b/pages/advanced-algorithms/available-algorithms/export_util.mdx @@ -46,7 +46,9 @@ The procedure exports the graph database to a local file. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `path: string` ➡ Path to the JSON file containing the exported graph database. - `config: Map` ➡ Map of the configuration with the following keys: - `stream: boolean (default=False)` ➡ Is the data exported to a stream rather than a file. @@ -117,7 +119,9 @@ Exports the given nodes and relationships to the JSON format. All nodes from the {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `nodes: List[Node]` ➡ The list of nodes that need to be exported. - `relationships: List[Relationship]` ➡ The list of relationships that need to be exported. - `path: string` ➡ The path to the JSON file containing the exported data. @@ -137,7 +141,9 @@ stream. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `path: string` ➡ The path to the Cypher file containing the exported graph database. - `config: Map` ➡ The map of the configuration with the following keys: - `stream: boolean (default= False)` ➡ Is the data exported to a stream rather than a file. @@ -157,7 +163,9 @@ The procedure exports query results to a CSV file. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `query: string` ➡ The query from which the results will be saved to a CSV file. - `file_path: string` ➡ The path to the CSV file where the query results will be exported. - `stream: boolean (default=False)` ➡ Will the procedure return a stream of query results in CSV format rather than a file. @@ -229,7 +237,9 @@ file. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `nodes_list: List[Node]` ➡ The list of nodes that will be exported. - `relationships_list: List[Relationship]` ➡ The list of relationships that will be exported. - `path: string (default="./exported_file.csv")` ➡ The path where the exported file will be saved, ending with the filename, for example, `folder_outer/folder/file.csv`. diff --git a/pages/advanced-algorithms/available-algorithms/gnn_link_prediction.mdx b/pages/advanced-algorithms/available-algorithms/gnn_link_prediction.mdx index d3fc5ec7..7a145724 100644 --- a/pages/advanced-algorithms/available-algorithms/gnn_link_prediction.mdx +++ b/pages/advanced-algorithms/available-algorithms/gnn_link_prediction.mdx @@ -206,7 +206,9 @@ The `train` procedure is used to train a model and it doesn't take any input par {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -232,7 +234,9 @@ from the last training. The results are in the same format as the results of the {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -259,7 +263,9 @@ edge between two vertices and the user wants to check the model’s evaluation. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `src_vertex: mgp.Vertex` -> Source vertex of the edge. - `dest_vertex: mgp.Vertex` -> Destination vertex of the edge. @@ -292,7 +298,9 @@ example.) {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `src_vertex: mgp.Vertex` → Source node. - `dest_vertices: List[mgp.Vertex]` → Destination nodes. If they are not of the same type, an exception is thrown. - `k: int` → Number of edges to recommend. @@ -324,7 +332,9 @@ context will be loaded from the default parameter specified in the {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `path: str` → Path to the folder where the model and the predictor are saved. {

Output:

} @@ -349,7 +359,9 @@ implementation reasons. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} diff --git a/pages/advanced-algorithms/available-algorithms/gnn_node_classification.mdx b/pages/advanced-algorithms/available-algorithms/gnn_node_classification.mdx index 8df46a58..9166b32c 100644 --- a/pages/advanced-algorithms/available-algorithms/gnn_node_classification.mdx +++ b/pages/advanced-algorithms/available-algorithms/gnn_node_classification.mdx @@ -85,7 +85,9 @@ place. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `params: (mgp.Map, optional)`: User defined parameters from query module. Defaults to {}. | Name | Type | Default | Description | @@ -139,7 +141,9 @@ model, optimizer, and criterion. Afterward, it performs training. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `num_epochs (int, optional)` ➡ Number of epochs (default:100). {

Output:

} @@ -166,7 +170,9 @@ Use the `get_training_data()` procedure to get logged data from training. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -192,7 +198,9 @@ are already 5 models in the directory, the oldest model is deleted. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -215,7 +223,9 @@ This `load_model()` procedure loads the model from the specified folder. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `num (int, optional)` ➡ Ordinal number of model to load from the default path on the disc (default: 0, i.e., newest model). {

Output:

} @@ -240,7 +250,9 @@ validation process. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `vertex: mgp.Vertex`➡ Prediction node. {

Output:

} @@ -263,7 +275,9 @@ This function resets all variables to default values. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} diff --git a/pages/advanced-algorithms/available-algorithms/graph_analyzer.mdx b/pages/advanced-algorithms/available-algorithms/graph_analyzer.mdx index 5ff29fe1..395ae725 100644 --- a/pages/advanced-algorithms/available-algorithms/graph_analyzer.mdx +++ b/pages/advanced-algorithms/available-algorithms/graph_analyzer.mdx @@ -62,7 +62,9 @@ The procedure analyzes the graph and returns information. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `analyses: List[string] (default=NULL)` ➡ List of analytics names to be fetched. If provided with NULL, the whole set of analytics will be included. {

Output:

} @@ -86,7 +88,9 @@ The procedure analyzes a subgraph and returns information. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `vertices: List[Vertex]` ➡ Subset of vertices within a graph. - `edges: List[Edge]` ➡ Subset of relationships in a graph for which analytics will take place. - `analyses: List[string] (default=NULL)` ➡ List of analytics names to be fetched. If provided with NULL, the whole set of analytics will be included. diff --git a/pages/advanced-algorithms/available-algorithms/graph_coloring.mdx b/pages/advanced-algorithms/available-algorithms/graph_coloring.mdx index ea8c2eb5..79b7b580 100644 --- a/pages/advanced-algorithms/available-algorithms/graph_coloring.mdx +++ b/pages/advanced-algorithms/available-algorithms/graph_coloring.mdx @@ -65,7 +65,9 @@ connected with a relationship don’t have the same color. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `parameters: Dict[string, Any] (default={})` ➡ A dictionary that specifies the algorithm configuration by listing [parameters](#parameters). - `edge_property: string (default=weight)` ➡ Relationship property that stores the relationship weight. Any relationship attribute not present defaults to 1. @@ -90,7 +92,9 @@ connected with a relationship don’t have the same color. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `vertices: List[Vertex]` ➡ List of vertices in the subgraph. - `edges: List[Edge]` ➡ List of relationships in the subgraph. - `parameters: Dict[string, Any] (default={})` ➡ A dictionary that specifies the algorithm configuration by listing [parameters](#parameters). diff --git a/pages/advanced-algorithms/available-algorithms/graph_util.mdx b/pages/advanced-algorithms/available-algorithms/graph_util.mdx index 1dcab12f..fde07c01 100644 --- a/pages/advanced-algorithms/available-algorithms/graph_util.mdx +++ b/pages/advanced-algorithms/available-algorithms/graph_util.mdx @@ -43,7 +43,9 @@ which there is a path to the input node. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `node: Vertex` ➡ The node you want to find ancestors for. {

Output:

} @@ -69,7 +71,9 @@ gets the relationship type from the second input parameter `edge_type`. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `nodes: List[Vertex]` ➡ List of nodes between which we want to create corresponding relationships. - `edge_type: String` ➡ The name of the relationship that will be created between nodes. @@ -97,7 +101,9 @@ Typically used to create a subgraph from returned nodes. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `nodes: List[Vertex]` ➡ List of nodes for which we want to find corresponding connections, i.e., relationships between them. {

Output:

} @@ -123,7 +129,9 @@ with an existing path from the input node. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `node: Vertex` ➡ The node for which we want to find descendants. diff --git a/pages/advanced-algorithms/available-algorithms/igraphalg.mdx b/pages/advanced-algorithms/available-algorithms/igraphalg.mdx index c2b2768f..3c16f95c 100644 --- a/pages/advanced-algorithms/available-algorithms/igraphalg.mdx +++ b/pages/advanced-algorithms/available-algorithms/igraphalg.mdx @@ -53,7 +53,9 @@ is a path with no repeated nodes. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `v: Vertex` ➡ Path's starting node. - `to: Vertex` ➡ Path's ending node. - `cutoff: int (default=-1)` ➡ Maximum length of the considered path. If negative, paths of all lengths are considered. @@ -80,7 +82,9 @@ A *minimum spanning tree* is a subset of the relationships of a connected graph {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `weights: string (default=NULL)` ➡ Property used for relationship weights. - `directed: bool (default=False)` ➡ If `True` the graph is directed, otherwise it's undirected. @@ -106,7 +110,9 @@ PageRank computes a ranking of the nodes in graph G based on the structure of th {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `damping: double (default=0.85)` ➡ Damping parameter for PageRank. - `weights: string (default="weight")` ➡ Property used as a weight. If `None`, weights are set to 1. - `directed: bool (default=True)` ➡ If `True` the graph is directed, otherwise it's undirected. @@ -135,7 +141,9 @@ Compute the shortest path in the graph. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `source: Vertex (default=NULL)` ➡ Path's starting node. - `target: Vertex (default=NULL)` ➡ Path's ending node. - `weights: string (default=NULL)` ➡ If `None`, every relationship has @@ -166,7 +174,9 @@ Compute the shortest path length in the graph. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `source: Vertex (default=NULL)` ➡ Path's starting node. - `target: Vertex (default=NULL)` ➡ Path's ending node. - `weights: string (default=NULL)` ➡ If `None`, every relationship has @@ -200,7 +210,9 @@ that `u` appears before `v` in the topological sort order. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `mode: string (default="out")` ➡ Specifies how to use the direction of the relationships. For `out`, the sorting order ensures that each node comes before all nodes to which it has relationships, so nodes with no incoming @@ -228,7 +240,9 @@ The maximum flow problem consists of finding a flow through a graph such that it {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `source: Vertex` ➡ Source node from which the maximum flow is calculated. - `target: Vertex` ➡ Sink node to which the max flow is calculated. - `capacity: string (default="weight")` ➡ Relationship property which is used as the flow capacity of the relationship. @@ -254,7 +268,9 @@ Minimum cut calculates the minimum st-cut between two vertices in a graph. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `source: Vertex` ➡ Source node from which the minimum cut is calculated. - `target: Vertex` ➡ Sink node to which the minimum cut is calculated. - `capacity: string (default="weight")` ➡ Relationship property which is used as the capacity of the relationship. @@ -283,7 +299,9 @@ Finding community structure of a graph using the Leiden algorithm of Traag, van {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `objective_function: string (default="CPM")` ➡ Whether to use the Constant Potts Model (CPM) or modularity. Must be either `CPM` or `modularity`. - `weights: string (default=NULL)` ➡ If a string is present, use this property @@ -322,7 +340,9 @@ Compute all shortest path lengths in the graph. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `weights: string (default=NULL)` ➡ If `None`, every relationship has weight/distance/cost 1. If the value is a property name, use that property as the relationship weight. If a relationship doesn't have a property, the value diff --git a/pages/advanced-algorithms/available-algorithms/katz_centrality_online.mdx b/pages/advanced-algorithms/available-algorithms/katz_centrality_online.mdx index f3560959..e992200d 100644 --- a/pages/advanced-algorithms/available-algorithms/katz_centrality_online.mdx +++ b/pages/advanced-algorithms/available-algorithms/katz_centrality_online.mdx @@ -75,7 +75,9 @@ Use the procedure to calculate Katz Centrality. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `alpha: double (default=0.2)` ➡ Exponential decay factor defining the walk length importance. - `epsilon: double (default=1e-2)` ➡ Convergence tolerance. Minimal difference in two @@ -103,7 +105,9 @@ procedure has been called before adding changes to the graph. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -126,7 +130,9 @@ The procedure is used to update the Katz Centrality values. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `created_vertices` ➡ Vertices (nodes) that were created in the last transaction. - `created_edges` ➡ Edges (relationships) created in a period from the last transaction. - `deleted_vertices` ➡ Vertices (nodes) deleted from the last transaction. diff --git a/pages/advanced-algorithms/available-algorithms/kmeans_clustering.mdx b/pages/advanced-algorithms/available-algorithms/kmeans_clustering.mdx index 13714263..d53ce5b8 100644 --- a/pages/advanced-algorithms/available-algorithms/kmeans_clustering.mdx +++ b/pages/advanced-algorithms/available-algorithms/kmeans_clustering.mdx @@ -52,7 +52,9 @@ For each node, the `get_clusters()` procedure returns what cluster it belongs to {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `n_clusters : int` ➡ Number of clusters to be formed. - `embedding_property : str (default: "embedding")` ➡ Node property where embeddings are stored. - `init : str (default: "k-means")` ➡ Initialization method. If `k-means++` is selected, initial cluster centroids are sampled per an empirical probability distribution of the points’ contribution to the overall inertia. This technique speeds up convergence and is theoretically proven to be `O(logk)`-optimal. @@ -84,7 +86,9 @@ The `set_clusters()` procedure sets to which cluster each node it belongs to by {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `n_clusters : int` ➡ Number of clusters to be formed. - `embedding_property : str (default: "embedding")` ➡ Node property where embeddings are stored. - `cluster_property: str (default: "cluster_id")` ➡ Node property where `cluster_id` will be stored. diff --git a/pages/advanced-algorithms/available-algorithms/llm_util.mdx b/pages/advanced-algorithms/available-algorithms/llm_util.mdx index 7c0bc015..9d5ca018 100644 --- a/pages/advanced-algorithms/available-algorithms/llm_util.mdx +++ b/pages/advanced-algorithms/available-algorithms/llm_util.mdx @@ -45,7 +45,9 @@ schema in a format that can be customized for later use with LLMs. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `output_type: str (default='prompt_ready')` ➡ By default, the graph schema will include additional context and it will be prompt-ready. If set to 'raw', it will produce a simpler version that can be adjusted for the prompt. The diff --git a/pages/advanced-algorithms/available-algorithms/max_flow.mdx b/pages/advanced-algorithms/available-algorithms/max_flow.mdx index 60573fe9..5f01436a 100644 --- a/pages/advanced-algorithms/available-algorithms/max_flow.mdx +++ b/pages/advanced-algorithms/available-algorithms/max_flow.mdx @@ -71,7 +71,9 @@ Use the `get_flow()` procedure to calculate the maximum flow. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `start_v: Vertex` ➡ Source node from which the maximum flow is calculated. - `end_v: Vertex` ➡ Sink node to which the max flow is calculated. - `edge_property: string (default="weight")` ➡ Relationship property which is used as the flow @@ -98,7 +100,9 @@ The `get_paths()` procedure returns paths that are a part of the flow with the m {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `start_v: Vertex` ➡ Source node from which the maximum flow is calculated. - `end_v: Vertex` ➡ Sink node to which the max flow is calculated. - `edge_property: string (default="weight")` ➡ Relationship property which is used as the flow diff --git a/pages/advanced-algorithms/available-algorithms/merge.mdx b/pages/advanced-algorithms/available-algorithms/merge.mdx index 09b1a3ec..c4b93e99 100644 --- a/pages/advanced-algorithms/available-algorithms/merge.mdx +++ b/pages/advanced-algorithms/available-algorithms/merge.mdx @@ -42,7 +42,9 @@ and sent as a list or map. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `labels: List[string]` ➡ A list of all labels that need to be added to the new node. - `identProps: Map` ➡ A map with key-value pairs used for identifying which nodes will be merged. - `createProps: Map` ➡ A map with key-value pairs which represent properties of the node, when the procedure creates a new node. diff --git a/pages/advanced-algorithms/available-algorithms/meta_util.mdx b/pages/advanced-algorithms/available-algorithms/meta_util.mdx index ef54c55c..e34516a3 100644 --- a/pages/advanced-algorithms/available-algorithms/meta_util.mdx +++ b/pages/advanced-algorithms/available-algorithms/meta_util.mdx @@ -49,7 +49,9 @@ distinct nodes, that is, a graph schema. If `include_properties` is set to {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `include_properties: bool (default=false)` ➡ If set to `true`, the graph schema will include properties count information. {

Output:

} diff --git a/pages/advanced-algorithms/available-algorithms/node.mdx b/pages/advanced-algorithms/available-algorithms/node.mdx index 3ea41d08..6289e5f9 100644 --- a/pages/advanced-algorithms/available-algorithms/node.mdx +++ b/pages/advanced-algorithms/available-algorithms/node.mdx @@ -44,7 +44,9 @@ all distinct relationship types. Relationship types can also be directed: {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `node: Node` ➡ The given node. - `types: List[string] (default = [])` ➡ A list of relationship types to filter by. @@ -94,7 +96,9 @@ The procedure checks if the given node has a relationship of a specific type. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `node: Node` ➡ The target node for which the existance of a relationship type is verified. - `pattern: List[string] (optional)` ➡ A list of relationship types that need to be checked. If the input parameter is empty, procedure will check all types of relationships. @@ -152,7 +156,9 @@ provided below: {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `node: Node` ➡ The target node for which the existance of relationship types is verified. - `relationships: List[string]` ➡ A list of relationship types that need to be checked. If the input parameter is empty, procedure will check all types of @@ -220,7 +226,9 @@ node degree. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `node: Node` ➡ The input node. - `type: string, default = ""` ➡ Optionally, you can define the relationship type which will be counted for degree calculation. @@ -280,7 +288,9 @@ node degree. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `node: Node` ➡ The input node. - `type: string, default = ""` ➡ Optionally, you can define the relationship type which will be counted for degree calculation. diff --git a/pages/advanced-algorithms/available-algorithms/node2vec.mdx b/pages/advanced-algorithms/available-algorithms/node2vec.mdx index c82ea3de..701a2df6 100644 --- a/pages/advanced-algorithms/available-algorithms/node2vec.mdx +++ b/pages/advanced-algorithms/available-algorithms/node2vec.mdx @@ -98,7 +98,9 @@ The procedure returns calculated embeddings and the corresponding list of embedd {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `is_directed : boolean` ➡ If `True`, graph is treated as directed, otherwise it's treated as undirected - `p : float` ➡ Return hyperparameter for calculating transition probabilities. @@ -148,7 +150,9 @@ with the embedding values and returns the corresponding list of embeddings. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `is_directed : boolean` ➡ If `True`, graph is treated as directed, else not directed - `p : float` ➡ Return hyperparameter for calculating transition probabilities. diff --git a/pages/advanced-algorithms/available-algorithms/node2vec_online.mdx b/pages/advanced-algorithms/available-algorithms/node2vec_online.mdx index b2481840..309a6fd3 100644 --- a/pages/advanced-algorithms/available-algorithms/node2vec_online.mdx +++ b/pages/advanced-algorithms/available-algorithms/node2vec_online.mdx @@ -107,7 +107,9 @@ Use the procedure to sample the temporal random walks in the graph. Once the {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `half_life: integer` ➡ Half-life [seconds], used in the temporal walk probability calculation. - `max_length: integer` ➡ The maximum length of the sampled temporal random walks. @@ -140,7 +142,9 @@ the parameters. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `embedding_dimension: integer` ➡ The number of dimensions in the representation of the embedding vector. - `learning_rate: float` ➡ The learning rate. @@ -169,7 +173,9 @@ Use the `udpate()` procedure to (re)calculate embeddings. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `edges: mgp.List[mgp.Edge]` ➡ A list of relationships added to the graph. Embeddings will be (re)calculated only for the starting and ending nodes of those new relationships. @@ -203,7 +209,9 @@ The `get()` procedure returns the node embeddings. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} diff --git a/pages/advanced-algorithms/available-algorithms/node_similarity.mdx b/pages/advanced-algorithms/available-algorithms/node_similarity.mdx index 186bc5bc..73a0a69a 100644 --- a/pages/advanced-algorithms/available-algorithms/node_similarity.mdx +++ b/pages/advanced-algorithms/available-algorithms/node_similarity.mdx @@ -71,7 +71,9 @@ The following procedure will calculate the Jaccard similarity between all pairs {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -95,7 +97,9 @@ account pairwise similarities between two set of nodes. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `src_nodes: List[Vertex]` ➡ The first set of nodes. - `dst_nodes: List[Vertex]` ➡ The second set of nodes. @@ -127,7 +131,9 @@ The following procedure will calculate the overlap similarity between all pairs {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -151,7 +157,9 @@ account pairwise similarities between two set of nodes. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `src_nodes: List[Vertex]` ➡ The first set of nodes. - `dst_nodes: List[Vertex]` ➡ The second set of nodes. @@ -183,7 +191,9 @@ The following procedure will calculate the cosine similarity between all pairs o {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `node1: Vertex` ➡ The first node. - `node2: Vertex` ➡ The second node. - `property: str` ➡ The property based on which the cosine similarity will be calculated. If the property is not of the vector type, the error will be thrown. @@ -210,7 +220,9 @@ similarities between two set of nodes. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `src_nodes: List[Vertex]` ➡ The first set of nodes. - `dst_nodes: List[Vertex]` ➡ The second set of nodes. - `property: str` ➡ The property based on which the cosine similarity will be calculated. If the property is not of the vector type, the error will be thrown. diff --git a/pages/advanced-algorithms/available-algorithms/nodes.mdx b/pages/advanced-algorithms/available-algorithms/nodes.mdx index 942c3f50..58168eac 100644 --- a/pages/advanced-algorithms/available-algorithms/nodes.mdx +++ b/pages/advanced-algorithms/available-algorithms/nodes.mdx @@ -45,7 +45,9 @@ directed: {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `node: int|node|List[int|node]` ➡ The input nodes given as nodes themselves or their IDs. - `types: List[string] (default = [])` ➡ A list of relationship types to filter by. @@ -138,7 +140,9 @@ DELETE` query. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `nodes: int|node|List[int|node]` - Nodes to be deleted given as nodes themselves or their IDs. {

Usage:

} @@ -176,7 +180,9 @@ Any other syntax results in an exception. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `nodes: List[Any]` ➡ A list of input nodes. Elements of the list can be either nodes themselves or their IDs. - `relationships: List[string]` ➡ A list of relationships to be checked. @@ -220,7 +226,9 @@ input, essentially creating a linked list of nodes. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `nodes: List[Node]` ➡ A list of input nodes that need to be linked. - `type: string` ➡ The type of relationship that will link two nodes. diff --git a/pages/advanced-algorithms/available-algorithms/nxalg.mdx b/pages/advanced-algorithms/available-algorithms/nxalg.mdx index e7812b41..3ebe0a98 100644 --- a/pages/advanced-algorithms/available-algorithms/nxalg.mdx +++ b/pages/advanced-algorithms/available-algorithms/nxalg.mdx @@ -67,7 +67,9 @@ Compute all simple shortest paths in the graph. A simple path is a path with no {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `source: Vertex` ➡ Starting node for the path. - `target: Vertex` ➡ Ending node for the path. - `weight: string (default=NULL)` ➡ If `NULL`, every relationship has @@ -100,7 +102,9 @@ is a path with no repeated nodes. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `source: Vertex` ➡ Starting node for the path. - `target: Vertex` ➡ Ending node for the path. - `cutoff: List[integer] (default=NULL)` ➡ Depth to stop the search. Only paths @@ -129,7 +133,9 @@ Returns all nodes having a path to `source` in `G`. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `source: Vertex` ➡ Starting node. Calculates all nodes that have a path to `source`. @@ -157,7 +163,9 @@ Centrality identifies the most important nodes within a graph. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `k: string (default=NULL)` ➡ If `k` is not `None`, use `k` node samples to estimate betweenness. The value of `k <= n` where `n` is the number of nodes in the graph. Higher values give a better approximation. @@ -191,7 +199,9 @@ Iterate over relationships in a breadth-first-search starting at source. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `source: Vertex` ➡ Specify starting node for breadth-first search. This function iterates only over relationships in the component that are reachable from this node. @@ -220,7 +230,9 @@ Returns an iterator of predecessors in breadth-first-search from source. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `source: Vertex` ➡ Specify starting node for breadth-first search. - `depth_limit: integer (default=NULL)` ➡ Specify the maximum search depth. @@ -246,7 +258,9 @@ Returns an iterator of successors in breadth-first-search from source. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `source: Vertex` ➡ Specify starting node for breadth-first search. - `depth_limit: integer (default=NULL)` ➡ Specify the maximum search depth. @@ -273,7 +287,9 @@ Returns an oriented tree constructed from of a breadth-first-search starting at {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `source: Vertex` ➡ Specify starting node for breadth-first search. - `reversed: boolean (default=False)` ➡ If `True`, traverse a directed graph in the reverse direction. @@ -310,7 +326,9 @@ Notice that by convention a dyad is considered a biconnected component. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -337,7 +355,9 @@ relationship that does not belong to any cycle. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `root: Vertex (default=NULL)` ➡ A node in the graph `G`. If specified, only the bridges in the connected components containing this node will be returned. @@ -365,7 +385,9 @@ The *center* is the set of nodes with eccentricity equal to the radius. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -396,7 +418,9 @@ cycle or path is called a *chain*. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `root: Vertex[default=NULL]` ➡ Optional. A node in the graph `G`. If specified, only the chain decomposition for the connected component containing this node will be returned. This node indicates the root of the depth-first @@ -429,7 +453,9 @@ any relationship intersections. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -454,7 +480,9 @@ in a graph tend to cluster together. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `nodes: List[Vertex] (default=NULL)` ➡ Compute clustering for nodes in this container. * `weight: string (default=NULL)` ➡ The relationship attribute that holds the numerical value used as a weight. If `None`, then each relationship has weight @@ -486,7 +514,9 @@ closed walks of different lengths starting at node `u` and ending at node `v`. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -516,7 +546,9 @@ that node. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -543,7 +575,9 @@ in the graph with respect to the node degree. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `x: string (default="out")` ➡ The degree type for source node (directed graphs only). Can be "in" or "out". * `y: string (default="in")` ➡ The degree type for target node (directed graphs only). Can be "in" or "out". * `weight: string (default=NULL)` ➡ The relationship attribute that holds the @@ -572,7 +606,9 @@ Returns all nodes reachable from `source` in `G`. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `source: Vertex` ➡ A node in `G`. {

Output:

} @@ -596,7 +632,9 @@ Returns nodes in a depth-first-search post-ordering starting at source. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `source: Vertex` ➡ Specify the maximum search depth. * `depth_limit: integer (default=NULL)` ➡ Specify the maximum search depth. @@ -621,7 +659,9 @@ Returns a dictionary of predecessors in depth-first-search from source. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `source: Vertex` ➡ Specify the maximum search depth. * `depth_limit: integer (default=NULL)` ➡ Specify the maximum search depth. @@ -647,7 +687,9 @@ Returns nodes in a depth-first-search pre-ordering starting at source. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `source: Vertex` ➡ Specify starting node for depth-first search and return nodes in the component reachable from this node. * `depth_limit: integer (default=NULL)` ➡ Specify the maximum search depth. @@ -672,7 +714,9 @@ Returns a dictionary of successors in depth-first-search from source. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `source: Vertex` ➡ Specify starting node for depth-first search and return nodes in the component reachable from this node. * `depth_limit: integer (default=NULL)` ➡ Specify the maximum search depth. @@ -699,7 +743,9 @@ Returns an oriented tree constructed from a depth-first-search from source. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `source: Vertex` ➡ Specify starting node for depth-first search. * `depth_limit: integer (default=NULL)` ➡ Specify the maximum search depth. @@ -726,7 +772,9 @@ The diameter is the maximum eccentricity. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -752,7 +800,9 @@ that node. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `start: Vertex` ➡ The start node of dominance computation. {

Output:

} @@ -780,7 +830,9 @@ that every node not in `D` is adjacent to at least one member of `D`. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `start: Vertex` ➡ Node to use as a starting point for the algorithm. {

Output:

} @@ -807,7 +859,9 @@ all relationships are generated. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `source: Vertex` ➡ The node from which the traversal begins. If `None`, then a source is chosen arbitrarily and repeatedly until all relationships from each node in the graph are searched. @@ -852,7 +906,9 @@ all relationships are generated. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `source: Vertex (default=NULL)` ➡ The node from which the traversal begins. If `None`, then a source is chosen arbitrarily and repeatedly until all relationships from each node in the graph are searched. @@ -902,7 +958,9 @@ suffer from recursion depth issues. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -928,7 +986,9 @@ relationships is determined by `orientation`. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `source: List[Vertex] (default=NULL)` ➡ The node from which the traversal begins. If `None`, then a source is chosen arbitrarily and repeatedly until all relationships from each node in the graph are searched. @@ -974,7 +1034,9 @@ in cycles in a directed graph. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `weight: string (default=NULL)` ➡ Attribute to use for node weights. If `None`, the weight defaults to 1. @@ -1001,7 +1063,9 @@ efficiency of all pairs of nodes. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -1026,7 +1090,9 @@ in which nodes are colored. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `strategy` ➡ The parameter `function(G,colors)` is a function (or a string representing a function) that provides the coloring strategy, by returning nodes in the order they should be colored. `G` is the graph, and `colors` is a @@ -1082,7 +1148,9 @@ RETURN node, color; {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -1104,7 +1172,9 @@ Returns `True` if `G` has a path from `source` to `target`. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `source: Vertex` ➡ Starting node for the path. * `target: Vertex` ➡ Ending node for the path. @@ -1131,7 +1201,9 @@ does not strictly dominate any other node That dominates `n`. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `start: Vertex` ➡ The start node of dominance computation. {

Output:

} @@ -1157,7 +1229,9 @@ with maximum in-degree equal to 1. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -1182,7 +1256,9 @@ graph is not AT-free and `False` is returned. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -1207,7 +1283,9 @@ in `u` one in `v`. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -1230,7 +1308,9 @@ maximum in-degree equal to 1. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -1254,7 +1334,9 @@ the cycle). {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -1280,7 +1362,9 @@ graph distance between `x` and `y`, independently of the choice of `x` and `y`. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -1305,7 +1389,9 @@ from the set incident on it. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `cover: List[Edge]` ➡ A list of relationships to be checked. {

Output:

} @@ -1332,7 +1418,9 @@ relationship of a graph exactly once. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -1357,7 +1445,9 @@ as a single undirected relationship in a multigraph. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -1381,7 +1471,9 @@ in-neighbors and no out-neighbors. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `n: Vertex` ➡ A node in `G`. {

Output:

} @@ -1406,7 +1498,9 @@ The two graphs `G1` and `G2` must be the same type. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `nodes1: List[Vertex]` ➡ Nodes in `G1`. * `edges1: List[Edge]` ➡ Edges in `G1`. * `nodes2: List[Vertex]` ➡ Nodes in `G2`. @@ -1441,7 +1535,9 @@ Returns `True` if `G` is semi-Eulerian. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -1466,7 +1562,9 @@ sequence is adjacent in the graph. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `nodes: List[Vertex]` ➡ A list of one or more nodes in the graph `G`. {

Output:

} @@ -1497,7 +1595,9 @@ An undirected graph is *strongly regular* if: {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -1521,7 +1621,9 @@ A *tournament* is a directed graph, with neither self-loops nor multi-relationsh {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -1546,7 +1648,9 @@ as a single undirected relationship in a multigraph. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -1570,7 +1674,9 @@ in-neighbors and no out-neighbors. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -1594,7 +1700,9 @@ Compute the Jaccard coefficient of all node pairs in `ebunch`. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `ebunch: List[List[Vertex]] (default=NULL)` ➡ Jaccard coefficient will be computed for each pair of nodes given in the iterable. The pairs must be given as 2-tuples `(u, v)` where `u` and `v` are nodes in the graph. If `ebunch` is @@ -1624,7 +1732,9 @@ adjacent (sharing `k-1` nodes) k-cliques. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `k: integer` ➡ Size of the smallest clique. * `cliques: List[List[Vertex]] (default=NULL)` ➡ Precomputed cliques (use networkx.find_cliques(G)). @@ -1657,7 +1767,9 @@ bounds of the number of node independent paths between two nodes. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `density: double (default=0.95)` ➡ Density relaxation threshold. {

Output:

} @@ -1685,7 +1797,9 @@ largest `k` for which the graph is k-edge-connected. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `k: integer` ➡ Desired relationship connectivity. {

Output:

} @@ -1714,7 +1828,9 @@ node. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -1736,7 +1852,9 @@ Compute the lowest common ancestor of the given pair of nodes. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `node1: Vertex` ➡ A node in the graph. * `node2: Vertex` ➡ A node in the graph. @@ -1764,7 +1882,9 @@ matching. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -1788,7 +1908,9 @@ that connects all of the vertices together without any cycles. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `weight: string (default="weight")` ➡ Data key to use for relationship weights. * `algorithm: string (default="kruskal")` ➡ The algorithm to use when finding a @@ -1821,7 +1943,9 @@ nodes for a weighted graph. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `sources: List[Vertex]` ➡ Starting nodes for paths. If this is a set containing a single node, then all paths computed by this function will start from that node. If there are two or more nodes in the set, the computed paths @@ -1864,7 +1988,9 @@ reachable nodes for a weighted graph. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `sources: List[Vertex]` ➡ Starting nodes for paths. If this is a set containing a single node, then all paths computed by this function will start from that node. If there are two or more nodes in the set, the computed paths @@ -1909,7 +2035,9 @@ to `v`. If `T` is not specified, it is assumed to be the set of all nodes not in {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `nbunch1: List[Vertex]` ➡ List of nodes in the graph representing the `S` set of nodes whose node boundary will be returned. * `nbunch2: List[Vertex] (default=NULL)` ➡ List of nodes representing the `T` @@ -1949,7 +2077,9 @@ directed and undirected graphs. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `source: Vertex (default=NULL)` ➡ Source node. * `target: Vertex (default=NULL)` ➡ Target node. @@ -1975,7 +2105,9 @@ of the size of the node boundary of `S` and the cardinality of `S`. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `s: List[Vertex]` ➡ A sequence of nodes in `G`. {

Output:

} @@ -2007,7 +2139,9 @@ by an Erdos Renyi model. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `k: integer (default=NULL)` ➡ The number of communities in `G`. If `k` is not set, the function will use a default community detection algorithm to set it. @@ -2036,7 +2170,9 @@ pages. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `alpha: double (default=0.85)` ➡ Damping parameter for PageRank. * `personalization: string (default=NULL)` ➡ The “personalization vector” consisting of a dictionary with a subset of graph nodes as a key and maps @@ -2085,7 +2221,9 @@ to node `u`. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `nodes: List[Vertex]` ➡ Compute reciprocity for nodes in this container. {

Output:

} @@ -2111,7 +2249,9 @@ Compute shortest paths in the graph. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `source: Vertex (default=NULL)` ➡ Starting node for the path. If not specified, compute shortest path lengths using all nodes as source nodes. * `target: Vertex (default=NULL)` ➡ Ending node for the path. If not specified, @@ -2155,7 +2295,9 @@ Compute shortest path lengths in the graph. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `source: Vertex (default=NULL)` ➡ Starting node for the path. If not specified, compute shortest path lengths using all nodes as source nodes. * `target: Vertex (default=NULL)` ➡ Ending node for the path. If not specified, @@ -2202,7 +2344,9 @@ algorithm. There may be better algorithms for some cases. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -2225,7 +2369,9 @@ Returns nodes in strongly connected components of a graph. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -2249,7 +2395,9 @@ implies that `u` appears before `v` in the topological sort order. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -2273,7 +2421,9 @@ graph. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -2302,7 +2452,9 @@ center nodes to the target node. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `center_nodes: List[Vertex]` ➡ A nonempty set of nodes in the graph `G` that represent the centers of the Voronoi cells. * `weight: string (default=NULL)` ➡ The relationship attribute (or an arbitrary @@ -2336,7 +2488,9 @@ counted. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `weight: string (default=NULL)` ➡ The relationship attribute to use as distance when computing shortest-path distances. This is passed directly to the `networkx.shortest_path_length` function. diff --git a/pages/advanced-algorithms/available-algorithms/pagerank.mdx b/pages/advanced-algorithms/available-algorithms/pagerank.mdx index 833269a0..79ba97e4 100644 --- a/pages/advanced-algorithms/available-algorithms/pagerank.mdx +++ b/pages/advanced-algorithms/available-algorithms/pagerank.mdx @@ -66,7 +66,9 @@ The procedure calculates the PageRank. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + * `max_iterations: integer (default=100)` ➡ Maximum number of iterations within PageRank algorithm. * `damping_factor: double (default=0.85)` ➡ PageRanks damping factor. This is the diff --git a/pages/advanced-algorithms/available-algorithms/pagerank_online.mdx b/pages/advanced-algorithms/available-algorithms/pagerank_online.mdx index f51a49c8..e4d639a9 100644 --- a/pages/advanced-algorithms/available-algorithms/pagerank_online.mdx +++ b/pages/advanced-algorithms/available-algorithms/pagerank_online.mdx @@ -89,8 +89,9 @@ parallelism, but is not applicable as it doesn't set the streaming context for t {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. -- `walks_per_node: integer (default=10)` ➡ Number of sampled walks per node. Note that increasing the number of walks per node will make the execution run for more time. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. +- `walks_per_node: integer (default=10)` ➡ Number of sampled walks per node. - `walk_stop_epsilon: double (default=0.1)` ➡ The probability of stopping when deriving the random walk. On average, it will create walks of length `1 / walk_stop_epsilon`. @@ -117,7 +118,9 @@ has been called, before adding changes to the graph. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -142,7 +145,8 @@ changes in the graph. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. - `created_vertices` ➡ Nodes that were created in the last transaction. - `created_edges` ➡ Relationships created in a period from the last transaction. - `deleted_vertices` ➡ Nodes deleted from the last transaction. diff --git a/pages/advanced-algorithms/available-algorithms/path.mdx b/pages/advanced-algorithms/available-algorithms/path.mdx index 173bfd74..faf8e4f3 100644 --- a/pages/advanced-algorithms/available-algorithms/path.mdx +++ b/pages/advanced-algorithms/available-algorithms/path.mdx @@ -44,7 +44,9 @@ node-relationship-node order. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `path: Path` ➡ The given path. {

Output:

} @@ -79,7 +81,9 @@ paths can't be combined. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `first: Path` ➡ The first path. - `second: Path` ➡ The second path. @@ -116,7 +120,9 @@ The function returns a subpath of the given path. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `path: Path` ➡ The given path. - `offset: int = 0` ➡ The first node index from the given path to be included in the subpath. - `length: int = -1` ➡ Length of the subpath. If set to -1 the subpath will end on the final node of the given path. @@ -158,7 +164,9 @@ from the last node of the path to one of the nodes in the current relationship {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `start_node: Node` - The starting node of the path. - `relationships: Map` - A map with the key `rel` that contains a list of the given relationships. @@ -207,7 +215,9 @@ inside the allowed number of hops, which satisfy relationship and label filters. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `start: any` ➡ A node, node ID, or a list of nodes and/or node IDs from which the function will expand. - `relationships: List[string]` ➡ A list of relationships which the expanding will follow. Relationships can be filtered using the notation described below. diff --git a/pages/advanced-algorithms/available-algorithms/refactor.mdx b/pages/advanced-algorithms/available-algorithms/refactor.mdx index 662a5ba6..43c9a5db 100644 --- a/pages/advanced-algorithms/available-algorithms/refactor.mdx +++ b/pages/advanced-algorithms/available-algorithms/refactor.mdx @@ -37,7 +37,9 @@ Redirect the relationship to use a new start (from) node. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `relationship: Relationship` ➡ Relationship that needs to be modified. - `new_from: Node` ➡ THe new start (from) node. @@ -65,7 +67,9 @@ Redirect the relationship to use a new end (to) node. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `relationship: Relationship` ➡ Relationship that needs to be modified. - `new_to: Node` ➡ The new end (to) node. @@ -99,7 +103,9 @@ the `old_label` the procedure doesn't modify it. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `old_label: str` ➡ The old label name. - `new_label: str` ➡ The new label name. - `nodes: List[Node]` ➡ The list of nodes to be modified. @@ -146,7 +152,9 @@ doesn't contain the `old_property` the procedure doesn't modify it. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `old_property: str` ➡ The old property name. - `new_label: str` ➡ The new property name. - `nodes: List[Node]` ➡ The list of nodes to be modified. @@ -191,7 +199,9 @@ and new category nodes to organize a graph based on these categories. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `original_prop_key: string` ➡ The property key on the existing nodes used to determine the category. - `rel_type: string` ➡ The type of relationship to be created between the @@ -262,7 +272,9 @@ properties during the cloning process. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `nodes: List[Node]` ➡ A list of nodes intended for duplication. - `withRelationships: bool (default = false)` ➡ If set to `true`, the function will also clone the relationships of the original nodes, connecting them to @@ -341,7 +353,9 @@ will be cloned. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `nodes: List[Node]` ➡ A list of nodes which form the subgraph intended for duplication. - `rels: List[Relationship] (default = [])` ➡ A list of relationships intended @@ -439,7 +453,9 @@ nodes connected by relationships. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `paths: List[Path]` ➡ A list of paths which define the subgraph intended for duplication. - `config: Map (default = {})` ➡ Configuration parameters explained below. @@ -452,7 +468,9 @@ nodes connected by relationships. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `input: int` ➡ ID of the original node which was cloned. - `output: Node` ➡ The new cloned node. @@ -534,7 +552,9 @@ requirements results in an exception. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `nodes: Any` ➡ A node, node ID, or list of nodes and node IDs. - `type: string` ➡ The type of the new relationship. @@ -580,7 +600,9 @@ Invert the direction of a given relationship. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `relationship: Any` ➡ A relationship, relationship ID, or a list of relationships or relationship IDs. @@ -629,7 +651,9 @@ an exception if both lists contain the same value. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `entity: Node|Relationship` ➡ The node or relationship on which the property value will be normalized. - `property_key: string` ➡ The key of the property to be normalized. - `true_values: List[Any]` ➡ A list of property values that will be normalized to `true`. @@ -669,7 +693,9 @@ end node of the given relationship with the given types. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `relationships: Relationship|int|List[Relationship|int]` ➡ Relationships to be changed into a node defined by their ID, themselves, or a list of any of those two. - `labels: List[string]` ➡ A list of labels that should assigned to the newly created node. - `outType: String` ➡ The type of the outgoing relationship from the newly created node. @@ -718,7 +744,9 @@ graph) and reconnects the remaining nodes. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `path: Path` ➡ The given path. - `nodes: List[Node]` ➡ A list of nodes to be deleted. - `config: Map` ➡ Config for reconnecting nodes. @@ -831,7 +859,9 @@ The procedure changes the relationship type. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `oldType: string` ➡ The relationship type that will be renamed. - `newType: string` ➡ The new relationship type. - `rels: List[Relationship]` ➡ The list of relationships whose types will be renamed. @@ -874,7 +904,9 @@ Renames the property of a relationship. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `old_property: string` ➡ The relationship property that will be renamed. - `new_property: string` ➡ The new property name. - `rels: List[Relationship]` ➡ The list of relationships whose properties will be renamed. diff --git a/pages/advanced-algorithms/available-algorithms/set_cover.mdx b/pages/advanced-algorithms/available-algorithms/set_cover.mdx index 6021bb00..6763f807 100644 --- a/pages/advanced-algorithms/available-algorithms/set_cover.mdx +++ b/pages/advanced-algorithms/available-algorithms/set_cover.mdx @@ -56,7 +56,9 @@ You can execute this algorithm on [graph projections, subgraphs or portions of t The input itself represents an *element-set* pair with each row of the lists. -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `element_vertexes: List[Vertex]` ➡ List of element nodes in pairs. - `set_vertexes: List[Vertex]` ➡ List of set nodes in pairs. @@ -84,7 +86,9 @@ The input itself represents an *element-set* pair with each row of the lists. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `element_vertexes: List[Vertex]` ➡ List of element nodes in pairs. - `set_vertexes: List[Vertex]` ➡ List of set nodes in pairs. diff --git a/pages/advanced-algorithms/available-algorithms/set_property.mdx b/pages/advanced-algorithms/available-algorithms/set_property.mdx index 0eee79b4..b14d8fe9 100644 --- a/pages/advanced-algorithms/available-algorithms/set_property.mdx +++ b/pages/advanced-algorithms/available-algorithms/set_property.mdx @@ -40,7 +40,9 @@ Copies properties from one node to another. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `sourceNode: Vertex` ➡ The node you want to copy property from. - `sourceProperties: List[string]` ➡ List of properties you want to copy from. - `targetNode: Vertex` ➡ The node you want to copy property to. @@ -64,7 +66,9 @@ Copies properties from one node to another relationship. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `sourceNode: Vertex` ➡ The node you want to copy property from. - `sourceProperties: List[string]` ➡ List of properties you want to copy from. - `targetRel: Relationship` ➡ The relationship you want to copy property to. @@ -88,7 +92,9 @@ Copies properties from one relationship to another node. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `sourceRel: Relationship` ➡ The relationship you want to copy property from. - `sourceProperties: List[string]` ➡ List of properties you want to copy from. - `targetNode: Vertex` ➡ The node you want to copy property to. @@ -112,7 +118,9 @@ Copies properties from one relationship to another. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `sourceRel: Vertex` ➡ The relationship you want to copy property from. - `sourceProperties: List[string]` ➡ List of properties you want to copy from. - `targetRel: Vertex` ➡ The relationship you want to copy property to. diff --git a/pages/advanced-algorithms/available-algorithms/tgn.mdx b/pages/advanced-algorithms/available-algorithms/tgn.mdx index 0d9708a2..8a742010 100644 --- a/pages/advanced-algorithms/available-algorithms/tgn.mdx +++ b/pages/advanced-algorithms/available-algorithms/tgn.mdx @@ -187,7 +187,9 @@ values. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `params: mgp.Map` ➡ A dictionary containing the following parameters: | Name | Type | Default | Description | @@ -233,7 +235,9 @@ The `update()` procedure scrapes data from edges, including `edge_features` and {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `edges: mgp.List[mgp.Edges]` ➡ List of edges to preprocess (that arrive in a stream to Memgraph). If a batch is full, `train` or `eval` starts, depending on the mode. @@ -265,7 +269,9 @@ The `get()` procedure retrieves calculated embeddings for each vertex. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -289,7 +295,9 @@ Use the `set_eval()` procedure to change the **TGN** mode to `eval`. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -311,7 +319,9 @@ Epoch count starts from 1. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} @@ -339,7 +349,9 @@ rounds on `train` edges and `eval` on evaluation edges. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `num_epochs: integer` ➡ Perform additional epoch training and evaluation **after** the stream is done. @@ -371,7 +383,9 @@ the link prediction task. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `src: mgp.Vertex` ➡ Source vertex of the link prediction. - `dest: mgp.Vertex` ➡ Destination vertex of the link prediction. diff --git a/pages/advanced-algorithms/available-algorithms/tsp.mdx b/pages/advanced-algorithms/available-algorithms/tsp.mdx index 5ffc657d..e2409156 100644 --- a/pages/advanced-algorithms/available-algorithms/tsp.mdx +++ b/pages/advanced-algorithms/available-algorithms/tsp.mdx @@ -66,7 +66,9 @@ Use the procedure to solve the travelling salesman problem. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `points: List[Vertex]` ➡ List of points to calculate TSP on. Required to have *lng* and *lat* properties. - `method: string (default=1.5_approx)` ➡ Method used for optimization. Can be either ***1.5_approx***, ***2_approx*** or ***greedy***. diff --git a/pages/advanced-algorithms/available-algorithms/union_find.mdx b/pages/advanced-algorithms/available-algorithms/union_find.mdx index a1fb880e..b0003213 100644 --- a/pages/advanced-algorithms/available-algorithms/union_find.mdx +++ b/pages/advanced-algorithms/available-algorithms/union_find.mdx @@ -62,7 +62,9 @@ different connected component. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `nodes1: Union[Vertex, List[Vertex]]` ➡ First value (or list thereof) in connectedness calculation. - `nodes2: Union[Vertex, List[Vertex]]` ➡ Second value (or list thereof) in connectedness calculation. - `mode: string (default="pairwise")` ➡ Mode of combining `nodes1` and `nodes2`. Can be ***p*** or ***pairwise*** for a pairwise product, or ***c*** or ***cartesian*** for a Cartesian product of the arguments. Pairwise by default. diff --git a/pages/advanced-algorithms/available-algorithms/uuid_generator.mdx b/pages/advanced-algorithms/available-algorithms/uuid_generator.mdx index 9b05fd6a..4ef79dfc 100644 --- a/pages/advanced-algorithms/available-algorithms/uuid_generator.mdx +++ b/pages/advanced-algorithms/available-algorithms/uuid_generator.mdx @@ -43,7 +43,9 @@ Use the procedure to the the UUID string. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} diff --git a/pages/advanced-algorithms/available-algorithms/vrp.mdx b/pages/advanced-algorithms/available-algorithms/vrp.mdx index 7b6a63bb..f4106f6e 100644 --- a/pages/advanced-algorithms/available-algorithms/vrp.mdx +++ b/pages/advanced-algorithms/available-algorithms/vrp.mdx @@ -65,7 +65,9 @@ The procedure returns a vehicle route. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `depot_node: Vertex` ➡ Depot node with its corresponding *lat* and *lng* coordinate properties. - `number_of_vehicles: integer = 1` ➡ Designates how many vehicles are used. Set to 1 by default. diff --git a/pages/advanced-algorithms/available-algorithms/weakly_connected_components.mdx b/pages/advanced-algorithms/available-algorithms/weakly_connected_components.mdx index 24d54fd5..c10b413d 100644 --- a/pages/advanced-algorithms/available-algorithms/weakly_connected_components.mdx +++ b/pages/advanced-algorithms/available-algorithms/weakly_connected_components.mdx @@ -46,7 +46,9 @@ Use the procedure to get disconnected componentes. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + {

Output:

} diff --git a/pages/advanced-algorithms/available-algorithms/xml_module.mdx b/pages/advanced-algorithms/available-algorithms/xml_module.mdx index 37e7e04f..dacbdd2d 100644 --- a/pages/advanced-algorithms/available-algorithms/xml_module.mdx +++ b/pages/advanced-algorithms/available-algorithms/xml_module.mdx @@ -53,7 +53,9 @@ via an element name prefixed with an `_`. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `xml_input: string` ➡ input XML string. - `simple: bool (default = false)` ➡ configuration bool used for specifying whether simple mode should be used. [**Simple configuration explanation**](#simple-configuration-explanation). - `path: string (default = "")` ➡ path to the XML file that needs to be parsed. If the path is not empty, the `xml_input` string is ignored, and only the file is parsed. @@ -321,7 +323,9 @@ must be used to avoid errors: `. .. *`. The current node is the root node. {

Input:

} -- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +- `subgraph: Graph` (**OPTIONAL**) ➡ A specific subgraph, which is an [object of type Graph](/advanced-algorithms/run-algorithms#run-procedures-on-subgraph) returned by the `project()` function, on which the algorithm is run. +If subgraph is not specified, the algorithm is computed on the entire graph by default. + - `xml_url: string` ➡ The input URL where the XML file is located. - `simple: bool (default = false)` ➡ A bool used for specifying whether simple mode should be used. - `path: string (default = "")` ➡ A path to the XML file that needs to be parsed. If the path is not empty, `xml_input` string is ignored, and only the file is parsed. From 102d8f173eb9ea1ce9b7a02eef9f30974575e284 Mon Sep 17 00:00:00 2001 From: Oleksandr Ichenskyi <55350107+AlexIchenskiy@users.noreply.github.com> Date: Tue, 5 Nov 2024 14:29:22 +0100 Subject: [PATCH 27/31] Add custom SSL for Lab configuration page (#1030) * add custom SSL configuration page * update titlecase --------- Co-authored-by: katarinasupe Co-authored-by: Katarina Supe <61758502+katarinasupe@users.noreply.github.com> --- .../install-and-connect.mdx | 3 + .../user-manual/custom-ssl-certificates.mdx | 89 +++++++++++++++++++ 2 files changed, 92 insertions(+) create mode 100644 pages/data-visualization/user-manual/custom-ssl-certificates.mdx diff --git a/pages/data-visualization/install-and-connect.mdx b/pages/data-visualization/install-and-connect.mdx index ba463ea2..7548a825 100644 --- a/pages/data-visualization/install-and-connect.mdx +++ b/pages/data-visualization/install-and-connect.mdx @@ -261,6 +261,9 @@ Configure Memgraph Lab using the following environment variables when running it | `QUICK_CONNECT_MG_IS_ENCRYPTED` | Turn SSL on/off for quick connect | `boolean` | `false` | | `PORT` | Lab app default listening port | `integer` | `3000` | | `REQUEST_BODY_LIMIT_MB` | Limit for request body size in MB | `integer` | `20` | +| `SSL_IS_ENABLED` | Enable or disable SSL | `boolean` | `false` | +| `SSL_CERT_PATH` | Path to SSL certificate to be used | `string` | `./ssl/cert.pem` | +| `SSL_KEY_PATH` | Path to SSL key to be used | `string` | `./ssl/key.pem` | | `STORAGE_MG_HOST` | `(Enterprise only)` Memgraph host for the Lab remote storage | `string` | | | `STORAGE_MG_PORT` | `(Enterprise only)` Memgraph port for the Lab remote storage | `number` | | | `STORAGE_MG_IS_ENCRYPTED` | `(Enterprise only)` Memgraph SSL on/off for the Lab remote storage | `boolean` | | diff --git a/pages/data-visualization/user-manual/custom-ssl-certificates.mdx b/pages/data-visualization/user-manual/custom-ssl-certificates.mdx new file mode 100644 index 00000000..4978f334 --- /dev/null +++ b/pages/data-visualization/user-manual/custom-ssl-certificates.mdx @@ -0,0 +1,89 @@ +--- +title: Custom SSL certificates +description: Use your own SSL certificate to use Memgraph Lab with HTTPS protocol. +--- + +## Instantiating Memgraph Lab with custom SSL certificate + +Memgraph Lab supports using custom SSL certificates, ensuring secure communication over HTTPS. To set up +SSL on Memgraph Lab you will need to configure a Dockerfile using a valid SSL certificate. + +### Options for generating SSL certificates + +There are various options to generate SSL certificates. Check out the steps on +how to do that with [OpenSSL](#openssl) and [Let's Encrypt](#lets-encrypt). + + +#### OpenSSL +[OpenSSL](https://github.com/openssl/openssl) is a widely used tool for +generating SSL certificates. You can create a self-signed certificate using the +following commands: + +1. Generate a private key: + ```bash + openssl genrsa -out key.pem 2048 + ``` + +2. Generate a self-signed certificate: + ```bash + openssl req -new -x509 -key key.pem -out cert.pem -days 365 + ``` + +However, this option has an expiration date and is not signed by a publicly trusted +[certificate authority](https://en.wikipedia.org/wiki/Certificate_authority), which means +you will most likely receive a security warning from your browser while using it. + +#### Let's Encrypt +[Let's Encrypt](https://letsencrypt.org/) is a free, automated, and open certificate authority +that provides SSL certificates. You can use tools like Certbot to obtain and install certificates. +To use Let's Encrypt: + +1. Install Certbot. +2. Run Certbot to obtain your certificates: + ```bash + sudo certbot certonly --standalone -d yourdomain.com + ``` + +This will generate your SSL certificate and key, typically located in +`/etc/letsencrypt/live/yourdomain.com/`. + +### Dockerfile setup + +To run Memgraph Lab with custom SSL certificates, you need to create a +Dockerfile that specifies how to build the Docker image with your certificates. + +You will need to set the `SSL_CERT_PATH` and `SSL_KEY_PATH` environment variables +to override the default `./ssl/` path used by Lab running in the container to +determine the SSL certificate location. After that, you should copy your certificates +(located in the `ssl` folder at the same location as your `Dockerfile`, for example) +into the container at the specified path. + +#### Example Dockerfile +```docker +FROM memgraph/lab:latest + +# Environment variables +ENV SSL_IS_ENABLED=true +ENV SSL_CERT_PATH=./myssl/cert.pem +ENV SSL_KEY_PATH=./myssl/key.pem + +# COPY source_on_your_machine destination_in_container +COPY ssl/ ./myssl/ + +EXPOSE 3000 +``` + +#### Building and running the Docker container + +1. **Create the SSL Directory**: Make sure your SSL certificate and key are placed +in a directory specified as `COPY` source in your Dockerfile. + +2. **Build the Docker Image**: Run the following command to build your Docker image: + `docker build -t memgraph-lab-ssl .` + +3. **Run the Docker Container**: Start the container using the following command: + `docker run -p 3000:3000 memgraph-lab-ssl` + +4. **Access Memgraph Lab**: You can now access Memgraph Lab in your web browser at +`https://localhost:3000`. Ensure to configure your browser to trust the self-signed +certificate if you are using one. \ No newline at end of file From b1f2d2e8a24123a196049b5a6b806ba93a2d761c Mon Sep 17 00:00:00 2001 From: katarinasupe Date: Tue, 5 Nov 2024 15:24:16 +0100 Subject: [PATCH 28/31] update cypher differences --- pages/querying/differences-in-cypher-implementations.mdx | 4 ---- 1 file changed, 4 deletions(-) diff --git a/pages/querying/differences-in-cypher-implementations.mdx b/pages/querying/differences-in-cypher-implementations.mdx index 77cef10f..f72fd9dd 100644 --- a/pages/querying/differences-in-cypher-implementations.mdx +++ b/pages/querying/differences-in-cypher-implementations.mdx @@ -238,10 +238,6 @@ UNWIND [42, true, 'abc'] AS val RETURN val, valueType(val) = "INTEGER" ``` -### Unsupported data types - -- `POINT` -> Track progress on [GitHub](https://github.com/memgraph/memgraph/issues/1583) and add a comment if you require such a feature. - ### Unsupported functions **Functions for converting data values**: From 98f071bb1db5289b4a76aea7f56113e26e875c88 Mon Sep 17 00:00:00 2001 From: andrejtonev <29177572+andrejtonev@users.noreply.github.com> Date: Tue, 5 Nov 2024 19:00:55 +0100 Subject: [PATCH 29/31] Add more details related to the schema info v2 (#1029) --- pages/fundamentals/storage-memory-usage.mdx | 3 +++ pages/querying/schema.mdx | 9 ++++++++- 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/pages/fundamentals/storage-memory-usage.mdx b/pages/fundamentals/storage-memory-usage.mdx index 38c9795c..de77773e 100644 --- a/pages/fundamentals/storage-memory-usage.mdx +++ b/pages/fundamentals/storage-memory-usage.mdx @@ -186,6 +186,9 @@ If the returned graph element has been deleted by a parallel transaction, the built-in behavior is as follows: * [procedures](/advanced-algorithms/run-algorithms#run-procedures-from-mage-library): skip all records that contain any deleted value * [functions](/querying/functions): return a null value + +Please note that deleting same part of the graph from parallel transaction will lead to undefined behavior. + Users developing [custom query procedures and functions](/custom-query-modules) intended to work in the analytical storage mode should use API methods to check if Memgraph is running in a transactional (ACID-compliant) storage mode. If not, the query module APIs diff --git a/pages/querying/schema.mdx b/pages/querying/schema.mdx index d3b07f15..f1d2b646 100644 --- a/pages/querying/schema.mdx +++ b/pages/querying/schema.mdx @@ -11,6 +11,13 @@ Schema queries are designed to retrieve information about the structure of the d ## Run-time schema tracking + + +Please use a snapshot to migrate a pre v2.21 datasets with properties on edges. +When schema is tracked, recovering using WAL files generated pre v2.21 will incur a performance penalty as crucial data is missing, which leads to long scan times. + + + To use run-time schema tracking, start Memgraph with the `--schema-info-enabled` [configuration flag](/configuration/configuration-settings#other) set to `True`. Once enabled, every change to the data layout will be tracked, and a derived schema will be automatically updated. Note that enabling this feature may result in a slight performance decrease; for more details, refer to [Performance Tips](#performance-tips). ### What Schema Information is Tracked? @@ -248,7 +255,7 @@ Enabling `--schema-info-enabled` incurs a performance cost because additional wo #### Performance Tips * __Label Changes on Nodes with Edges__: Changing labels on a node with existing edges can invalidate large parts of the schema. To avoid blocking queries during schema updates, define node labels before adding edges. Queries such as `CREATE (:A)-[:EDGE]->(:B)` are also fine. * __Edge Property Type Changes__: Modifying the type of an edge's property may require scanning large portions of the graph. To avoid this, define edges and their properties in the same transaction and keep property types stable. -* __Recovery Using WALs__: Recovering edges with properties via Write-Ahead Log (WAL) files can cause a significant performance hit. To mitigate this, use snapshots instead. Starting from v2.21, this issue will be alleviated, though not completely resolved. +* __Recovery Using WALs__: Recovering edges with properties via Write-Ahead Log (WAL) files can cause a significant performance hit. To mitigate this, use snapshots instead. Starting from v2.21, this issue has been alleviated, when using WAL files created by v2.21+. ## Schema metadata From 20d033572a31d4534a591ee24e199f4c6f1bea0d Mon Sep 17 00:00:00 2001 From: Marko Budiselic Date: Tue, 5 Nov 2024 17:19:57 -0800 Subject: [PATCH 30/31] Remove redundant empty lines --- pages/release-notes.mdx | 3 --- 1 file changed, 3 deletions(-) diff --git a/pages/release-notes.mdx b/pages/release-notes.mdx index 23d29c25..3303fb45 100644 --- a/pages/release-notes.mdx +++ b/pages/release-notes.mdx @@ -272,7 +272,6 @@ labeled with `jepsen`). - Replica now correctly reflects database registration success or failure. When replica receives a request for registering replica, it will now return status code NOT_MAIN. If attempting to undo an incomplete registration fails, then the Memgraph instance will be intentionally crashed because the system is in unrecoverable state. Main instance can now deal with stale RPC message GetReplicaUUID without crashing the instance. [#2373](https://github.com/memgraph/memgraph/pull/2373) - Closing instance no longer crashes due to [streams](/data-streams) and/or [TTL](/querying/time-to-live) running in the background. [#2361](https://github.com/memgraph/memgraph/pull/2361) - ## Lab v2.17.0 - Sep 25, 2024 {

New features and improvements

} @@ -299,8 +298,6 @@ labeled with `jepsen`). are now aligned. Instead of breaking the connection due to permission issues, users will now see "N/A" where applicable. - - ## Memgraph v2.20.0 - Sep 25, 2024 {

New features and improvements

} From e1298b98be2436ebfce36c0b90a5d13c9a3dfd48 Mon Sep 17 00:00:00 2001 From: Marko Budiselic Date: Tue, 5 Nov 2024 17:20:40 -0800 Subject: [PATCH 31/31] More lines --- pages/release-notes.mdx | 1 - 1 file changed, 1 deletion(-) diff --git a/pages/release-notes.mdx b/pages/release-notes.mdx index 3303fb45..c645f5c0 100644 --- a/pages/release-notes.mdx +++ b/pages/release-notes.mdx @@ -40,7 +40,6 @@ supported Enterprise-licensed feature. - ### Upgrading to Memgraph v2.18.0