Uses of Interface
org.neo4j.cypherdsl.core.Expression

Packages that use Expression

Package	Description
org.neo4j.cypherdsl.core	Contains an internal DSL for creating Cypher.

Uses of Expression in org.neo4j.cypherdsl.core

Subinterfaces of Expression in org.neo4j.cypherdsl.core

Modifier and Type	Interface	Description
interface	Case	See CaseExpression.
static interface	Case.CaseEnding	Specification for a renderable, complete CASE statement
static interface	Case.GenericCase	Extension of the Case interface to support generic case.
static interface	Case.SimpleCase	Extension the Case interface to support simple case with an initial expression / condition.
interface	Condition	Shared interface for all conditions.
interface	Literal<T>	Represents a literal with an optional content.
interface	Property	A property.
interface	SubqueryExpression	A sub-query expression can either be an EXISTS-tential or a COUNT expression as of Neo4j 5.

Classes in org.neo4j.cypherdsl.core that implement Expression

Modifier and Type	Class	Description
final class	AliasedExpression	An aliased expression, that deals with named expressions when accepting visitors.
final class	Asterisk	The *.
final class	BooleanLiteral	The boolean literal.
final class	CollectExpression	Implementing COLLECT subqueries
final class	Comparison	A concrete condition representing a comparision between two expressions.
final class	ConstantCondition	A constant condition that is either always true or false.
final class	CountExpression	Added for supporting the Neo5j parser.
final class	ExistentialSubquery	An existential sub-query can only be used in a where clause.
final class	FunctionInvocation	See FunctionInvocation
final class	HasLabelCondition	A condition checking for the presence of labels on nodes or types on relationships.
final class	KeyValueMapEntry	Helper class, only for internal use.
final class	ListComprehension	See ListComprehension and the corresponding cypher manual entry.
final class	ListExpression	Represents a list expression as in [expression1, expression2, ..., expressionN]
final class	ListLiteral	A list of literals.
final class	ListOperator	Represents a range literal applied to another expression.
final class	MapExpression	A dedicated map expression.
final class	MapLiteral	A map of literals.
final class	MapProjection	Represents a map projection as described here.
final class	NestedExpression
final class	NullLiteral	Represents the literal value null.
final class	NumberLiteral
final class	Operation	A binary operation.
final class	Parameter<T>	Represents a named parameter inside a Cypher statement.
final class	PatternComprehension	See PatternComprehension and the corresponding cypher manual entry.
final class	PropertyLookup	See PropertyLookup
final class	StringLiteral	The string representation of a string literal will be a quoted Cypher string in single tickmarks with escaped reserved characters.
final class	SymbolicName	A symbolic name to identify nodes, relationships and aliased items.
final class	TemporalLiteral	A literal representing a temporal value to be formatted in a way that Neo4j's Cypher understands it.

Methods in org.neo4j.cypherdsl.core with type parameters of type Expression

Modifier and Type	Method	Description
static <T extends Expression> Expression	Cypher.nameOrExpression(T expression)

Methods in org.neo4j.cypherdsl.core that return Expression

Modifier and Type	Method	Description
@NotNull Expression	AliasedExpression.asExpression()
@NotNull Expression	Asterisk.asExpression()
@NotNull Expression	ForeignAdapter.asExpression()	Adapts a foreign expression into a Cypher-DSL Expression.
@NotNull Expression	IdentifiableElement.asExpression()	Transform this element into an expression
default @NotNull Expression	Named.asExpression()
@NotNull Expression	SymbolicName.asExpression()
default @NotNull Expression	ExposesCall.AsFunction.asFunction()
@NotNull Expression	ExposesCall.AsFunction.asFunction(boolean distinct)
static @NotNull Expression	Cypher.collect(Statement statement)	Creates a COLLECT subquery from a statement, including its filters and conditions.
default @NotNull Expression	Property.getContainerReference()
Expression	KeyValueMapEntry.getValue()
Expression	StatementCatalog.PropertyFilter.left()	Returns the value of the left record component.
static <T extends Expression> Expression	Cypher.nameOrExpression(T expression)
static Expression	Cypher.plus(Expression e)	Creates an unary plus operation.
static @NotNull Expression	Cypher.raw(String format, Object... mixedArgs)	Creates an expression from a raw string fragment.
Expression	StatementCatalog.PropertyFilter.right()	Returns the value of the right record component.
default @NotNull Expression	Expression.size()	This creates a size(e) expression from this expression.
static @NotNull Expression	Cypher.subList(Expression targetExpression, Integer start, Integer end)	Creates a closed range with given boundaries.
static @NotNull Expression	Cypher.subList(Expression targetExpression, Expression start, Expression end)	Creates a closed range with given boundaries.
static @NotNull Expression	Cypher.subListFrom(Expression targetExpression, Integer start)	Creates an open range starting at start.
static @NotNull Expression	Cypher.subListFrom(Expression targetExpression, Expression start)	Creates an open range starting at start.
static @NotNull Expression	Cypher.subListUntil(Expression targetExpression, Integer end)	Creates an open range starting at start.
static @NotNull Expression	Cypher.subListUntil(Expression targetExpression, Expression end)	Creates an open range starting at start.

