Cypher Cheat Sheet

Match all nodes and return all nodes.

Find all nodes with the Movie label.

Find the types of an aliased relationship.

Relationship pattern filtering on the ACTED_IN relationship type.

Bind a path pattern to a path variable, and return the path pattern.

Match nodes dynamically using a variable.

Use MATCH to find entities that must be present in the pattern. Use OPTIONAL MATCH to find entities that may not be present in the pattern. OPTIONAL MATCH returns null for empty rows.

WHERE used to filter on node labels.

WHERE used to filter on node properties.

WHERE used to filter on relationship properties.

To filter on a property using a dynamically computed name, use square brackets [].

WHERE used inside a fixed-length pattern.

WHERE can appear inside a pattern comprehension.

WHERE can be used to filter variable-length patterns.

Return a node.

Return relationship types.

Return a specific property.

To return all nodes, relationships and paths found in a query, use the * symbol.

Names of returned columns can be aliased using the AS operator.

DISTINCT retrieves unique rows for the returned columns.

WITH can be used in combination with the AS keyword to bind new variables which can then be passed to subsequent clauses. Any variables not explicitly referenced by WITH (or carried over by WITH *) are dropped from the scope of the query.

Use the wildcard * to carry over all variables that are in scope.

WITH cannot de-scope variables imported to a CALL subquery, because variables imported to a subquery are considered global to its inner scope.

WITH can be used to assign the values of expressions to variables.

WITH can be used to chain expressions.

WITH can be used to perform aggregations and bind the results to new variables.

WITH can be used to remove duplicate values from the result set if appended with the modifier DISTINCT.

WITH can order and paginate results if used together with the ORDER BY, LIMIT, and SKIP subclauses.

WITH can be followed by the WHERE subclause to filter results.

If a write clause is followed by a read clause, WITH must be used as a separator between the two.

Return the distinct union of all query results. Result column types and names must match.

Return the union of all query results, including duplicate rows.

The UNION clause can be used within a CALL subquery to further process the combined results before a final output is returned.

Create a node with the given label and properties.

Create a node with the given label and properties.

Create a relationship with the given relationship type and direction; bind a variable r to it.

Create a relationship with the given type, direction, and properties.

Node labels and relationship types can be referenced dynamically in expressions, parameters, and variables when merging nodes and relationships. The expression must evaluate to a STRING NOT NULL | LIST<STRING NOT NULL> NOT NULL value.

Update or create a property.

Update or create several properties.

Dynamically set or update node properties.

Dynamically set node labels.

Set all properties. This will remove any existing properties.

Using the empty map ({}), removes any existing properties.

Add and update properties, while keeping existing ones.

Add a label to a node. This example adds the label Person to a node.

Match a pattern or create it if it does not exist. Use ON CREATE and ON MATCH for conditional updates.

MERGE finds or creates a relationship between the nodes.

MERGE finds or creates paths attached to the node.

Node labels and relationship types can be referenced dynamically in expressions, parameters, and variables when merging nodes and relationships. The expression must evaluate to a STRING NOT NULL | LIST<STRING NOT NULL> NOT NULL value.

Delete a relationship.

Delete all relationships.

Delete a node and all relationships connected to it.

Delete a node and a relationship. An error will be thrown if the given node is attached to more than one relationship.

Delete all nodes and relationships from the database.

Remove a label from a node.

Dynamically remove node labels.

Remove a property from a node.

Dynamically remove properties from nodes.

REMOVE cannot be used to remove all existing properties from a node or relationship. All existing properties can be removed from a node or relationship by using the SET clause with the property replacement operator (=) and an empty map ({}) as the right operand.

Prepending a query with CYPHER 25 ensures that the query will be executed using Cypher 25 as it exists in the version of Neo4j that the database is currently running, provided it is on Neo4j 2025.06 or later.

Selecting CYPHER 5 ensures that the query will be executed using the Cypher 5 as it existed at the time of the Neo4j 2025.06 release. Any changes introduced after the 2025.06 release will not affect the query.

Match a node pattern including a WHERE clause predicate.

Match a fixed-length path pattern to paths in a graph.

Quantified path pattern matching a sequence of paths whose length is constrained to a specific range (1 to 3 in this case) between two nodes.

Quantified relationship matching paths where a specified relationship occurs between 1 and 10 times.

Quantified path pattern including a predicate.

SHORTEST k finds the shortest path(s) (by number of hops) between nodes, where k is the number of paths to match.

Find all shortest paths between two nodes.

