Is it possible to implement the Criteria pattern using Spring Data Neo4j?

[yacosta738]

Hello community! I am working on a project that uses PostgreSQL and Neo4j reactively. I am making great progress with it and I have already finished the reactive part of PostgreSQL. However, when I got to the Neo4j part, I encountered some problems when trying to use the Criteria pattern. I am not sure how to use it correctly and I have not found something similar to Query Criteria in Spring Data Neo4j. I have been looking online but I have not found much information about it. I am looking for a way to use the Criteria pattern efficiently in order to move my project forward.

The following example is what I have implemented for the relational part, but I would like to find a solution for the Neo4j part as well. I am eagerly awaiting any advice you can provide me on how to use the Criteria pattern effectively in Neo4j.

interface CriteriaParser<Out : Any?> {
    fun parse(criteria: Criteria): Out
}

import com.astrum.data.criteria.Criteria
import com.astrum.data.criteria.CriteriaParser
import com.astrum.data.expansion.columnName
import kotlin.reflect.KClass
import kotlin.reflect.full.memberProperties
import org.springframework.data.relational.core.query.Criteria as R2DBCCriteria
import org.springframework.data.relational.core.query.Criteria.CriteriaStep as R2DBCCriteriaStep

class R2DBCCriteriaParser<T : Any>(
    clazz: KClass<T>
) : CriteriaParser<R2DBCCriteria> {
    private val columnNames = clazz.memberProperties.associate { it.name to columnName(it) }

    override fun parse(criteria: Criteria): R2DBCCriteria {
        return when (criteria) {
            is Criteria.Empty -> R2DBCCriteria.empty()
            is Criteria.And -> parse(criteria)
            is Criteria.Or -> parse(criteria)
            is Criteria.Equals -> parse(criteria)
            is Criteria.NotEquals -> parse(criteria)
            is Criteria.Between -> parse(criteria)
            is Criteria.NotBetween -> parse(criteria)
            is Criteria.LessThan -> parse(criteria)
            is Criteria.LessThanEquals -> parse(criteria)
            is Criteria.GreaterThan -> parse(criteria)
            is Criteria.GreaterThanEquals -> parse(criteria)
            is Criteria.IsNull -> parse(criteria)
            is Criteria.IsNotNull -> parse(criteria)
            is Criteria.Like -> parse(criteria)
            is Criteria.NotLike -> parse(criteria)
            is Criteria.In -> parse(criteria)
            is Criteria.NotIn -> parse(criteria)
            is Criteria.IsTrue -> parse(criteria)
            is Criteria.IsFalse -> parse(criteria)
            else -> throw RuntimeException()
        }
    }

    private fun parse(criteria: Criteria.And): R2DBCCriteria {
        if (criteria.value.isEmpty()) {
            return R2DBCCriteria.empty()
        }
        if (criteria.value.size == 1) {
            return parse(criteria.value[0])
        }
        return criteria.value
            .filter { it !is Criteria.Empty }
            .map { parse(it) }
            .reduce { acc, cur -> acc.and(cur) }
    }

    private fun parse(criteria: Criteria.Or): R2DBCCriteria {
        if (criteria.value.isEmpty()) {
            return R2DBCCriteria.empty()
        }
        if (criteria.value.size == 1) {
            return parse(criteria.value[0])
        }
        return criteria.value
            .filter { it !is Criteria.Empty }
            .map { parse(it) }
            .reduce { acc, cur -> acc.or(cur) }
    }

    private fun parse(criteria: Criteria.Equals): R2DBCCriteria {
        if (criteria.value == null) {
            return where(criteria.key).isNull
        }
        return where(criteria.key).`is`(criteria.value)
    }

    private fun parse(criteria: Criteria.NotEquals): R2DBCCriteria {
        if (criteria.value == null) {
            return where(criteria.key).isNotNull
        }
        return where(criteria.key).not(criteria.value)
    }

    private fun parse(criteria: Criteria.Between): R2DBCCriteria {
        return where(criteria.key).between(criteria.value.start, criteria.value.endInclusive)
    }

    private fun parse(criteria: Criteria.NotBetween): R2DBCCriteria {
        return where(criteria.key).notBetween(criteria.value.start, criteria.value.endInclusive)
    }

    private fun parse(criteria: Criteria.LessThan): R2DBCCriteria {
        return where(criteria.key).lessThan(criteria.value)
    }

    private fun parse(criteria: Criteria.LessThanEquals): R2DBCCriteria {
        return where(criteria.key).lessThanOrEquals(criteria.value)
    }

    private fun parse(criteria: Criteria.GreaterThan): R2DBCCriteria {
        return where(criteria.key).greaterThan(criteria.value)
    }

    private fun parse(criteria: Criteria.GreaterThanEquals): R2DBCCriteria {
        return where(criteria.key).greaterThanOrEquals(criteria.value)
    }

    private fun parse(criteria: Criteria.IsNull): R2DBCCriteria {
        return where(criteria.key).isNull
    }

    private fun parse(criteria: Criteria.IsNotNull): R2DBCCriteria {
        return where(criteria.key).isNotNull
    }

    private fun parse(criteria: Criteria.Like): R2DBCCriteria {
        return where(criteria.key).like(criteria.value)
    }

    private fun parse(criteria: Criteria.NotLike): R2DBCCriteria {
        return where(criteria.key).notLike(criteria.value)
    }

    private fun parse(criteria: Criteria.In): R2DBCCriteria {
        return where(criteria.key).`in`(criteria.value)
    }

    private fun parse(criteria: Criteria.NotIn): R2DBCCriteria {
        return where(criteria.key).notIn(criteria.value)
    }

    private fun parse(criteria: Criteria.IsTrue): R2DBCCriteria {
        return where(criteria.key).isTrue
    }

    private fun parse(criteria: Criteria.IsFalse): R2DBCCriteria {
        return where(criteria.key).isFalse
    }

    private fun where(key: String): R2DBCCriteriaStep {
        return R2DBCCriteria.where(
            columnNames[key] ?: throw IllegalArgumentException("$key is invalid}")
        )
    }
}