Methods in org.neo4j.cypherdsl.core that return types with arguments of type Expression

Modifier and Type	Method	Description
Collection<Expression>	StatementBuilder.OngoingReadingAndReturn.getIdentifiableExpressions()
Collection<Expression>	StatementBuilder.OrderableOngoingReadingAndWith.getIdentifiableExpressions()
Collection<Expression>	StatementCatalog.getIdentifiableExpressions()	Returns a collection of all expressions that are identifiable expression in a non-void (or non-unit) Cypher statement.
List<Expression>	With.getItems()

Methods in org.neo4j.cypherdsl.core with parameters of type Expression

Modifier and Type	Method	Description
static @NotNull FunctionInvocation	Cypher.abs(@NotNull Expression expression)	Creates a function invocation for abs({}).
@NotNull Reduction.OngoingDefinitionWithInitial	Reduction.OngoingDefinitionWithReducer.accumulateOn(Expression accumulator)
static @NotNull FunctionInvocation	Cypher.acos(@NotNull Expression expression)	Creates a function invocation for acos({}).
static Operation	Cypher.add(Expression op1, Expression op2)
default @NotNull Operation	Expression.add(Expression addend)	Creates a + operation of this (the augend) and the addend.
@NotNull StatementBuilder.TerminalOngoingOrderDefinition	StatementBuilder.OngoingMatchAndReturnWithOrder.and(@NotNull Expression expression)	Adds another expression to the list of order items.
@NotNull StatementBuilder.OngoingOrderDefinition	StatementBuilder.OngoingReadingAndWithWithWhereAndOrder.and(@NotNull Expression expression)	Adds another expression to the list of order items.
static @NotNull FunctionInvocation	Cypher.asin(@NotNull Expression expression)	Creates a function invocation for asin({}).
static @NotNull FunctionInvocation	Cypher.atan(@NotNull Expression expression)	Creates a function invocation for atan({}).
static @NotNull FunctionInvocation	Cypher.atan2(@NotNull Expression y, @NotNull Expression x)	Creates a function invocation for atan2({}).
static @NotNull FunctionInvocation	Cypher.avg(Expression expression)	Creates a function invocation for the avg() function.
static @NotNull FunctionInvocation	Cypher.avgDistinct(Expression expression)	Creates a function invocation for the avg() function with DISTINCT added.
static @NotNull Case	Cypher.caseExpression(@Nullable Expression expression)
static @NotNull FunctionInvocation	Cypher.ceil(@NotNull Expression expression)	Creates a function invocation for ceil({}).
static @NotNull FunctionInvocation	Cypher.coalesce(Expression... expressions)	Creates a function invocation for the coalesce() function.
static @NotNull FunctionInvocation	Cypher.collect(Expression expression)	Creates a function invocation for the collect() function.
static @NotNull FunctionInvocation	Cypher.collectDistinct(Expression expression)	Creates a function invocation for the collect() function with DISTINCT added.
static Operation	Cypher.concat(Expression op1, Expression op2)
default @NotNull Operation	Expression.concat(Expression expression)	Creates an expression concatenating two string or list expressions.
static Condition	Cypher.contains(Expression lhs, Expression rhs)	Creates a condition that checks whether the lhs contains with the rhs.
default @NotNull Condition	Expression.contains(Expression expression)	Creates a condition that checks whether this expression contains that expression.
static @NotNull FunctionInvocation	Cypher.cos(@NotNull Expression expression)	Creates a function invocation for cos({}).
static @NotNull FunctionInvocation	Cypher.cot(@NotNull Expression expression)	Creates a function invocation for cot({}).
static @NotNull FunctionInvocation	Cypher.count(Expression expression)	Creates a function invocation for the count() function.
static @NotNull FunctionInvocation	Cypher.countDistinct(Expression expression)	Creates a function invocation for a count() function with DISTINCT added.
static Case	Case.create(@Nullable Expression expression)	Creates a new Case Expression
static FunctionInvocation	FunctionInvocation.create(FunctionInvocation.FunctionDefinition definition, Expression... expressions)	Creates a FunctionInvocation based on a simple definition with arguments.
static @NotNull KeyValueMapEntry	KeyValueMapEntry.create(@NotNull String key, @NotNull Expression value)	Create a new KeyValueMapEntry.
static FunctionInvocation	FunctionInvocation.createDistinct(FunctionInvocation.FunctionDefinition definition, Expression... expressions)	Creates a FunctionInvocation based on a simple definition with arguments and adds the distinct operator to it.
static @NotNull FunctionInvocation	Cypher.date(@NotNull Expression temporalValue)	Creates a function invocation for date({}).
static @NotNull FunctionInvocation	Cypher.datetime(@NotNull Expression temporalValue)	Creates a function invocation for datetime({}).
static @NotNull FunctionInvocation	Cypher.degrees(@NotNull Expression expression)	Creates a function invocation for degrees({}).
@NotNull StatementBuilder.OngoingUpdate	StatementBuilder.ExposesDelete.delete(Expression... expressions)	Creates a delete step with one or more expressions to be deleted.
@NotNull StatementBuilder.OngoingUpdate	StatementBuilder.ExposesDelete.detachDelete(Expression... expressions)	Starts building a delete step that will use DETACH to remove relationships.
static @NotNull FunctionInvocation	Cypher.distance(@NotNull Expression point1, @NotNull Expression point2)	Creates a function invocation for the distance() function.
static Operation	Cypher.divide(Expression op1, Expression op2)
default @NotNull Operation	Expression.divide(Expression dividend)	Creates a / operation of this (the divisor) and the dividend.
static @NotNull FunctionInvocation	Cypher.duration(@NotNull Expression temporalAmount)	Creates a function invocation for duration({}).
@NotNull Case	Case.CaseEnding.elseDefault(Expression defaultExpression)	Ends this case expression with a default expression to evaluate.
static Condition	Cypher.endsWith(Expression lhs, Expression rhs)	Creates a condition that checks whether the lhs ends with the rhs.
default @NotNull Condition	Expression.endsWith(Expression expression)	Creates a condition that checks whether this expression ends with that expression.
default @NotNull Condition	Expression.eq(Expression rhs)	An alias for isEqualTo(Expression).
static @NotNull FunctionInvocation	Cypher.exists(Expression expression)	Creates a function invocation for the exists() function.
static @NotNull FunctionInvocation	Cypher.exp(@NotNull Expression expression)	Creates a function invocation for exp({}).
static @NotNull FunctionInvocation	Cypher.floor(@NotNull Expression expression)	Creates a function invocation for floor({}).
static Clause	Clauses.forEach(SymbolicName v, Expression list, List<Clause> updatingClauses)	Creates a literal for each clause.
static String	Cypher.format(Expression expression)	Tries to format this expression into something human-readable.
static @Nullable Where	Where.from(@Nullable Expression optionalWhere)	Creates a new WHERE
static @NotNull FunctionInvocation	Cypher.graphByName(Expression name)	Creates a function invocation for graph.byName().
static @NotNull FunctionInvocation	Cypher.graphPropertiesByName(Expression name)	Creates a function invocation for graph.propertiesByName().
static Condition	Cypher.gt(Expression lhs, Expression rhs)	Creates a condition that matches if the left hand side is greater than the right hand side..
default @NotNull Condition	Expression.gt(Expression rhs)	Creates a lhs > rhs condition.
static Condition	Cypher.gte(Expression lhs, Expression rhs)	Creates a condition that matches if the left hand side is greater than or equal the right hand side..
default @NotNull Condition	Expression.gte(Expression rhs)	Creates a lhs >= rhs condition.
default @NotNull Condition	Expression.hasSize(Expression expectedSize)	Takes the size() expresssions and compares it for equality with the parameter expectedSize.
static @NotNull FunctionInvocation	Cypher.haversin(@NotNull Expression expression)	Creates a function invocation for haversin({}).
static @NotNull FunctionInvocation	Cypher.head(Expression expression)	Creates a function invocation for the head() function.
default @NotNull Condition	Expression.in(Expression haystack)	Creates a IN operation for this expression and that expression.
@NotNull ListComprehension.OngoingDefinitionWithList	ListComprehension.OngoingDefinitionWithVariable.in(Expression list)	Create a list comprehension past on a literal list.
@NotNull OngoingListBasedPredicateFunctionWithList	OngoingListBasedPredicateFunction.in(Expression list)
@NotNull Reduction.OngoingDefinitionWithList	Reduction.OngoingDefinitionWithVariable.in(Expression list)
StatementBuilder.ForeachUpdateStep	StatementBuilder.ForeachSourceStep.in(Expression list)	Defines the source to be iterated by FOREACH.
static Condition	Cypher.includesAll(Expression lhs, Expression rhs)	Creates a condition that checks whether the lhs includes all elements present in rhs.
default @NotNull Condition	Expression.includesAll(Expression rhs)	Creates a condition that checks whether this expression includes all elements of rhs.
static Condition	Cypher.includesAny(Expression lhs, Expression rhs)	Creates a condition that checks whether the lhs includes any element present in rhs.
default @NotNull Condition	Expression.includesAny(Expression rhs)	Creates a condition that checks whether this expression includes any element of rhs.
static Condition	Cypher.isEmpty(Expression expression)	Creates a new condition based on a function invocation for the isEmpty() function.
static Condition	Cypher.isEqualTo(Expression lhs, Expression rhs)	Creates a condition that matches if both expressions are equals according to =.
default @NotNull Condition	Expression.isEqualTo(Expression rhs)	Creates a lhs = rhs condition.
static Condition	Cypher.isNotEqualTo(Expression lhs, Expression rhs)	Creates a condition that matches if both expressions are equals according to <>.
default @NotNull Condition	Expression.isNotEqualTo(Expression rhs)	Creates a lhs <> rhs condition.
static Condition	Cypher.isNotNull(Expression expression)	Creates a condition that checks whether the expression is not null.
static Condition	Cypher.isNull(Expression expression)	Creates a condition that checks whether the expression is null.
static @NotNull FunctionInvocation	Cypher.keys(@NotNull Expression expression)	Creates a function invocation for keys{}.
static @NotNull FunctionInvocation	Cypher.last(Expression expression)	Creates a function invocation for the last() function.
static @NotNull FunctionInvocation	Cypher.left(Expression expression, Expression length)	Creates a function invocation for the left() function.
@NotNull StatementBuilder.OngoingReadingAndWith	StatementBuilder.ExposesLimit.limit(Expression expression)	Limits the number of returned records.
@NotNull StatementBuilder.BuildableStatement<ResultStatement>	StatementBuilder.TerminalExposesLimit.limit(Expression expression)	Limits the number of returned records.
static @NotNull ListExpression	Cypher.listOf(Expression... expressions)	Creates a list-expression from several expressions.
static @NotNull FunctionInvocation	Cypher.localdatetime(@NotNull Expression temporalValue)	Creates a function invocation for localdatetime({}).
static @NotNull FunctionInvocation	Cypher.localtime(@NotNull Expression temporalValue)	Creates a function invocation for localtime({}).
static @NotNull FunctionInvocation	Cypher.log(@NotNull Expression expression)	Creates a function invocation for log({}).
static @NotNull FunctionInvocation	Cypher.log10(@NotNull Expression expression)	Creates a function invocation for log10({}).
static Condition	Cypher.lt(Expression lhs, Expression rhs)	Creates a condition that matches if the left hand side is less than the right hand side..
default @NotNull Condition	Expression.lt(Expression rhs)	Creates a lhs < rhs condition.
static Condition	Cypher.lte(Expression lhs, Expression rhs)	Creates a condition that matches if the left hand side is less than or equal the right hand side..
default @NotNull Condition	Expression.lte(Expression rhs)	Creates a lhs <= rhs condition.
static @NotNull FunctionInvocation	Cypher.ltrim(@NotNull Expression expression)	Creates a function invocation for the ltrim() function.
@NotNull Reduction.OngoingDefinitionWithReducer	Reduction.OngoingDefinitionWithList.map(Expression mapper)
static Condition	Cypher.matches(Expression lhs, Expression rhs)	Creates a condition that matches if the right hand side is a regular expression that matches the the left hand side via =~.
default @NotNull Condition	Expression.matches(Expression expression)	Creates a condition that checks whether this expression matches that expression.
static @NotNull FunctionInvocation	Cypher.max(Expression expression)	Creates a function invocation for the max() function.
static @NotNull FunctionInvocation	Cypher.maxDistinct(Expression expression)	Creates a function invocation for the max() function with DISTINCT added.
static @NotNull FunctionInvocation	Cypher.min(Expression expression)	Creates a function invocation for the min() function.
static @NotNull FunctionInvocation	Cypher.minDistinct(Expression expression)	Creates a function invocation for the min() function with DISTINCT added.
static Operation	Cypher.minus(Expression e)	Creates an unary minus operation.
static Operation	Cypher.multiply(Expression op1, Expression op2)
default @NotNull Operation	Expression.multiply(Expression multiplicand)	Creates a * operation of this (the multiplier) and the multiplicand.
static Operation	Cypher.mutate(Expression target, Expression value)	Creates a += operation.
static Operation	Cypher.mutate(Expression target, MapExpression value)	Creates a += operation.
@NotNull StatementBuilder.BuildableMatchAndUpdate	StatementBuilder.ExposesSet.mutate(Expression target, Expression properties)	Creates a += operation.
default @NotNull StatementBuilder.BuildableMatchAndUpdate	StatementBuilder.ExposesSet.mutate(Named variable, Expression properties)	Creates a += operation.
@NotNull StatementBuilder.BuildableOngoingMergeAction	StatementBuilder.OngoingMergeAction.mutate(Expression target, Expression properties)	Creates a += operation.
default @NotNull StatementBuilder.BuildableOngoingMergeAction	StatementBuilder.OngoingMergeAction.mutate(Named variable, Expression properties)	Creates a += operation.
default @NotNull Condition	Expression.ne(Expression rhs)	An alias for isNotEqualTo(Expression).
@NotNull StatementBuilder.OngoingOrderDefinition	StatementBuilder.ExposesOrderBy.orderBy(@NotNull Expression expression)	Order the result set by an expression.
@NotNull StatementBuilder.TerminalOngoingOrderDefinition	StatementBuilder.TerminalExposesOrderBy.orderBy(@NotNull Expression expression)	Order the result set by an expression.
static @NotNull FunctionInvocation	Cypher.percentileCont(Expression expression, Number percentile)	Creates a function invocation for the percentileCont() function.
static @NotNull FunctionInvocation	Cypher.percentileContDistinct(Expression expression, Number percentile)	Creates a function invocation for the percentileCont() function with DISTINCT added.
static @NotNull FunctionInvocation	Cypher.percentileDisc(Expression expression, Number percentile)	Creates a function invocation for the percentileDisc() function.
static @NotNull FunctionInvocation	Cypher.percentileDiscDistinct(Expression expression, Number percentile)	Creates a function invocation for the percentileDisc() function with DISTINCT added.
static Expression	Cypher.plus(Expression e)	Creates an unary plus operation.
static @NotNull FunctionInvocation	Cypher.point(Expression expression)	Creates a function invocation for the point() function.
static Operation	Cypher.pow(Expression op1, Expression op2)
default @NotNull Operation	Expression.pow(Expression n)	Returns the power of n of this value.
protected Visitable	MapExpression.prepareVisit(Expression child)
static @NotNull Property	Cypher.property(String containerName, Expression lookup)	Creates a dynamic lookup of a property for a symbolic name, most likely pointing to a property container like a node or a relationship.
static @NotNull Property	Cypher.property(Expression expression, String... names)	Dereferences a property on a arbitrary expression.
static @NotNull Property	Cypher.property(Expression expression, Collection<String> names)	Dereferences a property on a arbitrary expression.
static @NotNull Property	Cypher.property(Expression expression, Expression lookup)	Creates a dynamic lookup of a property on a arbitrary expression.
default @NotNull Property	Expression.property(@NotNull Expression lookup)	Creates a new Property associated with this property container.
@NotNull Property	PropertyAccessor.property(@NotNull Expression lookup)	Creates a new Property associated with this element.
static @NotNull FunctionInvocation	Cypher.radians(@NotNull Expression expression)	Creates a function invocation for radians({}).
static @NotNull FunctionInvocation	Cypher.range(@NotNull Expression start, @NotNull Expression end)
static @NotNull FunctionInvocation	Cypher.range(@NotNull Expression start, @NotNull Expression end, Expression step)	Creates a function invocation for the range() function.
static Operation	Cypher.remainder(Expression op1, Expression op2)
default @NotNull Operation	Expression.remainder(Expression dividend)	Returns the remainder of this value and the dividend.
static @NotNull FunctionInvocation	Cypher.replace(Expression original, Expression search, Expression replace)	Creates a function invocation for the replace() function.
static @NotNull Return	Clauses.returning(boolean distinct, List<Expression> expressions, @Nullable List<SortItem> optionalSortItems, @Nullable Expression optionalSkip, @Nullable Expression optionalLimit)	Builds a RETURN clause.
static StatementBuilder.OngoingReadingAndReturn	Cypher.returning(Expression... expressions)	A RETURN statement without a previous match.
default StatementBuilder.OngoingReadingAndReturn	ExposesReturning.returning(Expression... expressions)	Create a match that returns one or more expressions.
@NotNull ListComprehension	ListComprehension.OngoingDefinitionWithoutReturn.returning(Expression... listDefinition)
@NotNull PatternComprehension	PatternComprehension.OngoingDefinitionWithoutReturn.returning(Expression... listDefinition)
default StatementBuilder.OngoingReadingAndReturn	ExposesReturning.returningDistinct(Expression... expressions)	Creates a RETURN clause returning the distinct set of one or more expressions.
static StatementBuilder.OngoingReadingAndReturn	Cypher.returningRaw(Expression rawExpression)	Creates a RETURN clause from a raw Cypher expression created via Cypher.raw(String, Object...).
StatementBuilder.OngoingReadingAndReturn	ExposesReturning.returningRaw(Expression rawExpression)	Creates a RETURN clause from a raw Cypher expression created via Cypher.raw(String, Object...).
static @NotNull FunctionInvocation	Cypher.reverse(@NotNull Expression original)	Creates a function invocation for the reverse() function.
static @NotNull FunctionInvocation	Cypher.right(Expression expression, Expression length)	Creates a function invocation for the right() function.
static @NotNull FunctionInvocation	Cypher.round(Expression value, Expression... expression)	Creates a function invocation for round({}).
static @NotNull FunctionInvocation	Cypher.rtrim(@NotNull Expression expression)	Creates a function invocation for the rtrim() function.
static Operation	Cypher.set(Expression target, Expression value)	Creates a = operation.
@NotNull StatementBuilder.BuildableMatchAndUpdate	StatementBuilder.ExposesSet.set(Expression... expressions)	Adds a SET clause to the statement.
default @NotNull StatementBuilder.BuildableMatchAndUpdate	StatementBuilder.ExposesSet.set(Named variable, Expression expression)	Adds a SET clause to the statement, modifying the given named thing with an expression.
@NotNull StatementBuilder.BuildableOngoingMergeAction	StatementBuilder.OngoingMergeAction.set(Expression... expressions)	Adds a SET clause to the statement.
default @NotNull StatementBuilder.BuildableOngoingMergeAction	StatementBuilder.OngoingMergeAction.set(Named variable, Expression expression)	Adds a SET clause to the statement, modifying the given named thing with an expression.
static @NotNull FunctionInvocation	Cypher.sign(@NotNull Expression expression)	Creates a function invocation for sign({}).
static @NotNull FunctionInvocation	Cypher.sin(@NotNull Expression expression)	Creates a function invocation for sin({}).
static @NotNull FunctionInvocation	Cypher.size(Expression expression)	Creates a function invocation for the size() function.
@NotNull StatementBuilder.OngoingReadingAndWithWithSkip	StatementBuilder.ExposesSkip.skip(Expression expression)	Adds a skip clause.
@NotNull StatementBuilder.TerminalExposesLimit	StatementBuilder.TerminalExposesSkip.skip(Expression expression)	Adds a skip clause.
static @NotNull SortItem	Cypher.sort(Expression expression)	Creates a new SortItem to be used as part of an Order.
static @NotNull SortItem	Cypher.sort(Expression expression, SortItem.Direction direction)	Creates a new SortItem to be used as part of an Order.
static @NotNull FunctionInvocation	Cypher.split(@NotNull Expression expression, @NotNull String delimiter)	Creates a function invocation for the split() function.
static @NotNull FunctionInvocation	Cypher.split(@NotNull Expression expression, @NotNull Expression delimiter)	Creates a function invocation for the split() function.
static @NotNull FunctionInvocation	Cypher.sqrt(@NotNull Expression expression)	Creates a function invocation for sqrt({}).
static Condition	Cypher.startsWith(Expression lhs, Expression rhs)	Creates a condition that checks whether the lhs starts with the rhs.
default @NotNull Condition	Expression.startsWith(Expression expression)	Creates a condition that checks whether this expression starts with that expression.
static @NotNull FunctionInvocation	Cypher.stDev(Expression expression)	Creates a function invocation for the stDev() function.
static @NotNull FunctionInvocation	Cypher.stDevDistinct(Expression expression)	Creates a function invocation for the stDev() function with DISTINCT added.
static @NotNull FunctionInvocation	Cypher.stDevP(Expression expression)	Creates a function invocation for the stDevP() function.
static @NotNull FunctionInvocation	Cypher.stDevPDistinct(Expression expression)	Creates a function invocation for the stDevP() function with DISTINCT added.
static @NotNull Expression	Cypher.subList(Expression targetExpression, Integer start, Integer end)	Creates a closed range with given boundaries.
static @NotNull Expression	Cypher.subList(Expression targetExpression, Expression start, Expression end)	Creates a closed range with given boundaries.
static @NotNull Expression	Cypher.subListFrom(Expression targetExpression, Integer start)	Creates an open range starting at start.
static @NotNull Expression	Cypher.subListFrom(Expression targetExpression, Expression start)	Creates an open range starting at start.
static @NotNull Expression	Cypher.subListUntil(Expression targetExpression, Integer end)	Creates an open range starting at start.
static @NotNull Expression	Cypher.subListUntil(Expression targetExpression, Expression end)	Creates an open range starting at start.
static @NotNull FunctionInvocation	Cypher.substring(Expression original, Expression start, Expression length)	Creates a function invocation for the substring() function.
static Operation	Cypher.subtract(Expression op1, Expression op2)
default @NotNull Operation	Expression.subtract(Expression subtrahend)	Creates a - operation of this (the minuend) and the subtrahend.
static @NotNull FunctionInvocation	Cypher.sum(Expression expression)	Creates a function invocation for the sum() function.
static @NotNull FunctionInvocation	Cypher.sumDistinct(Expression expression)	Creates a function invocation for the sum() function with DISTINCT added.
static @NotNull FunctionInvocation	Cypher.tan(@NotNull Expression expression)	Creates a function invocation for tan({}).
@NotNull Case.CaseEnding	Case.OngoingWhenThen.then(Expression expression)	Ends this WHEN block with an expression.
static @NotNull FunctionInvocation	Cypher.time(@NotNull Expression temporalValue)	Creates a function invocation for time({}).
@NotNull Operation	Property.to(Expression expression)	Creates an Operation setting this property to a new value.
static @NotNull FunctionInvocation	Cypher.toBoolean(@NotNull Expression expression)	Creates a function invocation for toBoolean({}).
static @NotNull FunctionInvocation	Cypher.toFloat(@NotNull Expression expression)	Creates a function invocation for toFloat({}).
static @NotNull FunctionInvocation	Cypher.toInteger(@NotNull Expression expression)	Creates a function invocation for toInteger({}).
static @NotNull FunctionInvocation	Cypher.toLower(@NotNull Expression expression)	Creates a function invocation for the toLower() function.
static @NotNull FunctionInvocation	Cypher.toString(@NotNull Expression expression)	Creates a function invocation for toString({}).
static @NotNull FunctionInvocation	Cypher.toStringOrNull(@NotNull Expression expression)	Creates a function invocation for toStringOrNull({}).
static @NotNull FunctionInvocation	Cypher.toUpper(@NotNull Expression expression)	Creates a function invocation for the toUpper() function.
static @NotNull FunctionInvocation	Cypher.trim(@NotNull Expression expression)	Creates a function invocation for the trim() function.
static Clause	Clauses.unwind(Expression expression, SymbolicName name)	Creates an unwind clause.
static StatementBuilder.OngoingUnwind	Cypher.unwind(Expression expression)	Starts building a statement starting with an UNWIND clause.
static StatementBuilder.OngoingUnwind	Cypher.unwind(Expression... expressions)	Starts building a statement starting with an UNWIND clause.
StatementBuilder.OngoingUnwind	ExposesUnwind.unwind(Expression expression)	Starts building a new UNWIND clause.
default StatementBuilder.OngoingUnwind	ExposesUnwind.unwind(Expression... expressions)	Starts building a new UNWIND clause.
static Statement.UseStatement	Cypher.use(Expression target, Statement statement)	Decorates the given statement by prepending a dynamic USE clause.
static @NotNull ListOperator	Cypher.valueAt(Expression targetExpression, Integer index)	Creates a single valued range at index.
static @NotNull ListOperator	Cypher.valueAt(Expression targetExpression, Expression index)	Creates a single valued range at index.
@NotNull Case.OngoingWhenThen	Case.CaseEnding.when(Expression expression)	Adds a new WHEN block.
@NotNull Case.OngoingWhenThen	Case.when(Expression nextExpression)	Creates a new case/when expression with an additional WHEN block.
default @NotNull PatternElement	PatternElement.where(@Nullable Expression predicate)	Creates a new PatternElement which including an additional filter.
@NotNull PatternElement	QuantifiedPathPattern.TargetPattern.where(@Nullable Expression predicate)
@NotNull PatternElement	QuantifiedPathPattern.where(@Nullable Expression predicate)
@NotNull Relationship	RelationshipBase.where(@Nullable Expression predicate)
@NotNull RelationshipChain	RelationshipChain.where(@Nullable Expression predicate)
T	ExposesCall.ExposesWithArgs.withArgs(Expression... arguments)	Adds the given arguments to the ongoing call and procedes.
static FunctionInvocation	Cypher.withinBBox(Expression point, Expression lowerLeft, Expression upperRight)	Creates a function invocation for the point.withinBBox function.
@NotNull FunctionInvocation	Reduction.OngoingDefinitionWithInitial.withInitialValueOf(Expression initialValue)