SHORTEST k GROUPS returns all paths that are tied for first, second, and so on, up to the kth shortest length. This example finds all paths with the first and second shortest lengths between two nodes.

The ANY keyword can be used to test the reachability of nodes from a given node(s). It returns the same as SHORTEST 1, but by using the ANY keyword the intent of the query is clearer.

An equijoin is an operation on paths that requires more than one of the nodes or relationships of the paths to be the same. The equality between the nodes or relationships is specified by declaring a node variable or relationship variable more than once. An equijoin on nodes allows cycles to be specified in a path pattern. Due to relationship uniqueness, an equijoin on relationships yields no solutions.

Multiple path patterns can be combined in a comma-separated list to form a graph pattern. In a graph pattern, each path pattern is matched separately, and where node variables are repeated in the separate path patterns, the solutions are reduced via equijoins.

Standalone call to the procedure db.labels to list all labels used in the database. Note that required procedure arguments are given explicitly in brackets after the procedure name.

Optionally CALL a procedure. Similar to OPTIONAL MATCH, any empty rows produced by the OPTIONAL CALL will return null and not affect the remainder of the procedure evaluation.

Standalone calls may use YIELD * to return all columns.

Standalone calls may omit YIELD and also provide arguments implicitly via statement parameters, e.g. a standalone call requiring one argument input may be run by passing the parameter map {input: 'foo'}.

Calls the built-in procedure db.labels inside a larger query to count all labels used in the database. Calls inside a larger query always requires passing arguments and naming results explicitly with YIELD.

A query ending in FINISH — instead of RETURN — has no result but executes all its side effects.

FOREACH can be used to update data, such as executing update commands on elements in a path, or on a list created by aggregation. This example sets the property marked to true on all nodes along a path.

This example sets the property marked to true on all relationships along a path.

This example creates a new node for each label in a list.

LIMIT constrains the number of returned rows. It can be used in conjunction with ORDER BY and SKIP.

LIMIT can be used as a standalone clause.

LOAD CSV is used to import data from CSV files into a Neo4j database. This example imports the name and year information of artists from a local file.

Import artists name and year information from a remote file URL.

CSV columns can be referenced dynamically to map labels to nodes in the graph. This enables flexible data handling, allowing labels to be be populated from CSV column values without manually specifying each entry.

Load a CSV file in several transactions. This example uses a variable scope clause (introduced in Neo4j 5.23) to import variables into the CALL subquery.

Access line numbers in a CSV with the linenumber() function.

Access the CSV file path with the file() function.

Load CSV data with headers.

Import a CSV using ; as field delimiter.

You can order by multiple properties by stating each variable in the ORDER BY clause.

ORDER BY can be used as a standalone clause.

List all available functions, returns only the default outputs (name, category, and description).

List built-in functions, can also be filtered on ALL or USER-DEFINED .

Filter the available functions for the current user.

Filter the available functions for the specified user.

List all available procedures, returns only the default outputs (name, description, mode, and worksOnSystem).

List all available procedures.

List all procedures that can be executed by the current user and return only the name of the procedures.

List running transactions (within the instance), returns only the default outputs (database, transactionId, currentQueryId, connectionId, clientAddress, username, currentQuery, startTime, status, and elapsedTime).

List running transactions (within the instance).

List the running transaction (within the instance), with a specific transaction_id. As long as the transaction IDs evaluate to a string or a list of strings at runtime, they can be any expression.

SKIP defines from which row to start including the rows in the output. It can be used in conjunction with LIMIT and ORDER BY.

SKIP can be used as a standalone clause.

OFFSET can be used as a synonym to SKIP.

Terminate a specific transaction, returns the outputs: transactionId, username, message.

Terminal transactions allow for YIELD clauses. As long as the transaction IDs evaluate to a string or a list of strings at runtime, they can be any expression.

List all transactions by the specified user and terminate them. Return the transaction IDs of the transactions that failed to terminate successfully.

Create a number of nodes and relationships from a parameter-list without using FOREACH.

The USE clause determines which graph a query is executed against. This example assumes that the DBMS contains a database named myDatabase.

This example assumes that the DBMS contains a composite database named myComposite, which includes an alias named myConstituent.

A CALL subquery is executed once for each row. In this example, the CALL subquery executes three times.

Variables are imported into a CALL subquery using a variable scope clause, CALL (<variable>), or an importing WITH clause (deprecated). In this example, the subquery will process each Team at a time and collect a list of all Player nodes.

Optionally CALL a subquery. Similar to OPTIONAL MATCH, any empty rows produced by the OPTIONAL CALL will return null and not affect the remainder of the subquery evaluation.