[michael-simons]

Hi. Thanks for using SDN.

SDN does not offer R2DBC Criteria API.

It has however both Cypher-DSL and Query-DSL query executioners, for both imperative and reactive variants. You can use Cypher-DSL for the exact same thing as you are doing above.

https://docs.spring.io/spring-data/neo4j/docs/current/reference/html/#sdn-mixins.using-cypher-dsl-statements

[yacosta738]

Thank you very much, @michael-simons ! I'm going to review the documentation you sent me to implement the Criteria pattern for the Neo4j part used by my application.

[michael-simons]

If you want to parse Cypher, Cypher-DSL has a parser module, too.

Here are more examples in the tests: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/test/java/org/springframework/data/neo4j/integration/reactive/ReactiveCypherdslConditionExecutorIT.java#L122

[yacosta738]

Oh, great! I will check it.

[yacosta738]

@michael-simons I would like you to comment if this implementation fulfills the same purpose as R2DBC. I tried to use the properties that were most similar.

This is my domain class Criteria

import java.util.regex.Pattern

sealed class Criteria {
    object Empty : Criteria() {
        override fun toString(): String {
            return "()"
        }
    }

    data class And(val value: List<Criteria>) : Criteria() {
        override fun toString(): String {
            return "(${value.joinToString(" AND ") { it.toString() }})"
        }
    }

    data class Or(val value: List<Criteria>) : Criteria() {
        override fun toString(): String {
            return "(${value.joinToString(" OR ") { it.toString() }})"
        }
    }

    data class Equals(val key: String, val value: Any?) : Criteria() {
        override fun toString(): String {
            return "$key = $value"
        }
    }

    data class NotEquals(val key: String, val value: Any?) : Criteria() {
        override fun toString(): String {
            return "$key != $value"
        }
    }

    data class Between(val key: String, val value: ClosedRange<*>) : Criteria() {
        override fun toString(): String {
            return "($key >= ${value.start} && $key <= ${value.endInclusive})"
        }
    }

