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

Packages that use Condition

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

Uses of Condition in org.neo4j.cypherdsl.core

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

Modifier and Type	Class	Description
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	ExistentialSubquery	An existential sub-query can only be used in a where clause.
final class	HasLabelCondition	A condition checking for the presence of labels on nodes or types on relationships.

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

Modifier and Type	Method	Description
default @NotNull Condition	Condition.and(Condition condition)	Adds a condition to this condition with an AND.
default @NotNull Condition	Condition.and(RelationshipPattern pathPattern)	Adds a condition based on a path pattern to this condition with an AND.
default @NotNull Condition	Expression.asCondition()	Transform this expression into a condition.
@NotNull Condition	ForeignAdapter.asCondition()	Adapts a foreign expression into a Cypher-DSL Condition.
final @NotNull Condition	RelationshipBase.asCondition()
@NotNull Condition	RelationshipChain.asCondition()
@NotNull Condition	RelationshipPattern.asCondition()	Transform this pattern into a condition.
@NotNull Condition	StatementBuilder.ExposesExistentialSubqueryCall.asCondition()	This can be used against a 4.x database to turn this ongoing match statement into a condition to be used in an existential subquery.
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 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 Expression.isEqualTo(Expression).
static Condition	Cypher.exists(List<PatternElement> pattern)	Creates a new condition via an existential sub-query based on the list of patterns
static Condition	Cypher.exists(List<PatternElement> pattern, @Nullable Where where)	Creates a new condition via an existential sub-query based on the list of patterns and an optional where-clause.
static Condition	Cypher.exists(PatternElement pattern)	Creates a new condition via an existential sub-query based on the list of patterns
static @NotNull Condition	Cypher.exists(Property property)	Creates a new condition based on a function invocation for the exists() function.
static @NotNull Condition	Cypher.exists(RelationshipPattern pattern)	Creates a new condition based on a function invocation for the exists() function.
static Condition	Cypher.exists(Statement statement, IdentifiableElement... imports)	Creates a new condition via an existential sub-query.
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.
@NotNull Condition	Node.hasLabels(String... labelsToQuery)	A condition that checks for the presence of labels on a node.
@NotNull Condition	Node.hasLabels(LabelExpression labels)	A condition that checks for the presence of a label expression on a node
static Condition	Cypher.hasLabelsOrType(SymbolicName symbolicName, String... labelsOrTypes)
default @NotNull Condition	Expression.hasSize(Expression expectedSize)	Takes the Expression.size() expresssions and compares it for equality with the parameter expectedSize.
default @NotNull Condition	Expression.in(Expression haystack)	Creates a IN operation for this expression and that expression.
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.
default @NotNull Condition	Expression.isEmpty()	Creates a condition that evaluates to true if this expression is empty.
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.
@NotNull Condition	Node.isEqualTo(Node otherNode)	Creates a new condition whether this node is equal to otherNode.
static Condition	Cypher.isFalse()
default @NotNull Condition	Expression.isFalse()	Creates a condition that checks whether this expression is false.
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.
@NotNull Condition	Node.isNotEqualTo(Node otherNode)	Creates a new condition whether this node is not equal to otherNode.
static Condition	Cypher.isNotNull(Expression expression)	Creates a condition that checks whether the expression is not null.
default @NotNull Condition	Expression.isNotNull()	Creates a IS NOT NULL operation for this expression.
@NotNull Condition	Node.isNotNull()	Creates a new condition based on this node whether it is not null.
static Condition	Cypher.isNull(Expression expression)	Creates a condition that checks whether the expression is null.
default @NotNull Condition	Expression.isNull()	Creates a IS NULL operation for this expression.
@NotNull Condition	Node.isNull()	Creates a new condition based on this node whether it is null.
static Condition	Cypher.isTrue()
default @NotNull Condition	Expression.isTrue()	Creates a condition that checks whether this expression is true.
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 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(String pattern)	Creates a condition that checks whether this expression matches the given pattern.
default @NotNull Condition	Expression.matches(Expression expression)	Creates a condition that checks whether this expression matches that expression.
static Condition	Cypher.matching(RelationshipPattern relationshipPattern)
default @NotNull Condition	Expression.ne(Expression rhs)	An alias for Expression.isNotEqualTo(Expression).
static @NotNull Condition	Cypher.noCondition()	Creates a placeholder condition which is not rendered in the final statement but is useful while chaining conditions together.
@NotNull Condition	Comparison.not()
default @NotNull Condition	Condition.not()	Negates this condition.
static @NotNull Condition	Cypher.not(@NotNull Condition condition)	Negates the given condition.
static @NotNull Condition	Cypher.not(@NotNull RelationshipPattern pattern)	Negates the given pattern element: The pattern must not matched to be included in the result.
default @NotNull Condition	Condition.or(Condition condition)	Adds a condition to this condition with an OR.
default @NotNull Condition	Condition.or(RelationshipPattern pathPattern)	Adds a condition based on a path pattern to this condition with an OR.
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.
@NotNull Condition	OngoingListBasedPredicateFunctionWithList.where(Condition condition)
default @NotNull Condition	Condition.xor(Condition condition)	Adds a condition to this condition with a XOR.
default @NotNull Condition	Condition.xor(RelationshipPattern pathPattern)	Adds a condition based on a path pattern to this condition with a XOR.

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

Modifier and Type	Method	Description
default @NotNull Condition	Condition.and(Condition condition)	Adds a condition to this condition with an AND.
T	ExposesLogicalOperators.and(Condition condition)	Adds an additional condition to the existing conditions, connected by an and.
static @NotNull Condition	Cypher.not(@NotNull Condition condition)	Negates the given condition.
default @NotNull Condition	Condition.or(Condition condition)	Adds a condition to this condition with an OR.
T	ExposesLogicalOperators.or(Condition condition)	Adds an additional condition to the existing conditions, connected by an or.
@NotNull CountExpression	CountExpression.where(Condition condition)	Creates a new count expression with additional conditions
T	ExposesWhere.where(Condition condition)	Adds a where clause to this fragement.
@NotNull ListComprehension.OngoingDefinitionWithoutReturn	ListComprehension.OngoingDefinitionWithList.where(Condition condition)	Adds a WHERE clause to this comprehension.
@NotNull Condition	OngoingListBasedPredicateFunctionWithList.where(Condition condition)
@NotNull PatternComprehension.OngoingDefinitionWithPatternAndWhere	PatternComprehension.OngoingDefinitionWithPattern.where(Condition condition)	Adds a WHERE clause to the inner statement of the pattern comprehension
@NotNull StatementBuilder.OrderableOngoingReadingAndWithWithWhere	StatementBuilder.OrderableOngoingReadingAndWithWithoutWhere.where(@NotNull Condition condition)	Adds a where clause to this match.
default @NotNull Condition	Condition.xor(Condition condition)	Adds a condition to this condition with a XOR.