CALL subqueries can be used to further process the results of a UNION query. This example finds the youngest and the oldest Player in the graph.

CALL subqueries can execute in separate, inner transactions, producing intermediate commits.

Specify the number of rows processed in each transaction.

CALL subqueries can execute batches in parallel by appending IN [n] CONCURRENT TRANSACTIONS, where n is an optional concurrency value used to set the maximum number of transactions that can be executed in parallel.

ON ERROR RETRY …​ THEN CONTINUE can be used to retry the execution of a transaction for a specified maximum duration before continuing the execution of subsequent inner transactions by ignoring any recoverable errors.

A COUNT subquery counts the number of rows returned by the subquery. Unlike CALL subqueries, variables introduced by the outer scope can be used in EXISTS, COLLECT, and COUNT subqueries.

An EXISTS subquery determines if a specified pattern exists at least once in the graph. A WHERE clause can be used inside COLLECT, COUNT, and EXISTS patterns.

A COLLECT subquery creates a list with the rows returned by the subquery. COLLECT, COUNT, and EXISTS subqueries can be used inside other clauses.

The AND operator is used to combine multiple boolean expressions, returning true only if all conditions are true.

The OR operator is used to combine multiple boolean expressions, returning true if at least one of the conditions is true.

The XOR operator returns true if exactly one of the two boolean expressions is true, but not both.

The NOT operator negates a boolean expression, returning true if the expression is false and false if it is true.

The equality operator = checks for equality between two values.

The inequality operator <> checks if two values are not equal.

The less than operator < returns true if the value on the left is less than the value on the right.

The less than or equal or operator <= returns true if the value on the left is less than or equal to the value on the right.

The greater than operator > returns true if the value on the left is greater than the value on the right.

The greater than or equal operator >= returns true if the value on the left is greater than the value on the right.

The IS NULL operator returns true if the value is NULL, and false otherwise.

The IS NOT NULL operator returns true if the value is not NULL, and false otherwise.

The IN operator checks if a value is present in a LIST.

To check if NULL is a member of a LIST, use the any() function.

When used with nested LIST values, the IN operator evaluates whether a LIST is an exact match to any of the nested LIST values that are part of an outer LIST. Partial matches of individual elements within a nested LIST will return false.

A subset check using the all() function verifies if all elements of one LIST exist in another.

Similar to EXISTS subqueries, path pattern expressions can be used to assert whether a specified path exists at least once in a graph.

Path pattern expression with boolean operators.

The STARTS WITH operator checks if a STRING value begins with a specified prefix.

The ENDS WITH operator checks if a STRING value ends with a specified suffix

The CONTAINS operator checks if a STRING value contains a specified substring.

The regular expression operator =~ checks if a `STRING`value matches a regular expression.

The =~ operator can be used with regular expression flags, such as (?i) for case-insensitive matching, to modify how the regex is applied.

The IS NORMALIZED operator is used to check whether the given STRING value is in the NFC Unicode normalization form.

The IS NOT NORMALIZED operator is used to check whether the given STRING value is not in the NFC Unicode normalization form.

It is possible to define which Unicode normalization type is used. The available normalization types are: NFC (default), NFD, NFKC, and NFKD.

A type predicate expression can be used to verify the type of a variable, literal, property or other Cypher expression.

It is possible to verify that a Cypher expression is not of a certain type, using the negated type predicate expression IS NOT ::.

All Cypher types includes the NULL value. Type predicate expressions can be appended with NOT NULL. This means that IS :: returns TRUE for all expressions evaluating to NULL, unless NOT NULL is appended.

Type predicate expressions can also be used to filter out nodes or relationships with properties of a certain type.

Closed dynamic union types allow for the testing of multiple types in the same predicate.

The simple CASE form is used to compare a single expression against multiple values, and is analogous to the switch construct of programming languages. The expressions are evaluated by the WHEN operator until a match is found. If no match is found, the expression in the ELSE operator is returned. If there is no ELSE case and no match is found, null will be returned.

The extended simple CASE can use comparison operators.

The generic CASE expression supports multiple conditional statements, and is analogous to the if-elseif-else construct of programming languages. Each row is evaluated in order until a true value is found. If no match is found, the expression in the ELSE operator is returned. If there is no ELSE case and no match is found, null will be returned.

The results of a CASE expression can be used to set properties on a node or relationship.

Node pattern using the OR (|) label expression.

Node pattern using the negation (!) label expression.

