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	Implements 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 Neo4j v5 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	A nested expression.
final class	NullLiteral	Represents the literal value null.
final class	NumberLiteral	Representation of a numeric literal.
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)	Returns the name of the given expression or the expression itself if it isn't named.

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

Modifier and Type	Method	Description
Expression	AliasedExpression.asExpression()
Expression	Asterisk.asExpression()
Expression	ForeignAdapter.asExpression()	Adapts a foreign expression into a Cypher-DSL Expression.
Expression	IdentifiableElement.asExpression()	Transform this element into an expression.
default Expression	Named.asExpression()
Expression	SymbolicName.asExpression()
default Expression	ExposesCall.AsFunction.asFunction()	Returns a function invocation that can be used as an expression, for example as a property or inside a condition.
Expression	ExposesCall.AsFunction.asFunction(boolean distinct)	Returns a function invocation that can be used as an expression, for example as a property or inside a condition.
static Expression	Cypher.collect(Statement statement)	Creates a COLLECT subquery from a statement, including its filters and conditions.
default Expression	Property.getContainerReference()	Returns a reference to the container owning this property.
Expression	Comparison.getLeft()
Expression	Comparison.getRight()
Expression	KeyValueMapEntry.getValue()	Returns the value of this entry.
Expression	StatementCatalog.PropertyFilter.left()	Returns the value of the left record component.
static <T extends Expression> Expression	Cypher.nameOrExpression(T expression)	Returns the name of the given expression or the expression itself if it isn't named.
static Expression	Cypher.plus(Expression e)	Creates an unary plus operation.
static 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 Expression	Expression.size()	This creates a size(e) expression from this expression.
static Expression	Cypher.subList(Expression targetExpression, Integer start, Integer end)	Creates a closed range with given boundaries.
static Expression	Cypher.subList(Expression targetExpression, Expression start, Expression end)	Creates a closed range with given boundaries.
static Expression	Cypher.subListFrom(Expression targetExpression, Integer start)	Creates an open range starting at start.
static Expression	Cypher.subListFrom(Expression targetExpression, Expression start)	Creates an open range starting at start.
static Expression	Cypher.subListUntil(Expression targetExpression, Integer end)	Creates an open range starting at start.
static 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()	Returns the set of identifiable expressions in the RETURN clause, the final statement might have a different set.
Collection<Expression>	StatementBuilder.OrderableOngoingReadingAndWith.getIdentifiableExpressions()	Returns the set of identifiable expressions in the WITH clause.
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 FunctionInvocation	Cypher.abs(Expression expression)	Creates a function invocation for abs({}).
Reduction.OngoingDefinitionWithInitial	Reduction.OngoingDefinitionWithReducer.accumulateOn(Expression accumulator)	Return an ongoing definition.
static FunctionInvocation	Cypher.acos(Expression expression)	Creates a function invocation for acos({}).
static Operation	Cypher.add(Expression op1, Expression op2)
default Operation	Expression.add(Expression addend)	Creates a + operation of this (the augend) and the addend.
static Labels	Cypher.allLabels(Expression expression)	Creates a dynamic label expression matching all labels to which expression resolves.
StatementBuilder.TerminalOngoingOrderDefinition	StatementBuilder.OngoingMatchAndReturnWithOrder.and(Expression expression)	Adds another expression to the list of order items.
StatementBuilder.OngoingOrderDefinition	StatementBuilder.OngoingReadingAndWithWithWhereAndOrder.and(Expression expression)	Adds another expression to the list of order items.
static Labels	Cypher.anyLabel(Expression expression)	Creates a dynamic label expression matching any label to which expression resolves.
static FunctionInvocation	Cypher.asin(Expression expression)	Creates a function invocation for asin({}).
static FunctionInvocation	Cypher.atan(Expression expression)	Creates a function invocation for atan({}).
static FunctionInvocation	Cypher.atan2(Expression y, Expression x)	Creates a function invocation for atan2({}).
static FunctionInvocation	Cypher.avg(Expression expression)	Creates a function invocation for the avg() function.
static FunctionInvocation	Cypher.avgDistinct(Expression expression)	Creates a function invocation for the avg() function with DISTINCT added.
static Case	Cypher.caseExpression(Expression expression)	Starts building a CASE expression.
static FunctionInvocation	Cypher.ceil(Expression expression)	Creates a function invocation for ceil({}).
static FunctionInvocation	Cypher.coalesce(Expression... expressions)	Creates a function invocation for the coalesce() function.
static FunctionInvocation	Cypher.collect(Expression expression)	Creates a function invocation for the collect() function.
static 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 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 Condition	Expression.contains(Expression expression)	Creates a condition that checks whether this expression contains that expression.
static FunctionInvocation	Cypher.cos(Expression expression)	Creates a function invocation for cos({}).
static FunctionInvocation	Cypher.cot(Expression expression)	Creates a function invocation for cot({}).
static FunctionInvocation	Cypher.count(Expression expression)	Creates a function invocation for the count() function.
static FunctionInvocation	Cypher.countDistinct(Expression expression)	Creates a function invocation for a count() function with DISTINCT added.
static Case	Case.create(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 KeyValueMapEntry	KeyValueMapEntry.create(String key, 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 FunctionInvocation	Cypher.date(Expression temporalValue)	Creates a function invocation for date({}).
static FunctionInvocation	Cypher.datetime(Expression temporalValue)	Creates a function invocation for datetime({}).
static FunctionInvocation	Cypher.degrees(Expression expression)	Creates a function invocation for degrees({}).
StatementBuilder.OngoingUpdate	StatementBuilder.ExposesDelete.delete(Expression... expressions)	Creates a delete step with one or more expressions to be deleted.
StatementBuilder.OngoingUpdate	StatementBuilder.ExposesDelete.detachDelete(Expression... expressions)	Starts building a delete step that will use DETACH to remove relationships.
static FunctionInvocation	Cypher.distance(Expression point1, Expression point2)	Creates a function invocation for the distance() function.
static Operation	Cypher.divide(Expression op1, Expression op2)
default Operation	Expression.divide(Expression dividend)	Creates a / operation of this (the divisor) and the dividend.
static FunctionInvocation	Cypher.duration(Expression temporalAmount)	Creates a function invocation for duration({}).
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 Condition	Expression.endsWith(Expression expression)	Creates a condition that checks whether this expression ends with that expression.
default Condition	Expression.eq(Expression rhs)	An alias for isEqualTo(Expression).
static FunctionInvocation	Cypher.exists(Expression expression)	Creates a function invocation for the exists() function.
static FunctionInvocation	Cypher.exp(Expression expression)	Creates a function invocation for exp({}).
static FunctionInvocation	Cypher.floor(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 Where	Where.from(Expression optionalWhere)	Creates a new WHERE.
static FunctionInvocation	Cypher.graphByName(Expression name)	Creates a function invocation for graph.byName().
static 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 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 Condition	Expression.gte(Expression rhs)	Creates a lhs >= rhs condition.
default Condition	Expression.hasSize(Expression expectedSize)	Takes the size() expresssions and compares it for equality with the parameter expectedSize.
static FunctionInvocation	Cypher.haversin(Expression expression)	Creates a function invocation for haversin({}).
static FunctionInvocation	Cypher.head(Expression expression)	Creates a function invocation for the head() function.
default Condition	Expression.in(Expression haystack)	Creates a IN operation for this expression and that expression.
ListComprehension.OngoingDefinitionWithList	ListComprehension.OngoingDefinitionWithVariable.in(Expression list)	Create a list comprehension past on a literal list.
OngoingListBasedPredicateFunctionWithList	OngoingListBasedPredicateFunction.in(Expression list)	Returns a builder to specify the where condition for the list based predicate.
Reduction.OngoingDefinitionWithList	Reduction.OngoingDefinitionWithVariable.in(Expression list)	Returns an ongoing definition.
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 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 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 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 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 FunctionInvocation	Cypher.keys(Expression expression)	Creates a function invocation for keys{}.
static FunctionInvocation	Cypher.last(Expression expression)	Creates a function invocation for the last() function.
static FunctionInvocation	Cypher.left(Expression expression, Expression length)	Creates a function invocation for the left() function.
StatementBuilder.OngoingReadingAndWith	StatementBuilder.ExposesLimit.limit(Expression expression)	Limits the number of returned records.
StatementBuilder.BuildableStatement<ResultStatement>	StatementBuilder.TerminalExposesLimit.limit(Expression expression)	Limits the number of returned records.
static ListExpression	Cypher.listOf(Expression... expressions)	Creates a list-expression from several expressions.
static FunctionInvocation	Cypher.localdatetime(Expression temporalValue)	Creates a function invocation for localdatetime({}).
static FunctionInvocation	Cypher.localtime(Expression temporalValue)	Creates a function invocation for localtime({}).
static FunctionInvocation	Cypher.log(Expression expression)	Creates a function invocation for log({}).
static FunctionInvocation	Cypher.log10(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 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 Condition	Expression.lte(Expression rhs)	Creates a lhs <= rhs condition.
static FunctionInvocation	Cypher.ltrim(Expression expression)	Creates a function invocation for the ltrim() function.
Reduction.OngoingDefinitionWithReducer	Reduction.OngoingDefinitionWithList.map(Expression mapper)	Return an ongoing definition.
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 left hand side via =~.
default Condition	Expression.matches(Expression expression)	Creates a condition that checks whether this expression matches that expression.
static FunctionInvocation	Cypher.max(Expression expression)	Creates a function invocation for the max() function.
static FunctionInvocation	Cypher.maxDistinct(Expression expression)	Creates a function invocation for the max() function with DISTINCT added.
static FunctionInvocation	Cypher.min(Expression expression)	Creates a function invocation for the min() function.
static 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 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.
StatementBuilder.BuildableMatchAndUpdate	StatementBuilder.ExposesSet.mutate(Expression target, Expression properties)	Creates a += operation.
default StatementBuilder.BuildableMatchAndUpdate	StatementBuilder.ExposesSet.mutate(Named variable, Expression properties)	Creates a += operation.
StatementBuilder.BuildableOngoingMergeAction	StatementBuilder.OngoingMergeAction.mutate(Expression target, Expression properties)	Creates a += operation.
default StatementBuilder.BuildableOngoingMergeAction	StatementBuilder.OngoingMergeAction.mutate(Named variable, Expression properties)	Creates a += operation.
default Condition	Expression.ne(Expression rhs)	An alias for isNotEqualTo(Expression).
static Clause	Clauses.orderBy(List<SortItem> sortItems, Expression skip, Expression limit)	Creates a standalone ORDER BY clause.
StatementBuilder.OngoingOrderDefinition	StatementBuilder.ExposesOrderBy.orderBy(Expression expression)	Order the result set by an expression.
StatementBuilder.TerminalOngoingOrderDefinition	StatementBuilder.TerminalExposesOrderBy.orderBy(Expression expression)	Order the result set by an expression.
static FunctionInvocation	Cypher.percentileCont(Expression expression, Number percentile)	Creates a function invocation for the percentileCont() function.
static FunctionInvocation	Cypher.percentileContDistinct(Expression expression, Number percentile)	Creates a function invocation for the percentileCont() function with DISTINCT added.
static FunctionInvocation	Cypher.percentileDisc(Expression expression, Number percentile)	Creates a function invocation for the percentileDisc() function.
static 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 FunctionInvocation	Cypher.point(Expression expression)	Creates a function invocation for the point() function.
static Operation	Cypher.pow(Expression op1, Expression op2)
default Operation	Expression.pow(Expression n)	Returns the power of n of this value.
protected Visitable	MapExpression.prepareVisit(Expression child)
static 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 Property	Cypher.property(Expression expression, String... names)	Dereferences a property on an arbitrary expression.
static Property	Cypher.property(Expression expression, Collection<String> names)	Dereferences a property on a arbitrary expression.
static Property	Cypher.property(Expression expression, Expression lookup)	Creates a dynamic lookup of a property on an arbitrary expression.
default Property	Expression.property(Expression lookup)	Creates a new Property associated with this property container.
Property	PropertyAccessor.property(Expression lookup)	Creates a new Property associated with this element.
static FunctionInvocation	Cypher.radians(Expression expression)	Creates a function invocation for radians({}).
static FunctionInvocation	Cypher.range(Expression start, Expression end)	Creates a function invocation for the range() function.
static FunctionInvocation	Cypher.range(Expression start, Expression end, Expression step)	Creates a function invocation for the range() function.
static Operation	Cypher.remainder(Expression op1, Expression op2)
default Operation	Expression.remainder(Expression dividend)	Returns the remainder of this value and the dividend.
static FunctionInvocation	Cypher.replace(Expression original, Expression search, Expression replace)	Creates a function invocation for the replace() function.
static Return	Clauses.returning(boolean distinct, List<Expression> expressions, List<SortItem> optionalSortItems, Expression optionalSkip, 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.
ListComprehension	ListComprehension.OngoingDefinitionWithoutReturn.returning(Expression... listDefinition)	Defines the RETURN clause.
PatternComprehension	PatternComprehension.OngoingDefinitionWithoutReturn.returning(Expression... listDefinition)	Defines the returning exoression items.
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 FunctionInvocation	Cypher.reverse(Expression original)	Creates a function invocation for the reverse() function.
static FunctionInvocation	Cypher.right(Expression expression, Expression length)	Creates a function invocation for the right() function.
static FunctionInvocation	Cypher.round(Expression value, Expression... expression)	Creates a function invocation for round({}).
static FunctionInvocation	Cypher.rtrim(Expression expression)	Creates a function invocation for the rtrim() function.
static Operation	Cypher.set(Expression target, Expression value)	Creates a = operation.
StatementBuilder.BuildableMatchAndUpdate	StatementBuilder.ExposesSet.set(Expression... expressions)	Adds a SET clause to the statement.
default StatementBuilder.BuildableMatchAndUpdate	StatementBuilder.ExposesSet.set(Named variable, Expression expression)	Adds a SET clause to the statement, modifying the given named thing with an expression.
StatementBuilder.BuildableOngoingMergeAction	StatementBuilder.OngoingMergeAction.set(Expression... expressions)	Adds a SET clause to the statement.
default 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 FunctionInvocation	Cypher.sign(Expression expression)	Creates a function invocation for sign({}).
static FunctionInvocation	Cypher.sin(Expression expression)	Creates a function invocation for sin({}).
static FunctionInvocation	Cypher.size(Expression expression)	Creates a function invocation for the size() function.
StatementBuilder.OngoingReadingAndWithWithSkip	StatementBuilder.ExposesSkip.skip(Expression expression)	Adds a skip clause.
StatementBuilder.TerminalExposesLimit	StatementBuilder.TerminalExposesSkip.skip(Expression expression)	Adds a skip clause.
static SortItem	Cypher.sort(Expression expression)	Creates a new SortItem to be used as part of an Order.
static SortItem	Cypher.sort(Expression expression, SortItem.Direction direction)	Creates a new SortItem to be used as part of an Order.
static FunctionInvocation	Cypher.split(Expression expression, String delimiter)	Creates a function invocation for the split() function.
static FunctionInvocation	Cypher.split(Expression expression, Expression delimiter)	Creates a function invocation for the split() function.
static FunctionInvocation	Cypher.sqrt(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 Condition	Expression.startsWith(Expression expression)	Creates a condition that checks whether this expression starts with that expression.
static FunctionInvocation	Cypher.stDev(Expression expression)	Creates a function invocation for the stDev() function.
static FunctionInvocation	Cypher.stDevDistinct(Expression expression)	Creates a function invocation for the stDev() function with DISTINCT added.
static FunctionInvocation	Cypher.stDevP(Expression expression)	Creates a function invocation for the stDevP() function.
static FunctionInvocation	Cypher.stDevPDistinct(Expression expression)	Creates a function invocation for the stDevP() function with DISTINCT added.
static Expression	Cypher.subList(Expression targetExpression, Integer start, Integer end)	Creates a closed range with given boundaries.
static Expression	Cypher.subList(Expression targetExpression, Expression start, Expression end)	Creates a closed range with given boundaries.
static Expression	Cypher.subListFrom(Expression targetExpression, Integer start)	Creates an open range starting at start.
static Expression	Cypher.subListFrom(Expression targetExpression, Expression start)	Creates an open range starting at start.
static Expression	Cypher.subListUntil(Expression targetExpression, Integer end)	Creates an open range starting at start.
static Expression	Cypher.subListUntil(Expression targetExpression, Expression end)	Creates an open range starting at start.
static 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 Operation	Expression.subtract(Expression subtrahend)	Creates a - operation of this (the minuend) and the subtrahend.
static FunctionInvocation	Cypher.sum(Expression expression)	Creates a function invocation for the sum() function.
static FunctionInvocation	Cypher.sumDistinct(Expression expression)	Creates a function invocation for the sum() function with DISTINCT added.
static FunctionInvocation	Cypher.tan(Expression expression)	Creates a function invocation for tan({}).
Case.CaseEnding	Case.OngoingWhenThen.then(Expression expression)	Ends this WHEN block with an expression.
static FunctionInvocation	Cypher.time(Expression temporalValue)	Creates a function invocation for time({}).
Operation	Property.to(Expression expression)	Creates an Operation setting this property to a new value.
static FunctionInvocation	Cypher.toBoolean(Expression expression)	Creates a function invocation for toBoolean({}).
static FunctionInvocation	Cypher.toFloat(Expression expression)	Creates a function invocation for toFloat({}).
static FunctionInvocation	Cypher.toInteger(Expression expression)	Creates a function invocation for toInteger({}).
static FunctionInvocation	Cypher.toLower(Expression expression)	Creates a function invocation for the toLower() function.
static FunctionInvocation	Cypher.toString(Expression expression)	Creates a function invocation for toString({}).
static FunctionInvocation	Cypher.toStringOrNull(Expression expression)	Creates a function invocation for toStringOrNull({}).
static FunctionInvocation	Cypher.toUpper(Expression expression)	Creates a function invocation for the toUpper() function.
static FunctionInvocation	Cypher.trim(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 ListOperator	Cypher.valueAt(Expression targetExpression, Integer index)	Creates a single valued range at index.
static ListOperator	Cypher.valueAt(Expression targetExpression, Expression index)	Creates a single valued range at index.
Case.OngoingWhenThen	Case.CaseEnding.when(Expression expression)	Adds a new WHEN block.
Case.OngoingWhenThen	Case.when(Expression nextExpression)	Creates a new case/when expression with an additional WHEN block.
default PatternElement	PatternElement.where(Expression predicate)	Creates a new PatternElement which including an additional filter.
PatternElement	QuantifiedPathPattern.TargetPattern.where(Expression predicate)
PatternElement	QuantifiedPathPattern.where(Expression predicate)
Relationship	RelationshipBase.where(Expression predicate)
RelationshipChain	RelationshipChain.where(Expression predicate)
T	ExposesCall.ExposesWithArgs.withArgs(Expression... arguments)	Adds the given arguments to the ongoing call and proceeds.
static FunctionInvocation	Cypher.withinBBox(Expression point, Expression lowerLeft, Expression upperRight)	Creates a function invocation for the point.withinBBox function.
FunctionInvocation	Reduction.OngoingDefinitionWithInitial.withInitialValueOf(Expression initialValue)	Return an ongoing definition.

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

Modifier and Type	Method	Description
static Clause	Clauses.delete(boolean detach, List<Expression> expressions)	Builds a DELETE clause.
StatementBuilder.OngoingUpdate	StatementBuilder.ExposesDelete.delete(Collection<? extends Expression> expressions)	Creates a delete step with one or more expressions to be deleted.
StatementBuilder.OngoingUpdate	StatementBuilder.ExposesDelete.detachDelete(Collection<? extends Expression> expressions)	Starts building a delete step that will use DETACH to remove relationships.
static 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 Return	Clauses.returning(boolean distinct, List<Expression> expressions, List<SortItem> optionalSortItems, Expression optionalSkip, 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.
StatementBuilder.BuildableMatchAndUpdate	StatementBuilder.ExposesSet.set(Collection<? extends Expression> expressions)	Adds a SET clause to the statement.
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.