DOPE-202: extended Bucket with Expression and added functionality for…

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

@@ -3,13 +3,15 @@ package ch.ergon.dope.resolvable.clause.model
 import ch.ergon.dope.DopeQuery
 import ch.ergon.dope.resolvable.clause.ISelectClause
 import ch.ergon.dope.resolvable.expression.Expression
+import ch.ergon.dope.resolvable.expression.SingleExpression
 import ch.ergon.dope.resolvable.formatToQueryString
+import ch.ergon.dope.resolvable.fromable.AliasedBucket
 
 class SelectClause(private val expression: Expression, private vararg val expressions: Expression) : ISelectClause {
 
     override fun toDopeQuery(): DopeQuery {
-        val expressionDopeQuery = expression.toDopeQuery()
-        val expressionsDopeQuery = expressions.map { it.toDopeQuery() }
+        val expressionDopeQuery = getExpressionDopeQuery(expression)
+        val expressionsDopeQuery = expressions.map { getExpressionDopeQuery(it) }
         return DopeQuery(
             queryString = formatToQueryString(
                 "SELECT",
@@ -23,7 +25,7 @@ class SelectClause(private val expression: Expression, private vararg val expres
     }
 }
 
-class SelectRawClause(private val expression: Expression) : ISelectClause {
+class SelectRawClause(private val expression: SingleExpression) : ISelectClause {
 
     override fun toDopeQuery(): DopeQuery {
         val expressionDopeQuery = expression.toDopeQuery()
@@ -36,8 +38,8 @@ class SelectRawClause(private val expression: Expression) : ISelectClause {
 
 class SelectDistinctClause(private val expression: Expression, private vararg val expressions: Expression) : ISelectClause {
     override fun toDopeQuery(): DopeQuery {
-        val expressionsDopeQuery = expressions.map { it.toDopeQuery() }
-        val expressionDopeQuery = expression.toDopeQuery()
+        val expressionDopeQuery = getExpressionDopeQuery(expression)
+        val expressionsDopeQuery = expressions.map { getExpressionDopeQuery(it) }
         return DopeQuery(
             queryString = formatToQueryString(
                 "SELECT DISTINCT",
@@ -50,3 +52,6 @@ class SelectDistinctClause(private val expression: Expression, private vararg va
         )
     }
 }
+
+private fun getExpressionDopeQuery(expression: Expression) =
+    if (expression is AliasedBucket) DopeQuery("`${expression.alias}`", emptyMap()) else expression.toDopeQuery()

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

@@ -8,7 +8,7 @@ import ch.ergon.dope.validtype.ValidType
 class AliasedExpression<T : ValidType>(
     private val unaliasedExpression: UnaliasedExpression<T>,
     private val alias: String,
-) : Expression {
+) : SingleExpression {
     override fun toDopeQuery(): DopeQuery {
         val unaliasedExpressionDopeQuery = unaliasedExpression.toDopeQuery()
         return DopeQuery(

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

@@ -2,8 +2,9 @@ package ch.ergon.dope.resolvable.fromable
 
 import ch.ergon.dope.DopeQuery
 import ch.ergon.dope.resolvable.expression.AsteriskExpression
+import ch.ergon.dope.resolvable.expression.Expression
 
-sealed class Bucket(open val name: String) : Fromable {
+sealed class Bucket(open val name: String) : Fromable, Expression {
     override fun toDopeQuery() = DopeQuery("`$name`", emptyMap())
 }
 

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

@@ -787,4 +787,18 @@ class QueryBuilderTest {
 
         assertEquals(expected, actual)
     }
+
+    @Test
+    fun `should support select with buckets`() {
+        val expected = "SELECT `bucket1`, `alias` FROM `bucket2` AS `alias`"
+        val bucket1 = someBucket("bucket1")
+        val bucket2 = someBucket("bucket2").alias("alias")
+
+        val actual = create
+            .select(bucket1, bucket2)
+            .from(bucket2)
+            .build().queryString
+
+        assertEquals(expected, actual)
+    }
 }

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

@@ -2,6 +2,7 @@ package ch.ergon.dope.resolvable.clause
 
 import ch.ergon.dope.DopeQuery
 import ch.ergon.dope.helper.ParameterDependentTest
+import ch.ergon.dope.helper.someBucket
 import ch.ergon.dope.helper.someNumberField
 import ch.ergon.dope.helper.someStringArrayField
 import ch.ergon.dope.helper.someStringField
@@ -27,6 +28,32 @@ class SelectClauseTest : ParameterDependentTest {
         assertEquals(expected, actual)
     }
 
+    @Test
+    fun `should support select with bucket`() {
+        val expected = DopeQuery(
+            "SELECT `someBucket`",
+            emptyMap(),
+        )
+        val underTest = SelectClause(someBucket())
+
+        val actual = underTest.toDopeQuery()
+
+        assertEquals(expected, actual)
+    }
+
+    @Test
+    fun `should support select with aliased bucket`() {
+        val expected = DopeQuery(
+            "SELECT `alias`",
+            emptyMap(),
+        )
+        val underTest = SelectClause(someBucket().alias("alias"))
+
+        val actual = underTest.toDopeQuery()
+
+        assertEquals(expected, actual)
+    }
+
     @Test
     fun `should support select with positional parameter`() {
         val parameterValue = "value"
@@ -67,6 +94,32 @@ class SelectClauseTest : ParameterDependentTest {
         assertEquals(expected, actual)
     }
 
+    @Test
+    fun `should support select distinct with bucket`() {
+        val expected = DopeQuery(
+            "SELECT DISTINCT `someBucket`",
+            emptyMap(),
+        )
+        val underTest = SelectDistinctClause(someBucket())
+
+        val actual = underTest.toDopeQuery()
+
+        assertEquals(expected, actual)
+    }
+
+    @Test
+    fun `should support select distinct with aliased bucket`() {
+        val expected = DopeQuery(
+            "SELECT DISTINCT `alias`",
+            emptyMap(),
+        )
+        val underTest = SelectDistinctClause(someBucket().alias("alias"))
+
+        val actual = underTest.toDopeQuery()
+
+        assertEquals(expected, actual)
+    }
+
     @Test
     fun `should support select distinct with positional parameter`() {
         val parameterValue = "value"