Relationship pattern using the OR (|) label expression. As relationships can only have exactly one type each, ()-[:A&B]→() will never match a relationship.

The subscript operator, [], can be used to access specific elements in a LIST. [0] refers to the first element in a LIST, [1] to the second, and so on. [-1] refers to the last element in a LIST, [-2] to the penultimate element, and so on.

Access a LIST within a nested LIST.

Access specific elements in a nested LIST.

LIST values can be sliced if a range is provided within the subscript operator []. The bounds of the range are separated using two dots (..). This allows for extracting a subset of a LIST rather than a single element. List slicing is inclusive at the start of the range, but exclusive at the end (e.g. list[start..end] includes start, but excludes end).

Negative indexing in list slicing references elements from the end of the LIST; ..-1 excludes the last element, ..-2 excludes the last two elements, and so on.

Slicing inner LIST values require two [] operators; the first [] accesses elements from the outer LIST, while the second slices or accesses elements from the inner LIST.

Cypher contains two list concatenation operators: || and `. They are functionally equivalent but `||` is GQL conformant and ` is not.

The + operator can add elements to the beginning or end of a LIST value. This is not possible using the || operator.

List comprehension is used to create new LIST values by iterating over existing LIST values and transforming the elements based on certain conditions or operations. This process effectively maps each element in the original LIST to a new value. The result is a new LIST that consists of the transformed elements.

List comprehension using node properties.

List comprehension with a WHERE predicate.

List comprehension can be used to remove any unknown NULL values when concatenating LIST values.

Pattern comprehension is used to create new LIST values by matching graph patterns and applying conditions to the matched elements, returning custom projections.

Pattern comprehension with a WHERE predicate.

Variable-length pattern comprehension.

Property values of nodes and relationships can be accessed statically by specifying a property name after the . operator.

Property values can be accessed dynamically by using the subscript operator [].

If a property (or property value) is missing in an expression that tries to access a property statically or dynamically, the whole expression will evaluate to NULL. The coalesce() function can be used to skip the first NULL value in an expression.

The addition operator + is used to add numeric values.

The subtraction operator - is used to subtract numeric values.

The multiplication operator * is used to multiply numeric values.

The division operator / is used to divide numeric values.

The modulo division operation % returns the remainder when one number is divided by another.

The exponentiation operator ^ raises a number to the power of another.

MAP values can be accessed statically by specifying a key after the . operator.

To statically access a value in a nested MAP, use chained . operators. Each . operator traverses one level deeper into the nested structure.

To dynamically access a MAP value, use the subscript operator, []. The key can be provided by a variable or a parameter.

Dynamically access a nested MAP value.

Map projection with a key selector to extract specific key-value pairs from a MAP.

Map projection with a literal entry to add custom values to a projected MAP value without modifying the original data structure.

Map projection with a variable selector to project values based on a variable name.

Map projection with an all-map projection to project all key-value pairs from a MAP without explicitly listing them.

Cypher contains two operators for the concatenation of STRING values: || and ` The two operators are functionally equivalent. However, `||` is GQL conformant, while ` is not.

Cypher does not insert spaces when concatenating STRING values.

String concatenation on two STRING properties.

String concatenation adding a prefix, suffix, and separator.

STRING values in a LIST can be concatenated using the reduce() function.

Concatenating a STRING value with NULL returns NULL. To skip the first NULL value in a list of expressions, use the coalesce() function.

List comprehension allows concatenating a STRING value to each item in a LIST to generate a new LIST of modified STRING values.

DURATION values can be added and subtracted from temporal instant values, such as LOCAL DATETIME.

When multiplying or dividing a DURATION, each component is handled separately. In multiplication, the value of each component is multiplied by the given factor, while in division, each component is divided by the given number. If the result of the division does not fit into the original components, it overflows into smaller components (e.g. converting days into hours).

The avg() function returns the average of a set of INTEGER or FLOAT values.

The avg() duration function returns the average of a set of DURATION values.

The collect() function returns a single aggregated list containing the non-null values returned by an expression.

The count() function returns the number of values or rows. When count(*) is used, the function returns the number of matching rows.

The count() function can also be passed an expression. If so, it returns the number of non-null values returned by the given expression.

The max() function returns the maximum value in a set of values.

The min() function returns the minimum value in a set of values.

The percentileCont() function returns the percentile of the given value over a group, with a percentile from 0.0 to 1.0. It uses a linear interpolation method, calculating a weighted average between two values if the desired percentile lies between them.