    data class NotBetween(val key: String, val value: ClosedRange<*>) : Criteria() {
        override fun toString(): String {
            return "($key < ${value.start} || $key > ${value.endInclusive})"
        }
    }

    data class LessThan(val key: String, val value: Any) : Criteria() {
        override fun toString(): String {
            return "$key < $value"
        }
    }

    data class LessThanEquals(val key: String, val value: Any) : Criteria() {
        override fun toString(): String {
            return "$key <= $value"
        }
    }

    data class GreaterThan(val key: String, val value: Any) : Criteria() {
        override fun toString(): String {
            return "$key > $value"
        }
    }

    data class GreaterThanEquals(val key: String, val value: Any) : Criteria() {
        override fun toString(): String {
            return "$key >= $value"
        }
    }

    data class IsNull(val key: String) : Criteria() {
        override fun toString(): String {
            return "$key = null"
        }
    }

    data class IsNotNull(val key: String) : Criteria() {
        override fun toString(): String {
            return "$key != null"
        }
    }

    data class Like(val key: String, val value: String) : Criteria() {
        override fun toString(): String {
            return "$key LIKE $value"
        }
    }

    data class NotLike(val key: String, val value: String) : Criteria() {
        override fun toString(): String {
            return "$key NOT LIKE $value"
        }
    }

    data class Regexp(val key: String, val value: Pattern) : Criteria() {
        override fun toString(): String {
            return "$key REGEXP $value"
        }
    }

    data class NotRegexp(val key: String, val value: Pattern) : Criteria() {
        override fun toString(): String {
            return "$key NOT REGEXP $value"
        }
    }

    data class In(val key: String, val value: List<Any?>) : Criteria() {
        override fun toString(): String {
            return "$key IN (${value.map { it.toString() }.joinToString { ", " }})"
        }
    }

    data class NotIn(val key: String, val value: List<Any?>) : Criteria() {
        override fun toString(): String {
            return "$key NOT IN (${value.map { it.toString() }.joinToString { ", " }})"
        }
    }

    data class IsTrue(val key: String) : Criteria() {
        override fun toString(): String {
            return "$key IS TRUE"
        }
    }

    data class IsFalse(val key: String) : Criteria() {
        override fun toString(): String {
            return "$key IS FALSE"
        }
    }
}

And this the parser implementation

import com.astrum.data.criteria.Criteria
import com.astrum.data.criteria.CriteriaParser
import org.neo4j.cypherdsl.core.*
import kotlin.reflect.KClass


