Merge pull request #16 from ergon/feature/dope-201-extensions-for-cla…

…uses

Feature/dope 201 extensions for clauses

crystal-map-connector/src/main/kotlin/ch/ergon/dope/CrystalMapAdapter.kt

@@ -10,9 +10,22 @@ import ch.ergon.dope.validtype.StringType
 import ch.ergon.dope.validtype.ValidType
 import com.schwarz.crystalapi.schema.CMField
 import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMObject
 import com.schwarz.crystalapi.schema.CMObjectList
+import com.schwarz.crystalapi.schema.CMType
 import com.schwarz.crystalapi.schema.Schema
 
+fun CMType.asField(reference: String = path): Field<out ValidType> = Field(
+    when (this) {
+        is CMField<*> -> this.name
+        is CMList<*> -> this.name
+        is CMObjectList<*> -> this.name
+        is CMObject<*> -> TODO("DOPE-216")
+        else -> throw IllegalArgumentException("Unsupported type $this")
+    },
+    reference,
+)
+
 @JvmName("asNumberField")
 fun CMField<out Number>.asField(reference: String = path): Field<NumberType> = Field(name, reference)
 

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

@@ -0,0 +1,16 @@
+package ch.ergon.dope.extension
+
+import ch.ergon.dope.QueryBuilder
+import ch.ergon.dope.asField
+import ch.ergon.dope.resolvable.clause.model.SelectClause
+import ch.ergon.dope.resolvable.clause.model.SelectDistinctClause
+import ch.ergon.dope.resolvable.clause.model.SelectRawClause
+import com.schwarz.crystalapi.schema.CMType
+
+fun QueryBuilder.select(expression: CMType, vararg expressions: CMType): SelectClause =
+    select(expression.asField(), *expressions.map { it.asField() }.toTypedArray())
+
+fun QueryBuilder.selectDistinct(expression: CMType, vararg expressions: CMType): SelectDistinctClause =
+    selectDistinct(expression.asField(), *expressions.map { it.asField() }.toTypedArray())
+
+fun QueryBuilder.selectRaw(expression: CMType): SelectRawClause = selectRaw(expression.asField())

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

@@ -0,0 +1,18 @@
+package ch.ergon.dope.extension.clause
+
+import ch.ergon.dope.asField
+import ch.ergon.dope.resolvable.clause.IDeleteClause
+import ch.ergon.dope.resolvable.clause.IDeleteLimitClause
+import ch.ergon.dope.resolvable.clause.IDeleteOffsetClause
+import ch.ergon.dope.resolvable.clause.IDeleteWhereClause
+import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMType
+
+fun IDeleteOffsetClause.returning(field: CMType, vararg fields: CMType) =
+    returning(field.asField(), *fields.map { it.asField() }.toTypedArray())
+
+fun IDeleteLimitClause.offset(numberExpression: CMField<Number>) = offset(numberExpression.asField())
+
+fun IDeleteWhereClause.limit(numberExpression: CMField<Number>) = limit(numberExpression.asField())
+
+fun IDeleteClause.where(booleanExpression: CMField<Boolean>) = where(booleanExpression.asField())

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

@@ -0,0 +1,51 @@
+package ch.ergon.dope.extension.clause
+
+import ch.ergon.dope.asArrayField
+import ch.ergon.dope.asField
+import ch.ergon.dope.resolvable.clause.ISelectFromClause
+import ch.ergon.dope.resolvable.clause.ISelectGroupByClause
+import ch.ergon.dope.resolvable.clause.ISelectJoinClause
+import ch.ergon.dope.resolvable.clause.ISelectLimitClause
+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.GroupByClause
+import ch.ergon.dope.resolvable.clause.model.OrderByType
+import ch.ergon.dope.resolvable.clause.model.SelectLimitClause
+import ch.ergon.dope.resolvable.clause.model.SelectOffsetClause
+import ch.ergon.dope.resolvable.clause.model.SelectOrderByClause
+import ch.ergon.dope.resolvable.fromable.Bucket
+import com.schwarz.crystalapi.schema.CMField
+import com.schwarz.crystalapi.schema.CMList
+import com.schwarz.crystalapi.schema.CMType
+
+fun ISelectLimitClause.offset(numberField: CMField<Number>): SelectOffsetClause = offset(numberField.asField())
+
+fun ISelectOrderByClause.limit(numberField: CMField<Number>): SelectLimitClause = limit(numberField.asField())
+
+fun ISelectGroupByClause.orderBy(stringField: CMField<String>): SelectOrderByClause = orderBy(stringField.asField())
+
+fun ISelectGroupByClause.orderBy(stringField: CMField<String>, orderByType: OrderByType): SelectOrderByClause =
+    orderBy(stringField.asField(), orderByType)
+
+fun ISelectWhereClause.groupBy(field: CMType, vararg fields: CMType): GroupByClause =
+    groupBy(field.asField(), *fields.map { it.asField() }.toTypedArray())
+
+fun ISelectFromClause.where(whereExpression: CMField<Boolean>) = where(whereExpression.asField())
+
+fun ISelectJoinClause.join(bucket: Bucket, onKeys: CMField<out Any>) = join(bucket, onKeys.asField())
+
+fun ISelectJoinClause.innerJoin(bucket: Bucket, onKeys: CMField<out Any>) = innerJoin(bucket, onKeys.asField())
+
+fun ISelectJoinClause.leftJoin(bucket: Bucket, onKeys: CMField<out Any>) = leftJoin(bucket, onKeys.asField())
+
+fun ISelectJoinClause.rightJoin(bucket: Bucket, onKeys: CMField<out Any>) = rightJoin(bucket, onKeys.asField())
+
+@JvmName("unnestString")
+fun ISelectUnnestClause.unnest(arrayField: CMList<String>) = unnest(arrayField.asArrayField())
+
+@JvmName("unnestNumber")
+fun ISelectUnnestClause.unnest(arrayField: CMList<Number>) = unnest(arrayField.asArrayField())
+
+@JvmName("unnestBoolean")
+fun ISelectUnnestClause.unnest(arrayField: CMList<Boolean>) = unnest(arrayField.asArrayField())

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