The percentileDisc() function returns the percentile of the given value over a group, with a percentile from 0.0 to 1.0. It uses a rounding method and calculates the nearest value to the percentile.

The stDev() function returns the standard deviation for the given value over a group. It uses a standard two-pass method, with N - 1 as the denominator, and should be used when taking a sample of the population for an unbiased estimate.

The stDevP() function returns the standard deviation for the given value over a group. It uses a standard two-pass method, with N as the denominator, and should be used when calculating the standard deviation for an entire population.

The sum() function returns the sum of a set of numeric values.

The sum() duration function returns the sum of a set of durations.

The db.nameFromElementId() function returns the name of a database to which the element id belongs. The name of the database can only be returned if the provided element id belongs to a standard database in the DBMS.

The duration() function can construct a DURATION from a MAP of its components.

The duration() from a string function returns the DURATION value obtained by parsing a STRING representation of a temporal amount.

The duration.between() function returns the DURATION value equal to the difference between the two given instants.

The duration.inDays() function returns the DURATION value equal to the difference in whole days or weeks between the two given instants.

The duration.inMonths() function returns the DURATION value equal to the difference in whole months between the two given instants.

The duration.inSeconds() function returns the DURATION value equal to the difference in seconds and nanoseconds between the two given instants.

The graph.names() function returns a list containing the names of all graphs on the current composite database. It is only supported on composite databases.

The graph.propertiesByName() function returns a map containing the properties associated with the given graph. The properties are set on the alias that adds the graph as a constituent of a composite database. It is only supported on composite databases.

The graph.byName() function resolves a constituent graph by name. It is only supported in the USE clause on composite databases.

The graph.byElementId() function is used in the USE clause to resolve a constituent graph to which a given element id belongs. If the constituent database is not a standard database in the DBMS, an error will be thrown.

The keys() function returns a LIST<STRING> containing the STRING representations for all the property names of a NODE, RELATIONSHIP, or MAP.

The labels() function returns a LIST<STRING> containing the STRING representations for all the labels of a NODE.

The nodes() function returns a LIST<NODE> containing all the NODE values in a PATH.

The range() function returns a LIST<INTEGER> comprising all INTEGER values within a range bounded by a start value and an end value, where the difference step between any two consecutive values is constant; i.e. an arithmetic progression.

The reduce() function returns the value resulting from the application of an expression on each successive element in a list in conjunction with the result of the computation thus far.

The relationships() function returns a LIST<RELATIONSHIP> containing all the RELATIONSHIP values in a PATH.

The reverse() function returns a LIST<ANY> in which the order of all elements in the given LIST<ANY> have been reversed.

The tail() function returns a LIST<ANY> containing all the elements, excluding the first one, from a given LIST<ANY>.

The toBooleanList() converts a LIST<ANY> and returns a LIST<BOOLEAN>. If any values are not convertible to BOOLEAN they will be null in the LIST<BOOLEAN> returned.

The toFloatList() converts a LIST<ANY> of values and returns a LIST<FLOAT>. If any values are not convertible to FLOAT they will be null in the LIST<FLOAT> returned.

The toIntegerList() converts a LIST<ANY> of values and returns a LIST<INTEGER>. If any values are not convertible to INTEGER they will be null in the LIST<INTEGER> returned.

The toStringList() converts a LIST<ANY> of values and returns a LIST<STRING>. If any values are not convertible to STRING they will be null in the LIST<STRING> returned.

The abs() function returns the absolute value of the given number.

The ceil() function returns the smallest FLOAT that is greater than or equal to the given number and equal to an INTEGER.

The floor() function returns the largest FLOAT that is less than or equal to the given number and equal to an INTEGER.

The isNan() function returns true if the given numeric value is NaN (Not a Number).

The rand() function returns a random FLOAT in the range from 0 (inclusive) to 1 (exclusive). The numbers returned follow an approximate uniform distribution.

The round() function returns the value of the given number rounded to the nearest INTEGER, with ties always rounded towards positive infinity.

The round() with precision function returns the value of the given number rounded to the closest value of given precision, with ties always being rounded away from zero (using rounding mode HALF_UP). The exception is for precision 0, where ties are rounded towards positive infinity to align with round() without precision.

The round() with precision and rounding mode function returns the value of the given number rounded with the specified precision and the specified rounding mode.

The sign() function returns the signum of the given number: 0 if the number is 0, -1 for any negative number, and 1 for any positive number.

The e() function returns the base of the natural logarithm, e.

The exp() function returns en, where e is the base of the natural logarithm, and n is the value of the argument expression.

The log() function returns the natural logarithm of a number.