class Neo4jCriteriaParser<T : Any>(
    private val clazz: KClass<T>
) : CriteriaParser<ResultStatement> {
    private val properties: Array<Property> =
        clazz.java.declaredFields.map { it.name }.map { Cypher.property(it) }.toTypedArray()
    private val node: Node = Cypher.node(clazz.simpleName).named("n").withProperties(*properties)
    override fun parse(criteria: Criteria): ResultStatement {
        return when (criteria) {
            is Criteria.Empty -> parse()
            is Criteria.And -> parse(criteria)
            is Criteria.Or -> parse(criteria)
            is Criteria.Equals -> parse(criteria)
            is Criteria.NotEquals -> parse(criteria)
            is Criteria.Between -> parse(criteria)
            is Criteria.NotBetween -> parse(criteria)
            is Criteria.LessThan -> parse(criteria)
            is Criteria.LessThanEquals -> parse(criteria)
            is Criteria.GreaterThan -> parse(criteria)
            is Criteria.GreaterThanEquals -> parse(criteria)
            is Criteria.IsNull -> parse(criteria)
            is Criteria.IsNotNull -> parse(criteria)
            is Criteria.Like -> parse(criteria)
            is Criteria.NotLike -> parse(criteria)
            is Criteria.Regexp -> parse(criteria)
            is Criteria.NotRegexp -> parse(criteria)
            is Criteria.In -> parse(criteria)
            is Criteria.NotIn -> parse(criteria)
            is Criteria.IsTrue -> parse(criteria)
            is Criteria.IsFalse -> parse(criteria)
        }
    }

    private fun parse(): ResultStatement {
       return Cypher.match(node)
            .returning(
                node.requiredSymbolicName,
                Functions.collect(node)
            )
            .build()
    }
    private fun parse(criteria: Criteria.And): ResultStatement {
        if (criteria.value.isEmpty()) {
            return parse()
        }
        return Cypher.match(node)
            .where(
                properties.map { property ->
                    property.isEqualTo(Cypher.anonParameter(criteria.value))
                }.reduce { acc, cur -> acc.and(cur) }
            )
            .returning(
                node.requiredSymbolicName,
                Functions.collect(node)
            )
            .build()
    }

    private fun parse(criteria: Criteria.Or): ResultStatement {
        if (criteria.value.isEmpty()) {
            return parse()
        }
        return Cypher.match(node)
            .where(
                properties.map { property ->
                    property.isEqualTo(Cypher.anonParameter(criteria.value))
                }.reduce { acc, cur -> acc.or(cur) }
            )
            .returning(
                node.requiredSymbolicName,
                Functions.collect(node)
            )
            .build()
    }

    private fun parse(criteria: Criteria.Equals): ResultStatement {
        val key = criteria.key
        val property = properties.find { it.name == key }
        return Cypher.match(node)
            .where(
                property?.isEqualTo(Cypher.anonParameter(criteria.value))
            )
            .returning(
                node.requiredSymbolicName,
                Functions.collect(node)
            )
            .build()
    }

    private fun parse(criteria: Criteria.NotEquals): ResultStatement {
        val key = criteria.key
        val property = properties.find { it.name == key }
        return Cypher.match(node)
            .where(
                property?.isNotEqualTo(Cypher.anonParameter(criteria.value))
            )
            .returning(
                node.requiredSymbolicName,
                Functions.collect(node)
            )
            .build()
    }

    private fun parse(criteria: Criteria.Between): ResultStatement {
        val a = criteria.value.start
        val b = criteria.value.endInclusive

        val key = criteria.key
        val property = properties.find { it.name == key }

        return Cypher.match(node)
            .where(
                property?.gte(Cypher.anonParameter(a))?.and(property.lte(Cypher.anonParameter(b)))
            )
            .returning(
                node.requiredSymbolicName,
                Functions.collect(node)
            )
            .build()
    }

    private fun parse(criteria: Criteria.NotBetween): ResultStatement {
        val a = criteria.value.start
        val b = criteria.value.endInclusive
        val key = criteria.key
        val property = properties.find { it.name == key }
val condition = property?.lt(Cypher.anonParameter(a))?.or(property.gt(Cypher.anonParameter(b)))
        return Cypher.match(node)
            .where(condition)
            .returning(
                node.requiredSymbolicName,
                Functions.collect(node)
            )
            .build()
    }

    private fun parse(criteria: Criteria.LessThan): ResultStatement {
        val key = criteria.key
        val property = properties.find { it.name == key }
        return Cypher.match(node)
            .where(
                property?.lt(Cypher.anonParameter(criteria.value))
            )
            .returning(
                node.requiredSymbolicName,
                Functions.collect(node)
            )
            .build()
    }

    private fun parse(criteria: Criteria.LessThanEquals): ResultStatement {
        val key = criteria.key
        val property = properties.find { it.name == key }
        return Cypher.match(node)
            .where(
                property?.lte(Cypher.anonParameter(criteria.value))
            )
            .returning(
                node.requiredSymbolicName,
                Functions.collect(node)
            )
            .build()
    }

    private fun parse(criteria: Criteria.GreaterThan): ResultStatement {
        val key = criteria.key
        val property = properties.find { it.name == key }
        return Cypher.match(node)
            .where(
                property?.gt(Cypher.anonParameter(criteria.value))
            )
            .returning(
                node.requiredSymbolicName,
                Functions.collect(node)
            )
            .build()
    }

    private fun parse(criteria: Criteria.GreaterThanEquals): ResultStatement {
        val key = criteria.key
        val property = properties.find { it.name == key }
        return Cypher.match(node)
            .where(
                property?.gte(Cypher.anonParameter(criteria.value))
            )
            .returning(
                node.requiredSymbolicName,
                Functions.collect(node)
            )
            .build()
    }

    private fun parse(criteria: Criteria.IsNull): ResultStatement {
        val key = criteria.key
        val property = properties.find { it.name == key }
        return Cypher.match(node)
            .where(
                property?.isNull
            )
            .returning(
                node.requiredSymbolicName,
                Functions.collect(node)
            )
            .build()
    }

    private fun parse(criteria: Criteria.IsNotNull): ResultStatement {
        val key = criteria.key
        val property = properties.find { it.name == key }
        return Cypher.match(node)
            .where(
                property?.isNotNull
            )
            .returning(
                node.requiredSymbolicName,
                Functions.collect(node)
            )
            .build()
    }

    private fun parse(criteria: Criteria.Like): ResultStatement {
        val key = criteria.key
        val property = properties.find { it.name == key }
        return Cypher.match(node)
            .where(
                property?.contains(Cypher.anonParameter(criteria.value))
            )
            .returning(
                node.requiredSymbolicName,
                Functions.collect(node)
            )
            .build()
    }


    private fun parse(criteria: Criteria.NotLike): ResultStatement {
        val key = criteria.key
        val property = properties.find { it.name == key }
        return Cypher.match(node)
            .where(
                property?.ne(Cypher.anonParameter(criteria.value))
            )
            .returning(
                node.requiredSymbolicName,
                Functions.collect(node)
            )
            .build()
    }
    private fun parse(criteria: Criteria.Regexp): ResultStatement {
        val key = criteria.key
        val property = properties.find { it.name == key }
        return Cypher.match(node)
            .where(
                property?.matches(Cypher.anonParameter(criteria.value))
            )
            .returning(
                node.requiredSymbolicName,
                Functions.collect(node)
            )
            .build()
    }

    private fun parse(criteria: Criteria.NotRegexp): ResultStatement {
        val key = criteria.key
        val property = properties.find { it.name == key }
        val condition = property?.matches(Cypher.anonParameter(criteria.value))?.not()
        return Cypher.match(node)
            .where(condition)
            .returning(
                node.requiredSymbolicName,
                Functions.collect(node)
            )
            .build()
    }

    private fun parse(criteria: Criteria.In): ResultStatement {
        val key = criteria.key
        val property = properties.find { it.name == key }
        return Cypher.match(node)
            .where(
                property?.`in`(Cypher.anonParameter(criteria.value))
            )
            .returning(
                node.requiredSymbolicName,
                Functions.collect(node)
            )
            .build()
    }

    private fun parse(criteria: Criteria.NotIn): ResultStatement {
        val key = criteria.key
        val property = properties.find { it.name == key }
        val condition: Condition? = property?.`in`(Cypher.anonParameter(criteria.value))?.not()
        return Cypher.match(node)
            .where(condition)
            .returning(
                node.requiredSymbolicName,
                Functions.collect(node)
            )
            .build()
    }

    private fun parse(criteria: Criteria.IsTrue): ResultStatement {
        val key = criteria.key
        val property = properties.find { it.name == key }
        return Cypher.match(node)
            .where(
                property?.isTrue
            )
            .returning(
                node.requiredSymbolicName,
                Functions.collect(node)
            )
            .build()
    }

    private fun parse(criteria: Criteria.IsFalse): ResultStatement {
        val key = criteria.key
        val property = properties.find { it.name == key }
        return Cypher.match(node)
            .where(
                property?.isFalse
            )
            .returning(
                node.requiredSymbolicName,
                Functions.collect(node)
            )
            .build()
    }

}

[michael-simons]

You can use an empty condition https://github.com/neo4j-contrib/cypher-dsl/blob/main/neo4j-cypher-dsl/src/main/java/org/neo4j/cypherdsl/core/Conditions.java#L215 if you don't add to it, it won't be rendered at all.

[michael-simons]

Thanks for closing it @yacosta738 Feel free to reopen or reach out if there are other / more issues.