@@ -0,0 +1,48 @@
+package ch.ergon.dope.extensions
+
+import ch.ergon.dope.QueryBuilder
+import ch.ergon.dope.extension.select
+import ch.ergon.dope.extension.selectDistinct
+import ch.ergon.dope.extension.selectRaw
+import ch.ergon.dope.helper.someCMBooleanField
+import ch.ergon.dope.helper.someCMNumberField
+import ch.ergon.dope.helper.someCMStringList
+import org.junit.jupiter.api.Assertions.assertEquals
+import kotlin.test.Test
+
+class QueryBuilderTest {
+    @Test
+    fun `should support select with CM`() {
+        val actual: String = QueryBuilder().select(someCMNumberField()).toDopeQuery().queryString
+
+        assertEquals("SELECT someNumberField", actual)
+    }
+
+    @Test
+    fun `should support select with multiple CM`() {
+        val actual: String = QueryBuilder().select(someCMBooleanField(), someCMStringList()).toDopeQuery().queryString
+
+        assertEquals("SELECT someBooleanField, someStringList", actual)
+    }
+
+    @Test
+    fun `should support select distinct with CM`() {
+        val actual: String = QueryBuilder().selectDistinct(someCMNumberField()).toDopeQuery().queryString
+
+        assertEquals("SELECT DISTINCT someNumberField", actual)
+    }
+
+    @Test
+    fun `should support select distinct with multiple CM`() {
+        val actual: String = QueryBuilder().selectDistinct(someCMBooleanField(), someCMStringList()).toDopeQuery().queryString
+
+        assertEquals("SELECT DISTINCT someBooleanField, someStringList", actual)
+    }
+
+    @Test
+    fun `should support select raw with CM`() {
+        val actual: String = QueryBuilder().selectRaw(someCMNumberField()).toDopeQuery().queryString
+
+        assertEquals("SELECT RAW someNumberField", actual)
+    }
+}

crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/CountTest.kt

@@ -0,0 +1,55 @@
+package ch.ergon.dope.extensions.aggregator
+
+import ch.ergon.dope.extension.aggregator.count
+import ch.ergon.dope.helper.someCMBooleanField
+import ch.ergon.dope.helper.someCMBooleanList
+import ch.ergon.dope.helper.someCMNumberField
+import ch.ergon.dope.helper.someCMNumberList
+import ch.ergon.dope.helper.someCMStringField
+import ch.ergon.dope.helper.someCMStringList
+import org.junit.jupiter.api.Assertions.assertEquals
+import kotlin.test.Test
+
+class CountTest {
+    @Test
+    fun `should support count with CMField Number`() {
+        val actual: String = count(someCMNumberField()).toDopeQuery().queryString
+
+        assertEquals("COUNT(someNumberField)", actual)
+    }
+
+    @Test
+    fun `should support count with CMField String`() {
+        val actual: String = count(someCMStringField()).toDopeQuery().queryString
+
+        assertEquals("COUNT(someStringField)", actual)
+    }
+
+    @Test
+    fun `should support count with CMField Boolean`() {
+        val actual: String = count(someCMBooleanField()).toDopeQuery().queryString
+
+        assertEquals("COUNT(someBooleanField)", actual)
+    }
+
+    @Test
+    fun `should support count with CMList Number`() {
+        val actual: String = count(someCMNumberList()).toDopeQuery().queryString
+
+        assertEquals("COUNT(someNumberList)", actual)
+    }
+
+    @Test
+    fun `should support count with CMList String`() {
+        val actual: String = count(someCMStringList()).toDopeQuery().queryString
+
+        assertEquals("COUNT(someStringList)", actual)
+    }
+
+    @Test
+    fun `should support count with CMList Boolean`() {
+        val actual: String = count(someCMBooleanList()).toDopeQuery().queryString
+
+        assertEquals("COUNT(someBooleanList)", actual)
+    }
+}

crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/MinTest.kt

@@ -0,0 +1,55 @@
+package ch.ergon.dope.extensions.aggregator
+
+import ch.ergon.dope.extension.aggregator.min
+import ch.ergon.dope.helper.someCMBooleanField
+import ch.ergon.dope.helper.someCMBooleanList
+import ch.ergon.dope.helper.someCMNumberField
+import ch.ergon.dope.helper.someCMNumberList
+import ch.ergon.dope.helper.someCMStringField
+import ch.ergon.dope.helper.someCMStringList
+import org.junit.jupiter.api.Assertions.assertEquals
+import kotlin.test.Test
+
+class MinTest {
+    @Test
+    fun `should support min with CMField Number`() {
+        val actual: String = min(someCMNumberField()).toDopeQuery().queryString
+
+        assertEquals("MIN(someNumberField)", actual)
+    }
+
+    @Test
+    fun `should support min with CMField String`() {
+        val actual: String = min(someCMStringField()).toDopeQuery().queryString
+
+        assertEquals("MIN(someStringField)", actual)
+    }
+
+    @Test
+    fun `should support min with CMField Boolean`() {
+        val actual: String = min(someCMBooleanField()).toDopeQuery().queryString
+
+        assertEquals("MIN(someBooleanField)", actual)
+    }
+
+    @Test
+    fun `should support min with CMList Number`() {
+        val actual: String = min(someCMNumberList()).toDopeQuery().queryString
+
+        assertEquals("MIN(someNumberList)", actual)
+    }
+
+    @Test
+    fun `should support min with CMList String`() {
+        val actual: String = min(someCMStringList()).toDopeQuery().queryString
+
+        assertEquals("MIN(someStringList)", actual)
+    }
+
+    @Test
+    fun `should support min with CMList Boolean`() {
+        val actual: String = min(someCMBooleanList()).toDopeQuery().queryString
+
+        assertEquals("MIN(someBooleanList)", actual)
+    }
+}

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

@@ -0,0 +1,49 @@
+package ch.ergon.dope.extensions.clause
+
+import ch.ergon.dope.extension.clause.limit
+import ch.ergon.dope.extension.clause.offset
+import ch.ergon.dope.extension.clause.returning
+import ch.ergon.dope.extension.clause.where
+import ch.ergon.dope.helper.someCMBooleanField
+import ch.ergon.dope.helper.someCMNumberField
+import ch.ergon.dope.helper.someCMStringList
+import ch.ergon.dope.helper.someDelete
+import org.junit.jupiter.api.Assertions.assertEquals
+import kotlin.test.Test
+
+class DeleteClauseTest {
+    @Test
+    fun `should support delete where with CM`() {
+        val actual: String = someDelete().where(someCMBooleanField()).toDopeQuery().queryString
+
+        assertEquals("DELETE FROM someBucket WHERE someBooleanField", actual)
+    }
+
+    @Test
+    fun `should support delete limit with CM`() {
+        val actual: String = someDelete().limit(someCMNumberField()).toDopeQuery().queryString
+
+        assertEquals("DELETE FROM someBucket LIMIT someNumberField", actual)
+    }
+
+    @Test
+    fun `should support delete offset with CM`() {
+        val actual: String = someDelete().offset(someCMNumberField()).toDopeQuery().queryString
+
+        assertEquals("DELETE FROM someBucket OFFSET someNumberField", actual)
+    }
+
+    @Test
+    fun `should support delete returning with CM`() {
+        val actual: String = someDelete().returning(someCMNumberField()).toDopeQuery().queryString
+
+        assertEquals("DELETE FROM someBucket RETURNING someNumberField", actual)
+    }
+
+    @Test
+    fun `should support delete returning with multiple CM`() {
+        val actual: String = someDelete().returning(someCMNumberField(), someCMStringList(), someCMBooleanField()).toDopeQuery().queryString
+
+        assertEquals("DELETE FROM someBucket RETURNING someNumberField, someStringList, someBooleanField", actual)
+    }
+}