The log10() function returns the common logarithm (base 10) of a number.

The sqrt() function returns the square root of a number.

The acos() function returns the arccosine of a FLOAT in radians.

The asin() function returns the arcsine of a FLOAT in radians.

The atan() function returns the arctangent of a FLOAT in radians.

The atan2() function returns the arctangent2 of a set of coordinates in radians.

The cos() function returns the cosine of a FLOAT.

The cot() function returns the cotangent of a FLOAT.

The degrees() function converts radians to degrees.

The haversin() function converts half the versine of a number.

The pi() function returns the mathematical constant pi.

The radians() function converts degrees to radians.

The sin() function returns the sine of a number.

The tan() function returns the tangent of a number.

The all() function returns true if the predicate holds for all elements in the given LIST<ANY>.

The any() function returns true if the predicate holds for at least one element in the given LIST<ANY>.

The exists() function returns true if a match for the given pattern exists in the graph.

The isEmpty() function returns true if the given LIST<ANY> or MAP contains no elements, or if the given STRING contains no characters.

The none() function returns true if the predicate does not hold for any element in the given LIST<ANY>.

The single() function returns true if the predicate holds for exactly one of the elements in the given LIST<ANY>.

The char_length() function returns the number of Unicode characters in a STRING. This function is an alias of the size() function.

The character_length() function returns the number of Unicode characters in a STRING. This function is an alias of the size() function.

The coalesce() function returns the first given non-null argument.

The elementId() function returns a STRING representation of a node or relationship identifier, unique within a specific transaction and DBMS.

The endNode() function returns the the end NODE of a RELATIONSHIP.

The head() function returns the first element of the list. Returns null for an empty list. Equivalent to the list indexing $list[0].

The id() function returns an INTEGER (the internal ID of a node or relationship). Do not rely on the internal ID for your business domain; the internal ID can change between transactions. It is recommended to use elementId instead.

The last() function returns the last element of the list. Returns null for an empty list. Equivalent to the list indexing $list[-1].

The length() function returns the length of a PATH.

The nullIf() function returns null if the two given parameters are equivalent, otherwise it returns the value of the first parameter.

The properties() function returns a MAP containing all the properties of a node or relationship.

The randomUUID() function returns a STRING; a randomly-generated universally unique identifier (UUID).

The size() function returns the number of elements in the list.

The function startNode() function returns the start NODE of a RELATIONSHIP.

The timestamp() function returns the time in milliseconds since midnight, January 1, 1970 UTC. and the current time.

The toBoolean() function converts a STRING, INTEGER or BOOLEAN value to a BOOLEAN value.

The toBooleanOrNull() function converts a STRING, INTEGER or BOOLEAN value to a BOOLEAN value. For any other input value, null will be returned.

The toFloat() function converts an INTEGER, FLOAT or a STRING value to a FLOAT.

The toFloatOrNull() function converts an INTEGER, FLOAT or a STRING value to a FLOAT. For any other input value, null will be returned.

The toInteger() function converts a BOOLEAN, INTEGER, FLOAT or a STRING value to an INTEGER value.

The toIntegerOrNull() function converts a BOOLEAN, INTEGER, FLOAT or a STRING value to an INTEGER value. For any other input value, null will be returned.

The type() function returns the STRING representation of the RELATIONSHIP type.

The valueType() function returns a STRING representation of the most precise value type that the given expression evaluates to.

The btrim() function returns the original STRING with leading and trailing trimCharacterString characters removed. If trimCharacterString is not specified then all leading and trailing whitespace will be removed.

The left() function returns a STRING containing the specified number of leftmost characters of the given STRING.

The lower() function returns the given STRING in lowercase. This function is an alias of the toLower function.

The ltrim() function returns the original STRING with leading trimCharacterString characters removed. If trimCharacterString is not specified then all leading whitespace will be removed.

The normalize() function returns a given STRING normalized using the NFC Unicode normalization form.

The replace() function returns a STRING in which all occurrences of a specified STRING in the given STRING have been replaced by another (specified) replacement STRING.

The reverse() function returns a STRING in which the order of all characters in the given STRING have been reversed.

The right() function returns a STRING containing the specified number of rightmost characters in the given STRING.

The rtrim() function returns the given STRING with trailing trimCharacterString characters removed. If trimCharacterString is not specified then all trailing whitespace will be removed.

The split() function returns a LIST<STRING> resulting from the splitting of the given STRING around matches of the given delimiter.

The substring() function returns a substring of the given STRING, beginning with a zero-based index start and length.

