DOPE-255: add let clause with tests

core/src/main/kotlin/ch/ergon/dope/resolvable/clause/ISelectClause.kt

@@ -1,10 +1,12 @@
 package ch.ergon.dope.resolvable.clause
 
 import ch.ergon.dope.resolvable.clause.model.AliasedUnnestClause
+import ch.ergon.dope.resolvable.clause.model.DopeVariable
 import ch.ergon.dope.resolvable.clause.model.FromClause
 import ch.ergon.dope.resolvable.clause.model.GroupByClause
 import ch.ergon.dope.resolvable.clause.model.InnerJoinClause
 import ch.ergon.dope.resolvable.clause.model.LeftJoinClause
+import ch.ergon.dope.resolvable.clause.model.LetClause
 import ch.ergon.dope.resolvable.clause.model.OrderByType
 import ch.ergon.dope.resolvable.clause.model.RightJoinClause
 import ch.ergon.dope.resolvable.clause.model.SelectLimitClause
@@ -60,7 +62,15 @@ interface ISelectFromClause<T : ValidType> : ISelectWhereClause<T> {
     fun where(whereExpression: TypeExpression<BooleanType>) = SelectWhereClause(whereExpression, this)
 }
 
-interface ISelectJoinClause<T : ValidType> : ISelectFromClause<T> {
+interface ISelectLetClause<T : ValidType> : ISelectFromClause<T> {
+    fun withVariables(dopeVariable: DopeVariable<out ValidType>, vararg dopeVariables: DopeVariable<out ValidType>) = LetClause(
+        dopeVariable,
+        *dopeVariables,
+        parentClause = this,
+    )
+}
+
+interface ISelectJoinClause<T : ValidType> : ISelectLetClause<T> {
     fun join(
         joinable: Joinable,
         onCondition: TypeExpression<BooleanType>,

core/src/main/kotlin/ch/ergon/dope/resolvable/clause/model/LetClause.kt

@@ -0,0 +1,61 @@
+package ch.ergon.dope.resolvable.clause.model
+
+import ch.ergon.dope.DopeQuery
+import ch.ergon.dope.DopeQueryManager
+import ch.ergon.dope.resolvable.clause.ISelectLetClause
+import ch.ergon.dope.resolvable.expression.TypeExpression
+import ch.ergon.dope.resolvable.expression.unaliased.type.toDopeType
+import ch.ergon.dope.resolvable.formatToQueryStringWithSymbol
+import ch.ergon.dope.validtype.BooleanType
+import ch.ergon.dope.validtype.NumberType
+import ch.ergon.dope.validtype.StringType
+import ch.ergon.dope.validtype.ValidType
+
+class LetClause<T : ValidType>(
+    private val dopeVariable: DopeVariable<out ValidType>,
+    private vararg val dopeVariables: DopeVariable<out ValidType>,
+    private val parentClause: ISelectLetClause<T>,
+) : ISelectLetClause<T> {
+    override fun toDopeQuery(manager: DopeQueryManager): DopeQuery {
+        val parentDopeQuery = parentClause.toDopeQuery(manager)
+        val letExpressionDopeQuery = dopeVariable.toDefinitionDopeQuery(manager)
+        val letExpressionDopeQueries = dopeVariables.map { it.toDefinitionDopeQuery(manager) }
+
+        return DopeQuery(
+            queryString = formatToQueryStringWithSymbol(
+                parentDopeQuery.queryString,
+                "LET",
+                letExpressionDopeQuery.queryString,
+                *letExpressionDopeQueries.map { it.queryString }.toTypedArray(),
+            ),
+            parameters = parentDopeQuery.parameters.merge(
+                letExpressionDopeQuery.parameters,
+                *letExpressionDopeQueries.map { it.parameters }.toTypedArray(),
+            ),
+        )
+    }
+}
+
+class DopeVariable<T : ValidType>(private val name: String, private val value: TypeExpression<T>) : TypeExpression<T> {
+    override fun toDopeQuery(manager: DopeQueryManager): DopeQuery {
+        return DopeQuery(
+            queryString = "`$name`",
+        )
+    }
+
+    fun toDefinitionDopeQuery(manager: DopeQueryManager): DopeQuery {
+        val valueDopeQuery = value.toDopeQuery(manager)
+        return DopeQuery(
+            queryString = "`$name` = ${valueDopeQuery.queryString}",
+            parameters = valueDopeQuery.parameters,
+        )
+    }
+}
+
+fun <T : ValidType> String.assignTo(expression: TypeExpression<T>): DopeVariable<T> = DopeVariable(this, expression)
+
+fun String.assignTo(expression: Number): DopeVariable<NumberType> = assignTo(expression.toDopeType())
+
+fun String.assignTo(expression: String): DopeVariable<StringType> = assignTo(expression.toDopeType())
+
+fun String.assignTo(expression: Boolean): DopeVariable<BooleanType> = assignTo(expression.toDopeType())

core/src/test/kotlin/ch/ergon/dope/buildTest/QueryBuilderTest.kt

@@ -7,8 +7,10 @@ import ch.ergon.dope.helper.someBooleanField
 import ch.ergon.dope.helper.someBucket
 import ch.ergon.dope.helper.someFromClause
 import ch.ergon.dope.helper.someNumberField
+import ch.ergon.dope.helper.someStringArrayField
 import ch.ergon.dope.helper.someStringField
 import ch.ergon.dope.helper.unifyString
+import ch.ergon.dope.resolvable.clause.model.assignTo
 import ch.ergon.dope.resolvable.clause.model.setoperator.except
 import ch.ergon.dope.resolvable.clause.model.setoperator.exceptAll
 import ch.ergon.dope.resolvable.clause.model.setoperator.intersect
@@ -20,6 +22,8 @@ import ch.ergon.dope.resolvable.expression.unaliased.type.FALSE
 import ch.ergon.dope.resolvable.expression.unaliased.type.MISSING
 import ch.ergon.dope.resolvable.expression.unaliased.type.NULL
 import ch.ergon.dope.resolvable.expression.unaliased.type.TRUE
+import ch.ergon.dope.resolvable.expression.unaliased.type.collection.any
+import ch.ergon.dope.resolvable.expression.unaliased.type.collection.inArray
 import ch.ergon.dope.resolvable.expression.unaliased.type.conditional.case
 import ch.ergon.dope.resolvable.expression.unaliased.type.conditional.condition
 import ch.ergon.dope.resolvable.expression.unaliased.type.conditional.otherwise
@@ -35,6 +39,7 @@ import ch.ergon.dope.resolvable.expression.unaliased.type.relational.isLessOrEqu
 import ch.ergon.dope.resolvable.expression.unaliased.type.relational.isLessThan
 import ch.ergon.dope.resolvable.expression.unaliased.type.relational.isLike
 import ch.ergon.dope.resolvable.expression.unaliased.type.relational.isNotEqualTo
+import ch.ergon.dope.resolvable.expression.unaliased.type.relational.isNotNull
 import ch.ergon.dope.resolvable.expression.unaliased.type.toDopeType
 import ch.ergon.dope.resolvable.fromable.asterisk
 import kotlin.test.BeforeTest
@@ -896,4 +901,30 @@ class QueryBuilderTest : ManagerDependentTest {
 
         assertEquals(expected, actual)
     }
+
+    @Test
+    fun `should support selecting let clause`() {
+        val t1 = someBucket("route").alias("t1")
+        val equip = "equip".assignTo(someStringArrayField("equipment", t1).any { it.isEqualTo("radio") })
+        val sourceAirport = someStringField("sourceAirport", someBucket("route").alias("t2"))
+        val sourceAirports = "source_airports".assignTo(create.selectRaw(sourceAirport).where(sourceAirport.isNotNull()).asExpression())
+        val destinationAirport = someStringField("destinationAirport", t1)
+
+        val expected = "SELECT `t1`.`destinationAirport`, `equip` AS `has_radio` " +
+            "FROM `route` AS `t1` " +
+            "LET `equip` = ANY `iterator1` IN `t1`.`equipment` SATISFIES `iterator1` = \"radio\" END, " +
+            "`source_airports` = (SELECT RAW `t2`.`sourceAirport` WHERE `t2`.`sourceAirport` IS NOT NULL) " +
+            "WHERE (`t1`.`airline` = \"AI\" AND `t1`.`destinationAirport` IN `source_airports`)"
+
+        val actual = create
+            .select(destinationAirport, equip.alias("has_radio"))
+            .from(t1)
+            .withVariables(equip, sourceAirports)
+            .where(
+                someStringField("airline", t1).isEqualTo("AI")
+                    .and(destinationAirport.inArray(sourceAirports)),
+            ).build().queryString
+
+        assertEquals(expected, actual)
+    }
 }

core/src/test/kotlin/ch/ergon/dope/resolvable/clause/LetClauseTest.kt

@@ -0,0 +1,116 @@
+package ch.ergon.dope.resolvable.clause
+
+import ch.ergon.dope.DopeQuery
+import ch.ergon.dope.DopeQueryManager
+import ch.ergon.dope.helper.ManagerDependentTest
+import ch.ergon.dope.helper.someBoolean
+import ch.ergon.dope.helper.someFromClause
+import ch.ergon.dope.helper.someNumber
+import ch.ergon.dope.helper.someNumberField
+import ch.ergon.dope.helper.someString
+import ch.ergon.dope.helper.someStringField
+import ch.ergon.dope.resolvable.clause.model.DopeVariable
+import ch.ergon.dope.resolvable.clause.model.LetClause
+import ch.ergon.dope.resolvable.clause.model.assignTo
+import ch.ergon.dope.resolvable.expression.unaliased.type.function.stringfunction.lower
+import ch.ergon.dope.resolvable.expression.unaliased.type.toDopeType
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class LetClauseTest : ManagerDependentTest {
+    override lateinit var manager: DopeQueryManager
+
+    @Test
+    fun `should support let`() {
+        val expected = DopeQuery(
+            queryString = "SELECT * FROM `someBucket` LET `someName` = `numberField`",
+        )
+        val underTest = LetClause(DopeVariable("someName", someNumberField()), parentClause = someFromClause())
+
+        val actual = underTest.toDopeQuery(manager)
+
+        assertEquals(expected, actual)
+    }
+
+    @Test
+    fun `should support let with multiple expressions`() {
+        val expected = DopeQuery(
+            queryString = "SELECT * FROM `someBucket` LET `name1` = `numberField`, `name2` = `stringField`",
+        )
+        val underTest = LetClause(
+            DopeVariable("name1", someNumberField()),
+            DopeVariable("name2", someStringField()),
+            parentClause = someFromClause(),
+        )
+
+        val actual = underTest.toDopeQuery(manager)
+
+        assertEquals(expected, actual)
+    }
+
+    @Test
+    fun `should support let function`() {
+        val parentClause = someFromClause()
+        val dopeVariable = DopeVariable("name1", someNumberField())
+        val expected = LetClause(dopeVariable, parentClause = parentClause)
+
+        val actual = parentClause.withVariables(dopeVariable)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support let expression`() {
+        val expression = lower("TEST")
+        val expected = DopeQuery("`name1`")
+        val underTest = DopeVariable("name1", expression)
+
+        val actual = underTest.toDopeQuery(manager)
+
+        assertEquals(expected, actual)
+    }
+
+    @Test
+    fun `should support let expression function`() {
+        val expression = lower("test")
+        val name = "name"
+        val expected = DopeVariable(name, expression)
+
+        val actual = name.assignTo(expression)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support let expression function number`() {
+        val expression = someNumber()
+        val name = "name"
+        val expected = DopeVariable(name, expression.toDopeType())
+
+        val actual = name.assignTo(expression)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support let expression function string`() {
+        val expression = someString()
+        val name = "name"
+        val expected = DopeVariable(name, expression.toDopeType())
+
+        val actual = name.assignTo(expression)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support let expression function boolean`() {
+        val expression = someBoolean()
+        val name = "name"
+        val expected = DopeVariable(name, expression.toDopeType())
+
+        val actual = name.assignTo(expression)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+}

crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/clause/SelectClause.kt

@@ -8,6 +8,7 @@ import ch.ergon.dope.resolvable.clause.ISelectOrderByClause
 import ch.ergon.dope.resolvable.clause.ISelectUnnestClause
 import ch.ergon.dope.resolvable.clause.ISelectWhereClause
 import ch.ergon.dope.resolvable.clause.model.OrderByType
+import ch.ergon.dope.resolvable.clause.model.assignTo
 import ch.ergon.dope.resolvable.clause.model.joinHint.HashOrNestedLoopHint
 import ch.ergon.dope.resolvable.clause.model.joinHint.KeysOrIndexHint
 import ch.ergon.dope.resolvable.fromable.Bucket
@@ -82,3 +83,21 @@ fun <T : ValidType> ISelectUnnestClause<T>.unnest(arrayField: CMJsonList<Number>
 
 @JvmName("unnestBoolean")
 fun <T : ValidType> ISelectUnnestClause<T>.unnest(arrayField: CMJsonList<Boolean>) = unnest(arrayField.toDopeType())
+
+@JvmName("assignToCMNumberField")
+fun String.assignTo(value: CMJsonField<Number>) = assignTo(value.toDopeType())
+
+@JvmName("assignToCMStringField")
+fun String.assignTo(value: CMJsonField<String>) = assignTo(value.toDopeType())
+
+@JvmName("assignToCMBooleanField")
+fun String.assignTo(value: CMJsonField<Boolean>) = assignTo(value.toDopeType())
+
+@JvmName("assignToCMNumberList")
+fun String.assignTo(value: CMJsonList<Number>) = assignTo(value.toDopeType())
+
+@JvmName("assignToCMStringList")
+fun String.assignTo(value: CMJsonList<String>) = assignTo(value.toDopeType())
+
+@JvmName("assignToCMBooleanList")
+fun String.assignTo(value: CMJsonList<Boolean>) = assignTo(value.toDopeType())

crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/clause/SelectClauseTest.kt

@@ -1,6 +1,7 @@
 package ch.ergon.dope.extensions.clause
 
 import ch.ergon.dope.DopeQueryManager
+import ch.ergon.dope.extension.clause.assignTo
 import ch.ergon.dope.extension.clause.groupBy
 import ch.ergon.dope.extension.clause.innerJoin
 import ch.ergon.dope.extension.clause.join
@@ -22,6 +23,8 @@ import ch.ergon.dope.helper.someCMStringList
 import ch.ergon.dope.helper.someFrom
 import ch.ergon.dope.helper.someNumberField
 import ch.ergon.dope.helper.someSelect
+import ch.ergon.dope.helper.someString
+import ch.ergon.dope.resolvable.clause.model.DopeVariable
 import ch.ergon.dope.resolvable.clause.model.GroupByClause
 import ch.ergon.dope.resolvable.clause.model.InnerJoinClause
 import ch.ergon.dope.resolvable.clause.model.LeftJoinClause
@@ -262,4 +265,70 @@ class SelectClauseTest : ManagerDependentTest {
 
         assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
     }
+
+    @Test
+    fun `should support DopeVariables with cmNumberField`() {
+        val name = someString()
+        val value = someCMNumberField()
+        val expected = DopeVariable(name, value.toDopeType())
+
+        val actual = name.assignTo(value)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support DopeVariables with cmStringField`() {
+        val name = someString()
+        val value = someCMStringField()
+        val expected = DopeVariable(name, value.toDopeType())
+
+        val actual = name.assignTo(value)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support DopeVariables with cmBooleanField`() {
+        val name = someString()
+        val value = someCMBooleanField()
+        val expected = DopeVariable(name, value.toDopeType())
+
+        val actual = name.assignTo(value)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support DopeVariables with cmNumberList`() {
+        val name = someString()
+        val value = someCMNumberList()
+        val expected = DopeVariable(name, value.toDopeType())
+
+        val actual = name.assignTo(value)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support DopeVariables with cmStringList`() {
+        val name = someString()
+        val value = someCMStringList()
+        val expected = DopeVariable(name, value.toDopeType())
+
+        val actual = name.assignTo(value)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
+
+    @Test
+    fun `should support DopeVariables with cmBooleanList`() {
+        val name = someString()
+        val value = someCMBooleanList()
+        val expected = DopeVariable(name, value.toDopeType())
+
+        val actual = name.assignTo(value)
+
+        assertEquals(expected.toDopeQuery(manager), actual.toDopeQuery(manager))
+    }
 }