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.
org.neo4j.cypherdsl.core.internal	This is basically the kitchen sink for all classes that must be public but are not actually part of the public API.

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.

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

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

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

Modifier and Type	Method	Description
@NotNull Expression	AliasedExpression.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 Expression	Operations.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.
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
@NotNull Collection<Expression>	Statement.getIdentifiableExpressions()
Collection<Expression>	StatementBuilder.OngoingReadingAndReturn.getIdentifiableExpressions()
Collection<Expression>	StatementBuilder.OrderableOngoingReadingAndWith.getIdentifiableExpressions()

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

Modifier and Type	Method	Description
static @NotNull FunctionInvocation	Functions.abs(@NotNull Expression expression)	Creates a function invocation for abs({}).
@NotNull Reduction.OngoingDefinitionWithInitial	Reduction.OngoingDefinitionWithReducer.accumulateOn(Expression accumulator)
static @NotNull FunctionInvocation	Functions.acos(@NotNull Expression expression)	Creates a function invocation for acos({}).
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	Functions.asin(@NotNull Expression expression)	Creates a function invocation for asin({}).
static @NotNull FunctionInvocation	Functions.atan(@NotNull Expression expression)	Creates a function invocation for atan({}).
static @NotNull FunctionInvocation	Functions.atan2(@NotNull Expression y, @NotNull Expression x)	Creates a function invocation for atan2({}).
static @NotNull FunctionInvocation	Functions.avg(Expression expression)	Creates a function invocation for the avg() function.
static @NotNull FunctionInvocation	Functions.avgDistinct(Expression expression)	Creates a function invocation for the avg() function with DISTINCT added.
static Clause	Clauses.callClause(List<String> namespace, String name, @Nullable List<Expression> arguments, @Nullable List<Expression> resultItems, @Nullable Expression optionalWhere)	Creates a CALL clause.
static @NotNull Case	Cypher.caseExpression(@Nullable Expression expression)
static @NotNull FunctionInvocation	Functions.ceil(@NotNull Expression expression)	Creates a function invocation for ceil({}).
static @NotNull FunctionInvocation	Functions.coalesce(Expression... expressions)	Creates a function invocation for the coalesce() function.
static @NotNull FunctionInvocation	Functions.collect(Expression expression)	Creates a function invocation for the collect() function.
static @NotNull FunctionInvocation	Functions.collectDistinct(Expression expression)	Creates a function invocation for the collect() function with DISTINCT added.
default @NotNull Operation	Expression.concat(Expression expression)	Creates an expression concatenating two string or list expressions.
default @NotNull Condition	Expression.contains(Expression expression)	Creates a condition that checks whether this expression contains that expression.
static @NotNull FunctionInvocation	Functions.cos(@NotNull Expression expression)	Creates a function invocation for cos({}).
static @NotNull FunctionInvocation	Functions.cot(@NotNull Expression expression)	Creates a function invocation for cot({}).
static @NotNull FunctionInvocation	Functions.count(Expression expression)	Creates a function invocation for the count() function.
static @NotNull FunctionInvocation	Functions.countDistinct(Expression expression)	Creates a function invocation for a count() function with DISTINCT added.
static Case	Case.create(@Nullable Expression 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	Functions.date(@NotNull Expression temporalValue)	Creates a function invocation for date({}).
static @NotNull FunctionInvocation	Functions.datetime(@NotNull Expression temporalValue)	Creates a function invocation for datetime({}).
static @NotNull FunctionInvocation	Functions.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	Functions.distance(@NotNull Expression point1, @NotNull Expression point2)	Creates a function invocation for the distance() function.
default @NotNull Operation	Expression.divide(Expression dividend)	Creates a / operation of this (the divisor) and the dividend.
static @NotNull FunctionInvocation	Functions.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.
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	Functions.exists(Expression expression)	Creates a function invocation for the exists() function.
static @NotNull FunctionInvocation	Functions.exp(@NotNull Expression expression)	Creates a function invocation for exp({}).
static @NotNull FunctionInvocation	Functions.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.
default @NotNull Condition	Expression.gt(Expression rhs)	Creates a lhs > rhs condition.
default @NotNull Condition	Expression.gte(Expression rhs)	Creates a lhs >= rhs condition.
static @NotNull FunctionInvocation	Functions.haversin(@NotNull Expression expression)	Creates a function invocation for haversin({}).
static @NotNull FunctionInvocation	Functions.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 Predicates.OngoingListBasedPredicateFunctionWithList	Predicates.OngoingListBasedPredicateFunction.in(Expression list)
@NotNull Reduction.OngoingDefinitionWithList	Reduction.OngoingDefinitionWithVariable.in(Expression list)
default @NotNull Condition	Expression.isEqualTo(Expression rhs)	Creates a lhs = rhs condition.
default @NotNull Condition	Expression.isNotEqualTo(Expression rhs)	Creates a lhs <> rhs condition.
static @NotNull FunctionInvocation	Functions.keys(@NotNull Expression expression)	Creates a function invocation for keys{}.
static @NotNull FunctionInvocation	Functions.last(Expression expression)	Creates a function invocation for the last() 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	Functions.localdatetime(@NotNull Expression temporalValue)	Creates a function invocation for localdatetime({}).
static @NotNull FunctionInvocation	Functions.localtime(@NotNull Expression temporalValue)	Creates a function invocation for localtime({}).
static @NotNull FunctionInvocation	Functions.log(@NotNull Expression expression)	Creates a function invocation for log({}).
static @NotNull FunctionInvocation	Functions.log10(@NotNull Expression expression)	Creates a function invocation for log10({}).
default @NotNull Condition	Expression.lt(Expression rhs)	Creates a lhs < rhs condition.
default @NotNull Condition	Expression.lte(Expression rhs)	Creates a lhs <= rhs condition.
@NotNull Reduction.OngoingDefinitionWithReducer	Reduction.OngoingDefinitionWithList.map(Expression mapper)
static @NotNull Clause	Clauses.match(boolean optional, List<PatternElement> patternElements, @Nullable Expression optionalWhere, @Nullable List<Hint> optionalHints)	Builds a MATCH clause.
default @NotNull Condition	Expression.matches(Expression expression)	Creates a condition that checks whether this expression matches that expression.
static @NotNull FunctionInvocation	Functions.max(Expression expression)	Creates a function invocation for the max() function.
static @NotNull FunctionInvocation	Functions.maxDistinct(Expression expression)	Creates a function invocation for the max() function with DISTINCT added.
static @NotNull FunctionInvocation	Functions.min(Expression expression)	Creates a function invocation for the min() function.
static @NotNull FunctionInvocation	Functions.minDistinct(Expression expression)	Creates a function invocation for the min() function with DISTINCT added.
static Operation	Operations.minus(Expression e)	Creates an unary minus operation.
default @NotNull Operation	Expression.multiply(Expression multiplicand)	Creates a * operation of this (the multiplier) and the multiplicand.
static Operation	Operations.mutate(Expression target, Expression value)	Creates a += operation.
static Operation	Operations.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	Functions.percentileCont(Expression expression, Number percentile)	Creates a function invocation for the percentileCont() function.
static @NotNull FunctionInvocation	Functions.percentileContDistinct(Expression expression, Number percentile)	Creates a function invocation for the percentileCont() function with DISTINCT added.
static @NotNull FunctionInvocation	Functions.percentileDisc(Expression expression, Number percentile)	Creates a function invocation for the percentileDisc() function.
static @NotNull FunctionInvocation	Functions.percentileDiscDistinct(Expression expression, Number percentile)	Creates a function invocation for the percentileDisc() function with DISTINCT added.
static Expression	Operations.plus(Expression e)	Creates an unary plus operation.
static @NotNull FunctionInvocation	Functions.point(Expression expression)	Creates a function invocation for the point() function.
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.
@NotNull Property	PropertyContainer.property(Expression lookup)	Creates a new Property associated with this property container.
static @NotNull FunctionInvocation	Functions.radians(@NotNull Expression expression)	Creates a function invocation for radians({}).
static @NotNull FunctionInvocation	Functions.range(@NotNull Expression start, @NotNull Expression end)
static @NotNull FunctionInvocation	Functions.range(@NotNull Expression start, @NotNull Expression end, Expression step)	Creates a function invocation for the range() function.
default @NotNull Operation	Expression.remainder(Expression dividend)	Returns the remainder of this value and the dividend.
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.
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)
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	Functions.round(Expression value, Expression... expression)	Creates a function invocation for round({}).
static Operation	Operations.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	Functions.sign(@NotNull Expression expression)	Creates a function invocation for sign({}).
static @NotNull FunctionInvocation	Functions.sin(@NotNull Expression expression)	Creates a function invocation for sin({}).
static @NotNull FunctionInvocation	Functions.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	Functions.split(@NotNull Expression expression, @NotNull String delimiter)	Creates a function invocation for the split() function.
static @NotNull FunctionInvocation	Functions.split(@NotNull Expression expression, @NotNull Expression delimiter)	Creates a function invocation for the split() function.
static @NotNull FunctionInvocation	Functions.sqrt(@NotNull Expression expression)	Creates a function invocation for sqrt({}).
default @NotNull Condition	Expression.startsWith(Expression expression)	Creates a condition that checks whether this expression starts with that expression.
static @NotNull FunctionInvocation	Functions.stDev(Expression expression)	Creates a function invocation for the stDev() function.
static @NotNull FunctionInvocation	Functions.stDevDistinct(Expression expression)	Creates a function invocation for the stDev() function with DISTINCT added.
static @NotNull FunctionInvocation	Functions.stDevP(Expression expression)	Creates a function invocation for the stDevP() function.
static @NotNull FunctionInvocation	Functions.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.
default @NotNull Operation	Expression.subtract(Expression subtrahend)	Creates a - operation of this (the minuend) and the subtrahend.
static @NotNull FunctionInvocation	Functions.sum(Expression expression)	Creates a function invocation for the sum() function.
static @NotNull FunctionInvocation	Functions.sumDistinct(Expression expression)	Creates a function invocation for the sum() function with DISTINCT added.
static @NotNull FunctionInvocation	Functions.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	Functions.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	Functions.toBoolean(@NotNull Expression expression)	Creates a function invocation for toBoolean({}).
static @NotNull FunctionInvocation	Functions.toFloat(@NotNull Expression expression)	Creates a function invocation for toFloat({}).
static @NotNull FunctionInvocation	Functions.toInteger(@NotNull Expression expression)	Creates a function invocation for toInteger({}).
static @NotNull FunctionInvocation	Functions.toLower(@NotNull Expression expression)	Creates a function invocation for the toLower() function.
static @NotNull FunctionInvocation	Functions.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 @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.
static Clause	Clauses.with(Return returnClause, @Nullable Expression optionalWhere)	Retrofits an existing return clause into an equivalent with clause, optionally adding a where.
static StatementBuilder.OrderableOngoingReadingAndWithWithoutWhere	Cypher.with(Expression... expressions)	Starts a statement with a leading WITH.
@NotNull StatementBuilder.OrderableOngoingReadingAndWithWithoutWhere	StatementBuilder.ExposesWith.with(Expression... expressions)	Create a match that returns one or more expressions.
@NotNull StatementBuilder.OrderableOngoingReadingAndWithWithoutWhere	StatementBuilder.with(Expression... expressions)	Allows for queries starting with with range(1,10) as x return x or similar.
T	ExposesCall.ExposesWithArgs.withArgs(Expression... arguments)	Adds the given arguments to the ongoing call and procedes.
@NotNull StatementBuilder.OrderableOngoingReadingAndWithWithoutWhere	StatementBuilder.ExposesWith.withDistinct(Expression... expressions)	Create a match that returns the distinct set of one or more expressions.
@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<Expression> expressions)	Creates a delete step with one or more expressions to be deleted.
@NotNull StatementBuilder.OngoingUpdate	StatementBuilder.ExposesDelete.detachDelete(Collection<Expression> expressions)	Starts building a delete step that will use DETACH to remove relationships.
static @NotNull ListExpression	Cypher.listOf(Collection<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<Expression> expressions)	A RETURN statement without a previous match.
StatementBuilder.OngoingReadingAndReturn	ExposesReturning.returning(Collection<Expression> expressions)	Create a match that returns one or more expressions.
StatementBuilder.OngoingReadingAndReturn	ExposesReturning.returningDistinct(Collection<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<Expression> expressions)	Adds a SET clause to the statement.
@NotNull StatementBuilder.BuildableOngoingMergeAction	StatementBuilder.OngoingMergeAction.set(Collection<Expression> expressions)	Adds a SET clause to the statement.
static StatementBuilder.OngoingUnwind	Cypher.unwind(Collection<Expression> expressions)	Starts building a statement starting with an UNWIND clause.
static StatementBuilder.OrderableOngoingReadingAndWithWithoutWhere	Cypher.with(Collection<Expression> expressions)	Starts a statement with a leading WITH.
@NotNull StatementBuilder.OrderableOngoingReadingAndWithWithoutWhere	StatementBuilder.ExposesWith.with(Collection<Expression> expressions)	Create a match that returns one or more expressions.
@NotNull StatementBuilder.OrderableOngoingReadingAndWithWithoutWhere	StatementBuilder.with(Collection<Expression> expressions)	Allows for queries starting with with range(1,10) as x return x or similar.
@NotNull StatementBuilder.OrderableOngoingReadingAndWithWithoutWhere	StatementBuilder.ExposesWith.withDistinct(Collection<Expression> expressions)	Create a match that returns the distinct set of one or more expressions.

Uses of Expression in org.neo4j.cypherdsl.core.internal

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

Modifier and Type	Class	Description
class	LiteralBase<T>	Represents a literal with an optional content.
class	Namespace
class	RelationshipPatternCondition	Internal wrapper for marking a path pattern as a condition.

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

Modifier and Type	Method	Description
Collection<Expression>	ScopingStrategy.getIdentifiables()

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

Modifier and Type	Method	Description
static YieldItems	YieldItems.yieldAllOf(Expression... c)

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

Constructor	Description
CaseElse(Expression elseExpression)
CaseWhenThen(Expression whenExpression, Expression thenExpression)