The toLower() function returns the given STRING in lowercase.

The toString() function converts an INTEGER, FLOAT, BOOLEAN, STRING, POINT, DURATION, DATE, ZONED TIME, LOCAL TIME, LOCAL DATETIME or ZONED DATETIME value to a STRING.

The toStringOrNull() function converts an INTEGER, FLOAT, BOOLEAN, STRING, POINT, DURATION, DATE, ZONED TIME, LOCAL TIME, LOCAL DATETIME or ZONED DATETIME value to a STRING. For any other input value, null will be returned.

The toUpper() function returns the given STRING in uppercase.

The trim() function returns the given STRING with leading and trailing whitespace removed.

The upper() function returns the given STRING in uppercase. This function is an alias of the toUpper() function.

The point() Cartesian 2D function returns a 2D POINT in the Cartesian CRS corresponding to the given coordinate values.

The point() Cartesian 3D function returns a 3D POINT in the Cartesian CRS corresponding to the given coordinate values.

The point() WGS 84 2D function returns a 2D POINT in the WGS 84 CRS corresponding to the given coordinate values.

The point() WGS 84 3D function returns a 3D POINT in the WGS 84 CRS corresponding to the given coordinate values.

The point.distance() function returns returns a FLOAT representing the geodesic distance between two points in the same Coordinate Reference System (CRS).

The point.withinBBox() function takes the following arguments: the POINT to check, the lower-left (south-west) POINT of a bounding box, and the upper-right (or north-east) POINT of a bounding box. The return value will be true if the provided point is contained in the bounding box (boundary included), otherwise the return value will be false.

The date function returns the current DATE value. If no time zone parameter is specified, the local time zone will be used.

The date.realtime() function returns the current DATE instant using the realtime clock.

The date.statement() function returns the current DATE instant using the statement clock.

The date.transaction() function returns the current DATE instant using the transaction clock.

The date.truncate() function truncates the given temporal value to a DATE instant using the specified unit.

The datetime() function creates a ZONED DATETIME instant.

The datetime.fromEpoch() function creates a ZONED DATETIME given the seconds and nanoseconds since the start of the epoch.

The datetime.fromEpochMillis() function creates a ZONED DATETIME given the milliseconds since the start of the epoch.

The datetime.realtime() function returns the current ZONED DATETIME instant using the realtime clock.

The datetime.statement() function returns the current ZONED DATETIME instant using the statement clock.

The datetime.transaction() function returns the current ZONED DATETIME instant using the transaction clock.

The datetime.truncate() function truncates the given temporal value to a ZONED DATETIME instant using the specified unit.

The localdatetime() function creates a LOCAL DATETIME instant.

The localdatetime.realtime() function returns the current LOCAL DATETIME instant using the realtime clock.

The localdatetime.statement() function returns the current LOCAL DATETIME instant using the statement clock.

The localdatetime.transaction() function returns the current LOCAL DATETIME instant using the transaction clock.

The localdatetime.truncate() function truncates the given temporal value to a LOCAL DATETIME instant using the specified unit.

The localtime() function creates a LOCAL TIME instant.

The localtime.realtime() function creates a LOCAL TIME instant. function returns the current LOCAL TIME instant using the realtime clock.

The localtime.statement() function creates a LOCAL TIME instant. function returns the current LOCAL TIME instant using the statement clock.

The localtime.transaction() function returns the current LOCAL TIME instant using the transaction clock.

The localtime.truncate() function truncates the given temporal value to a LOCAL TIME instant using the specified unit.

The time() function creates a ZONED TIME instant.

The time.realtime() function returns the current ZONED TIME instant using the realtime clock.

The time.statement() function returns the current ZONED TIME instant using the statement clock.

The time.transaction() function returns the current ZONED TIME instant using the transaction clock.

The time.truncate() function truncates the given temporal value to a ZONED TIME instant using the specified unit.

The vector.similarity.euclidean() function returns a FLOAT representing the similarity between the argument vectors based on their Euclidean distance.

The vector.similarity.cosine() function returns a FLOAT representing the similarity between the argument vectors based on their cosine.

Create a range index on relationships with type KNOWS and property since with the name index_name.

Create a composite range index with the name given by the parameter nameParam on nodes with label Person and the properties name and age, throws an error if the index already exist.

Create a composite range index with the name index_name on nodes with label Person and the properties name and age if it does not already exist, does nothing if it did exist.

Create a text index on relationships with type KNOWS and property city. Text indexes only solve predicates involving STRING property values.

