Feature/dope 214 add backticks to buckets and params

core/src/main/kotlin/ch/ergon/dope/resolvable/QueryStringBuilder.kt

@@ -15,7 +15,7 @@ fun formatToQueryStringWithBrackets(symbol: String, vararg argument: String) =
 
 fun formatPathToQueryString(name: String, path: String) =
     if (path.isBlank()) {
-        name
+        "`$name`"
     } else {
-        "$path.$name"
+        "`$path`.`$name`"
     }

core/src/main/kotlin/ch/ergon/dope/resolvable/expression/AliasedExpression.kt

@@ -14,7 +14,7 @@ class AliasedExpression<T : ValidType>(
     override fun toDopeQuery(): DopeQuery {
         val unaliasedExpressionDopeQuery = unaliasedExpression.toDopeQuery()
         return DopeQuery(
-            queryString = formatToQueryStringWithSymbol(unaliasedExpressionDopeQuery.queryString, "AS", alias),
+            queryString = formatToQueryStringWithSymbol(unaliasedExpressionDopeQuery.queryString, "AS", "`$alias`"),
             parameters = unaliasedExpressionDopeQuery.parameters,
         )
     }

core/src/main/kotlin/ch/ergon/dope/resolvable/expression/AsteriskExpression.kt

@@ -12,8 +12,8 @@ class AsteriskExpression : Expression {
 
     constructor(bucket: Bucket) {
         queryString = when (bucket) {
-            is AliasedBucket -> bucket.alias
-            is UnaliasedBucket -> bucket.name
+            is AliasedBucket -> "`${bucket.alias}`"
+            is UnaliasedBucket -> "`${bucket.name}`"
         } + ".$ASTERISK_STRING"
     }
 

core/src/main/kotlin/ch/ergon/dope/resolvable/expression/unaliased/type/Field.kt

@@ -5,7 +5,7 @@ import ch.ergon.dope.resolvable.expression.TypeExpression
 import ch.ergon.dope.resolvable.formatPathToQueryString
 import ch.ergon.dope.validtype.ValidType
 
-class Field<T : ValidType>(private val name: String, private val path: String) : TypeExpression<T> {
+open class Field<T : ValidType>(private val name: String, private val path: String) : TypeExpression<T> {
     override fun toDopeQuery(): DopeQuery = DopeQuery(
         queryString = formatPathToQueryString(name, path),
         parameters = emptyMap(),

core/src/main/kotlin/ch/ergon/dope/resolvable/expression/unaliased/type/meta/MetaExpression.kt

@@ -5,34 +5,47 @@ import ch.ergon.dope.resolvable.expression.TypeExpression
 import ch.ergon.dope.resolvable.expression.unaliased.type.Field
 import ch.ergon.dope.resolvable.fromable.AliasedBucket
 import ch.ergon.dope.resolvable.fromable.Bucket
+import ch.ergon.dope.resolvable.fromable.UnaliasedBucket
+import ch.ergon.dope.resolvable.operator.FunctionOperator
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
+import ch.ergon.dope.validtype.ValidType
 
-class MetaExpression(private val bucket: Bucket) : TypeExpression<StringType> {
+class MetaExpression(private val bucket: Bucket) : TypeExpression<StringType>, FunctionOperator {
     override fun toDopeQuery(): DopeQuery {
         val bucketDopeQuery = bucket.toDopeQuery()
         return DopeQuery(
-            queryString = "META(${
-            when (bucket) {
-                is AliasedBucket -> bucket.alias
-                else -> bucketDopeQuery.queryString
-            }
-            })",
+            queryString = toFunctionQueryString(
+                "META",
+                when (bucket) {
+                    is AliasedBucket -> "`${bucket.alias}`"
+                    is UnaliasedBucket -> bucketDopeQuery.queryString
+                },
+            ),
             parameters = bucketDopeQuery.parameters,
         )
     }
 
-    val cas: Field<NumberType> = Field("cas", toDopeQuery().queryString)
+    val cas: Field<NumberType> = getMetaField("cas")
 
-    val expiration: Field<NumberType> = Field("expiration", toDopeQuery().queryString)
+    val expiration: Field<NumberType> = getMetaField("expiration")
 
-    val flags: Field<NumberType> = Field("flags", toDopeQuery().queryString)
+    val flags: Field<NumberType> = getMetaField("flags")
 
-    val id: Field<StringType> = Field("id", toDopeQuery().queryString)
+    val id: Field<StringType> = getMetaField("id")
 
-    val type: Field<StringType> = Field("type", toDopeQuery().queryString)
+    val type: Field<StringType> = getMetaField("type")
 
-    val keyspace: Field<StringType> = Field("keyspace", toDopeQuery().queryString)
+    val keyspace: Field<StringType> = getMetaField("keyspace")
+
+    private fun <T : ValidType> getMetaField(field: String): MetaField<T> = MetaField(field, toDopeQuery().queryString)
+
+    private class MetaField<T : ValidType>(private val name: String, private val queryString: String) : Field<T>(name, "") {
+        override fun toDopeQuery(): DopeQuery = DopeQuery(
+            queryString = "$queryString.`$name`",
+            parameters = emptyMap(),
+        )
+    }
 }
 
 fun meta(bucket: Bucket) = MetaExpression(bucket)

core/src/main/kotlin/ch/ergon/dope/resolvable/fromable/AliasedSelectClause.kt

@@ -7,7 +7,7 @@ class AliasedSelectClause(private val alias: String, private val selectClause: I
     override fun toDopeQuery(): DopeQuery {
         val selectClauseDopeQuery = selectClause.toDopeQuery()
         return DopeQuery(
-            queryString = "(${selectClauseDopeQuery.queryString}) AS $alias",
+            queryString = "(${selectClauseDopeQuery.queryString}) AS `$alias`",
             parameters = selectClauseDopeQuery.parameters,
         )
     }

core/src/main/kotlin/ch/ergon/dope/resolvable/fromable/Bucket.kt

@@ -4,7 +4,7 @@ import ch.ergon.dope.DopeQuery
 import ch.ergon.dope.resolvable.expression.AsteriskExpression
 
 sealed class Bucket(open val name: String) : Fromable {
-    override fun toDopeQuery(): DopeQuery = DopeQuery(name, emptyMap())
+    override fun toDopeQuery(): DopeQuery = DopeQuery("`$name`", emptyMap())
 }
 
 open class UnaliasedBucket(name: String) : Bucket(name) {
@@ -13,7 +13,7 @@ open class UnaliasedBucket(name: String) : Bucket(name) {
 
 class AliasedBucket(name: String, val alias: String) : Bucket(name) {
     override fun toDopeQuery(): DopeQuery = DopeQuery(
-        queryString = "$name AS $alias",
+        queryString = "`$name` AS `$alias`",
         parameters = emptyMap(),
     )
 }

core/src/test/kotlin/ch/ergon/dope/ArrayTest.kt

@@ -28,7 +28,7 @@ class ArrayTest {
     @Test
     fun `should support arrays`() {
         val person = someBucket("person")
-        val expected = "SELECT [person.fname, stringField] FROM person"
+        val expected = "SELECT [`person`.`fname`, `stringField`] FROM `person`"
 
         val actual: String = create
             .select(
@@ -43,7 +43,7 @@ class ArrayTest {
     @Test
     fun `should support multiple arrays`() {
         val person = someBucket("person")
-        val expected = "SELECT [stringField], [stringField] FROM person"
+        val expected = "SELECT [`stringField`], [`stringField`] FROM `person`"
 
         val actual: String = create
             .select(
@@ -59,7 +59,7 @@ class ArrayTest {
     @Test
     fun `should support arrays with multiple types`() {
         val person = someBucket("person")
-        val expected = "SELECT [\"test\", 53, TRUE, stringField, person.age, booleanField] FROM person"
+        val expected = "SELECT [\"test\", 53, TRUE, `stringField`, `person`.`age`, `booleanField`] FROM `person`"
 
         val actual: String = create
             .select(
@@ -81,7 +81,7 @@ class ArrayTest {
     @Test
     fun `should support array aliased`() {
         val person = someBucket("person")
-        val expected = "SELECT [stringField] AS test FROM person"
+        val expected = "SELECT [`stringField`] AS `test` FROM `person`"
 
         val actual: String = create
             .select(
@@ -96,7 +96,7 @@ class ArrayTest {
     @Test
     fun `should support multiple arrays aliased`() {
         val person = someBucket("person")
-        val expected = "SELECT [stringField] AS fname, [stringField] AS true FROM person"
+        val expected = "SELECT [`stringField`] AS `fname`, [`stringField`] AS `true` FROM `person`"
 
         val actual: String = create
             .select(
@@ -112,7 +112,7 @@ class ArrayTest {
     @Test
     fun `should support nested arrays`() {
         val person = someBucket("person")
-        val expected = "SELECT [stringField, [person.age, TRUE, \"string\"], 23] AS test FROM person"
+        val expected = "SELECT [`stringField`, [`person`.`age`, TRUE, \"string\"], 23] AS `test` FROM `person`"
 
         val actual: String = create
             .select(
@@ -135,7 +135,7 @@ class ArrayTest {
     @Test
     fun `should support string arrays`() {
         val person = someBucket("person")
-        val expected = "SELECT [\"string\", \"hallo\"] FROM person"
+        val expected = "SELECT [\"string\", \"hallo\"] FROM `person`"
 
         val actual: String = create
             .select(
@@ -153,7 +153,7 @@ class ArrayTest {
     @Test
     fun `should support stringFunction in string arrays`() {
         val person = someBucket("person")
-        val expected = "SELECT [CONCAT(\"string\", stringField), \"hallo\"] AS test, 23 FROM person"
+        val expected = "SELECT [CONCAT(\"string\", `stringField`), \"hallo\"] AS `test`, 23 FROM `person`"
 
         val actual: String = create
             .select(
@@ -172,7 +172,7 @@ class ArrayTest {
     @Test
     fun `should support in array`() {
         val person = someBucket("person")
-        val expected = "SELECT TRUE IN [FALSE] FROM person"
+        val expected = "SELECT TRUE IN [FALSE] FROM `person`"
 
         val actual: String = create
             .select(
@@ -191,7 +191,7 @@ class ArrayTest {
     @Test
     fun `should support in array aliased`() {
         val person = someBucket("person")
-        val expected = "SELECT TRUE IN [FALSE] AS test FROM person"
+        val expected = "SELECT TRUE IN [FALSE] AS `test` FROM `person`"
 
         val actual: String = create
             .select(
@@ -209,7 +209,7 @@ class ArrayTest {
 
     @Test
     fun `should support in array with boolean and collection`() {
-        val expected = "SELECT TRUE IN [FALSE, TRUE] AS test FROM person"
+        val expected = "SELECT TRUE IN [FALSE, TRUE] AS `test` FROM `person`"
 
         val actual: String = create
             .select(
@@ -228,7 +228,7 @@ class ArrayTest {
 
     @Test
     fun `should support in array with string and collection`() {
-        val expected = "SELECT \"test\" IN [stringField, \"string\"] AS test FROM person"
+        val expected = "SELECT \"test\" IN [`stringField`, \"string\"] AS `test` FROM `person`"
 
         val actual: String = create
             .select(
@@ -247,7 +247,7 @@ class ArrayTest {
 
     @Test
     fun `should support in array with number and collection`() {
-        val expected = "SELECT 3 IN [numberField, 23] AS test FROM someBucket"
+        val expected = "SELECT 3 IN [`numberField`, 23] AS `test` FROM `someBucket`"
 
         val actual: String = create
             .select(
@@ -266,7 +266,7 @@ class ArrayTest {
 
     @Test
     fun `should support in array with field and collection`() {
-        val expected = "SELECT numberField IN [23] AS test FROM person"
+        val expected = "SELECT `numberField` IN [23] AS `test` FROM `person`"
 
         val actual: String = create
             .select(
@@ -285,7 +285,7 @@ class ArrayTest {
     @Test
     fun `should support in array as whereClause`() {
         val person = someBucket("person")
-        val expected = "SELECT * FROM person WHERE stringField IN [\"string\", \"hallo\"]"
+        val expected = "SELECT * FROM `person` WHERE `stringField` IN [\"string\", \"hallo\"]"
 
         val actual: String = create
             .selectFrom(