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.
See CaseExpression.
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
ExposesUnwind.unwind(Expression...),ExposesUnwind.unwind(Expression), ExposesUnwind.unwind(String) and method.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.
ListComprehension.OngoingDefinitionWithVariable.in(Expression) must be used to define the source list.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.
See NodePattern.
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.
See PatternElement.
A marker interface used for pattern appearing in
exists or size statements.See StandaloneCall.
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.
See PropertyLookup
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
See RelationshipPattern.
See RelationshipDetail.
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 the
StatementBuilder.TerminalExposesLimit.limit(Number) method.A step that exposes several methods to specify ordering.
A step that exposes the
StatementBuilder.TerminalExposesSkip.skip(Number) method.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.