Method parameters in org.neo4j.cypherdsl.core with type arguments of type Expression

Modifier and Type	Method	Description
static @NotNull Clause	Clauses.delete(boolean detach, List<Expression> expressions)	Builds a DELETE clause.
@NotNull StatementBuilder.OngoingUpdate	StatementBuilder.ExposesDelete.delete(Collection<? extends Expression> expressions)	Creates a delete step with one or more expressions to be deleted.
@NotNull StatementBuilder.OngoingUpdate	StatementBuilder.ExposesDelete.detachDelete(Collection<? extends Expression> expressions)	Starts building a delete step that will use DETACH to remove relationships.
static @NotNull ListExpression	Cypher.listOf(Collection<? extends Expression> expressions)	Creates a list-expression from several expressions.
static Clause	Clauses.remove(List<Expression> expressions)	Creates a remove clause, removing labels or properties.
static @NotNull Return	Clauses.returning(boolean distinct, List<Expression> expressions, @Nullable List<SortItem> optionalSortItems, @Nullable Expression optionalSkip, @Nullable Expression optionalLimit)	Builds a RETURN clause.
static StatementBuilder.OngoingReadingAndReturn	Cypher.returning(Collection<? extends Expression> expressions)	A RETURN statement without a previous match.
StatementBuilder.OngoingReadingAndReturn	ExposesReturning.returning(Collection<? extends Expression> expressions)	Create a match that returns one or more expressions.
StatementBuilder.OngoingReadingAndReturn	ExposesReturning.returningDistinct(Collection<? extends Expression> expressions)	Creates a RETURN clause returning the distinct set of one or more expressions.
static Clause	Clauses.set(List<Expression> expressions)	Creates a remove clause, setting labels or properties.
@NotNull StatementBuilder.BuildableMatchAndUpdate	StatementBuilder.ExposesSet.set(Collection<? extends Expression> expressions)	Adds a SET clause to the statement.
@NotNull StatementBuilder.BuildableOngoingMergeAction	StatementBuilder.OngoingMergeAction.set(Collection<? extends Expression> expressions)	Adds a SET clause to the statement.
static StatementBuilder.OngoingUnwind	Cypher.unwind(Collection<? extends Expression> expressions)	Starts building a statement starting with an UNWIND clause.

Constructors in org.neo4j.cypherdsl.core with parameters of type Expression

Modifier	Constructor	Description
	PropertyFilter(StatementCatalog.Clause clause, Expression left, Operator operator, Expression right, Set<String> parameterNames, Map<String,Object> parameters)	The constructor enforces the use of unmodifiable sets.