Create a point index on nodes with label Person and property location with the name index_name and the given spatial.cartesian settings. The other index settings will have their default values. Point indexes only solve predicates involving POINT property values.

Create a point index with the name given by the parameter nameParam on relationships with the type STREET and property intersection. Point indexes only solve predicates involving POINT property values.

Create a token lookup index on nodes with any label.

Create a token lookup index on relationships with any relationship type.

List all indexes, returns only the default outputs (id, name, state, populationPercent, type, entityType, labelsOrTypes, properties, indexProvider, owningConstraint, lastRead, and readCount).

List all indexes and return all columns.

List all indexes and return only specific columns.

List all indexes and return only specific columns using the RETURN clause. Note that YIELD is mandatory if RETURN is used.

List range indexes, can also be filtered on ALL, FULLTEXT, LOOKUP, POINT, TEXT, and VECTOR.

Drop the index named index_name, throws an error if the index does not exist.

Drop the index named index_name if it exists, does nothing if it does not exist.

Drop an index using a parameter.

Index usage can be enforced when Cypher uses a suboptimal index, or when more than one index should be used.

Create a fulltext index on nodes with the name index_name and analyzer swedish. The other index settings will have their default values.

Create a fulltext index on relationships with the name index_name and analyzer english. The other index settings will have their default values.

Query a full-text index on nodes.

Query a full-text index on relationships.

List all full-text indexes.

Drop a full-text index.

Create a vector index on nodes with label Abstract, property embedding, and a vector dimension of 1536 using the cosine similarity function and the name abstract-embeddings. Note that the OPTIONS map is mandatory since a vector index cannot be created without setting the vector dimensions and similarity function.

Create a vector index on relationships with relationship type REVIEWED, property embedding, and a vector dimension of 256 using the cosine similarity function and the name review-embeddings. Note that the OPTIONS map is mandatory since a vector index cannot be created without setting the vector dimensions and similarity function.

Query the node vector index abstract-embeddings for a neighborhood of 10 similar abstracts.

Query the relationship vector index review-embeddings for a neighborhood of 10 similar reviews to the vector given by the query parameter.

Set the vector properties of a node using db.create.setNodeVectorProperty.

Set the vector properties of a relationship using db.create.setRelationshipVectorProperty.

List all vector indexes.

Drop a vector index.

List all constraints, returns only the default outputs (id, name, type, entityType, labelsOrTypes, properties, ownedIndex, and propertyType). Can also be filtered on NODE UNIQUENESS, RELATIONSHIP UNIQUENESS, UNIQUENESS, NODE EXISTENCE, RELATIONSHIP EXISTENCE, EXISTENCE, NODE PROPERTY TYPE, RELATIONSHIP PROPERTY TYPE, PROPERTY TYPE, NODE KEY, RELATIONSHIP KEY, and KEY. For more information, see Constraints → Syntax → SHOW CONSTRAINTS.

List all constraints. For more information, see Constraints → Create, show, and drop constraints → SHOW CONSTRAINTS.

Drop the constraint with the name constraint_name, throws an error if the constraint does not exist.

Drop the constraint with the name given by the parameter nameParam if it exists, does nothing if it does not exist.

Create a node property uniqueness constraint on the label Person and properties name and age. An error will be thrown if an attempt is made to create the same constraint twice. If any node with that label is updated or created with a name and age combination that already exists, the write operation will fail.

List all databases in Neo4j DBMS and information about them, returns only the default outputs (name, type, aliases, access, address, role, writer, requestedStatus, currentStatus, statusMessage, default, home, and constituents).

List all databases in Neo4j DBMS and information about them.

List information about databases, filtered by name and currentStatus and further refined by conditions on these.

List information about the database database-name.

List the default Cypher version of databases.

List information about the default database, for the Neo4j DBMS.

List information about the current users home database.

List all users in Neo4j DBMS, returns only the default outputs (user, roles, passwordChangeRequired, suspended, and home).

List the currently logged-in user, returns only the default outputs (user, roles, passwordChangeRequired, suspended, and home).

List users that must change their password at the next login.

List users with their auth providers. Will return one row per user per auth provider.

List users who have the oidc1 auth provider.

Delete the specified user.

Create a new user and set the password. This password must be changed on the first login.

Create a new user and set the password using the auth provider syntax. This password must be changed on the first login.

Rename the specified user.

Change the password of the logged-in user. The user will not be required to change this password on the next login.

Set a new password (a String) for a user. This user will not be required to change this password on the next login.

If the specified user exists, force this user to change the password on the next login.