All Classes and Interfaces

Class
Description
An element with an alias.
An aliased expression, that deals with named expressions when accepting visitors.
The *.
The boolean literal.
Specification for a renderable, complete CASE statement
Extension of the Case interface to support generic case.
Helper class to collect `when` expressions and create CaseWhenThen instances when the `then` is provided.
Extension the Case interface to support simple case with an initial expression / condition.
Simple version of the JSR 305 annotation that allows detecting accidentally omitted calls to Cypher.match(org.neo4j.cypherdsl.core.PatternElement...) ()} and the likes in IntelliJ.
This is a marker interface for top level clauses.
Builder / factory for various clauses.
Implementing COLLECT subqueries
A concrete condition representing a comparision between two expressions.
Shared interface for all conditions.
This class provides some configuration settings for the Cypher-DSL, mainly around rendering of a statement.
Use this builder to create new Configuration instances.
Enum for configuring name rewriting.
Enum for the available indent styles.
Simple definition of a known / schema relationship.
Exception thrown when extracting parameters from a statement leads to one parameter with a given name appearing with different values.
A constant condition that is either always true or false.
Added for supporting the Neo5j parser.
See Create.
The main entry point into the Cypher DSL.
See Delete.
The dialect to be used when rendering a statement into Cypher.
Result of entering a Visitable.
This interface extends ExecutableStatement and adds several fetchWithXXX methods that can be used with any ResultStatement to retrieve their results.
This interface spots several methods that allow statements to be used with an instance of the Neo4j Java Driver.
An existential sub-query can only be used in a where clause.
Allows chaining of statements to some other builders.
Entrypoint for building procedure calls.
Interface to allow creating an expression instead of a statement from an ongoing definition.
Used to provide arguments to procedure calls.
Used to yield procedure result fields.
A step exposing a ExposesCreate.create(PatternElement...) method.
A step exposing a several using methods that are provide entry points of adding advanced query hints.
Exposes methods to configure a LOAD CSV clause.
A step exposing logical operators and and or after a where clause.
A step exposing a ExposesMatch.match(PatternElement...) method.
A step exposing a ExposesMerge.merge(PatternElement...) method.
This interface is used to derive new relationship patterns from existing relationships or chains of relationships with new lengths (min, max or unbounded) configured.
A container that exposes methods to add properties with values to nodes or relationships.
A marker interface for things that expose methods to create new relationships to other elements.
Return part of a statement.
This exposes a call method taking in a statement that represents a valid, correlated subquery.
Subqueries can be valid without any further return statement (i.e when the subquery is a void (unit) one, meaning it doesn't yield or return its results.
A step exposing a several where methods that are provide entry points of adding conditions.
A step that exposes the WITH clause.
An expression can be used in many places, i.e. in return statements, pattern elements etc.
Represents the FOREACH clause and is currently only producible via the Cypher-Parser.
Represents an adapter that allows to turn foreign expressions into Cypher-DSL expressions.
Defines metadata for a function.
This is a more general renderer than Renderer.
A condition checking for the presence of labels on nodes or types on relationships.
Visitable implementing hints.
This interface represents an element that can be for example an identifiable part of the WITH clause.
Used for subqueries IN TRANSACTIONS
Helper class, only for internal use.
Represents a label expression, usable in Cypher.node(LabelExpression).
Type of this expression
 
Allows to add a where clause into the definition of the list.
Provides the final step of defining a list comprehension.
Represents a list expression as in [expression1, expression2, ..., expressionN]
A list of literals.
Represents a range literal applied to another expression.
Represents a literal with an optional content.
Thrown when a given object cannot be used as a Cypher-DSL-Literal.
 
An instance of this interface will be provided after pointing the database to a valid URI of a CSV resource.
A dedicated map expression.
A map of literals.
Represents a map projection as described here.
See Match.
See Create.
An action or event that happens after a MERGE clause.
The type of the action.
A named thing exposes Named.getSymbolicName(), making the thing identifiable.
Represents a named path.
Partial path that has a name (p = ).
Partial path that has a name (p = ) and is based on a graph algorithm function.
This annotation provides information which Neo4j version is required to be able to successfully run a query containing a fragment generated via a method annotated with it.
 
This is the base class for all nodes.
Expression for a single Node label.
Represents the literal value null.
 
Allows to define the source of the list predicate.
Allows to specify the where condition for the list based predicate.
A binary operation.
An operator.
Operator type.
Represents the list of sort items that make up the order of records in a result set.
Represents a named parameter inside a Cypher statement.
Provides the final step of defining a pattern comprehension.
Allows to add a where clause into the definition of the pattern.
Intermediate step that allows expressing additional, logical operators.
A marker interface used for pattern appearing in exists or size statements.
Represents the properties of a node or a relationship when used as part of the whole pattern (inside a MATCH, CREATE or MERGE clause as {p1: v1, p2: v2, pn: vn}.
A property.
This interface represents an element that has properties.
A container having properties.
 
 
Quantifier for path patterns.
Synthetic element for the Cypher-DSL AST.
This interface extends ReactiveExecutableStatement and adds several fetchWithXXX methods that can be used with any ResultStatement to retrieve their results in a reactive fashion.
This is an extended version of the ExecutableStatement, spotting an additional ReactiveExecutableStatement.executeWith(ReactiveQueryRunner) that runs a statement in a reactive fashion.
A typed subtree representing the arguments of a call to the reduce() function.
Step 4b: Define the initial value
Step 3: Define the map expression
Step 4a: Define the accumulator
Step 2: Define the list
While the direction in the schema package is centered around the node, the direction here is the direction between two nodes.
This is the base class for all relationships.
Represents a chain of relationships.
A shared, public interface for relationships and chains of relationships.
See Remove.
Instances of this class are supposed to be thread-safe.
A statement that returns items from the graph.
See Return.
The container or "body" for return items, order and optional skip and things.
Thrown when schema validation fails.
See Set.
 
A sort item can be used in an ORDER BY clause and changes the order of the items being returned from a query.
Sort direction.
Shall be the common interfaces for queries that we support.
Represents RegularQuery.
Represents a SingleQuery.
Represents a UnionQuery.
Represents a USE statement, utilizing a composite graph call.
 
A buildable ongoing MATCH and UPDATE.
An interface combining a buildable MATCH and UPDATE with the possibility to add actions after a MERGE clause.
A statement that has all information required to be build and exposes a build method.
A step that exposes only the DELETE clause.
A shared marker interface for things that can be turned into a subquery to be used inside the WHERE clause.
Steps for building a Foreach clause.
A step that exposes the StatementBuilder.ExposesLimit.limit(Number) method.
Provides a way to specify an action that happens after a MERGE clause.
See StatementBuilder.TerminalExposesOrderBy, but on a with clause.
Set part of a statement.
A step that exposes the set clause.
Exposes node mutations.
A step that exposes the StatementBuilder.ExposesSkip.skip(Number) method.
A step providing all the supported updating clauses (DELETE, SET)
A trait for an ongoing standalone call to expose all of its results via an asterisk.
Initial step of defining a FOREACH-clause.
Second step of defining a FOREACH-clause in which the updating clause is defined.
The union of an in-query call exposing yields.
The union of an in-query call exposing new arguments and yields.
An in-query call exposing where and return clauses.
Combines the capabilities of skip, limit and adds additional expressions to the order-by items.
After a MATCH..UPDATE chain has been established, a RETURN can be added, a pipeline with WITH can be started or more mutating steps can be added.
An ongoing update statement that can be used to chain more updating statements, define actions on a merge or add a with or return clause.
A variant of StatementBuilder.ExposesSet that allows for further chaining of actions.
An intermediate step while defining the order of a with clause.
A match that exposes returning and for which it is not decided whether the optional where part has been used or note.
A match that knows what to return and which is ready to be build.
Represents a reading statement ending in a with clause, potentially already having an order and not exposing order methods.
The union type of an ongoing reading with a WITH and a SKIP clause.
Combines the capabilities of skip, limit and adds additional expressions to the order-by items.
A match that exposes returning and where methods to add required information.
A match that has a non-empty where-part.
The union of a buildable statement and call exposing yields.
The union of a buildable statement and call exposing new arguments and yields.
A buildable statement exposing where and return clauses.
Builder part for unwinding.
An ongoing update statement that can be used to chain more update statements or add a with or return clause.
 
A match that knows what to pipe to the next part of a multipart query.
 
A step that exposes several methods to specify ordering.
An intermediate step while defining the order of a result set.
The result of a call to a stored procedure not having any results.
The statement catalog gives an overview about relevant items in a statement.
Enum for the clause in which a comparison was made.
This interface represents all kinds of filters in a query such as filters on labels and filters on properties.
This type represents a filter on nodes requiring one or more labels.
A property that has been resolved.
This type encapsulates a comparison in which a property of a node or relationship was used.
A token can either describe a node label or a relationship type.
The specific token type.
Context for while rendering a statement.
The string representation of a string literal will be a quoted Cypher string in single tickmarks with escaped reserved characters.
Represents a "callable" sub-query.
A sub-query expression can either be an EXISTS-tential or a COUNT expression as of Neo4j 5.
Something that can build counting sub-queries.
A symbolic name to identify nodes, relationships and aliased items.
A literal representing a temporal value to be formatted in a way that Neo4j's Cypher understands it.
A mutable tree structure providing Breadth-first search (aka in-level order traversal) and pre-ordered depth-first search.
This class helps to group items of the same type on the same level of the tree into a list structure that can be recognized by visitors.
Represents a part of a union.
See Unwind.
 
The USE clause can be prepended to statements or be used in a CALL subquery.
Interface for implementations that accepts visitors.
 
Sometimes it will be necessary - for example in dialects - to change the flow of elements visited.
Roughly corresponding to Where.
See With.