Merge branch 'refs/heads/main' into feature/dope-239-object-funcitons

ergon · Nov 21, 2024 · 4a74f87 · 4a74f87
2 parents c5b7e69 + c710fcd
commit 4a74f87
Show file tree

Hide file tree

Showing 24 changed files with 1,180 additions and 90 deletions.
diff --git a/.github/workflows/reviewer.yml b/.github/workflows/reviewer.yml
diff --git a/core/src/main/kotlin/ch/ergon/dope/resolvable/QueryStringBuilder.kt b/core/src/main/kotlin/ch/ergon/dope/resolvable/QueryStringBuilder.kt
@@ -20,7 +20,7 @@ fun formatPathToQueryString(name: String, path: String) =
     if (path.isBlank()) {
         "`$name`"
     } else {
-        "`$path`.`$name`"
+        "${path.split(".").joinToString(".") { "`$it`" }}.`$name`"
     }
 
 fun formatStringListToQueryStringWithBrackets(dopeQueries: List<String>, separator: String = ", ", prefix: String = "(", postfix: String = ")") =

diff --git a/core/src/main/kotlin/ch/ergon/dope/resolvable/clause/ISelectClause.kt b/core/src/main/kotlin/ch/ergon/dope/resolvable/clause/ISelectClause.kt
@@ -6,11 +6,11 @@ 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.OrderByType
+import ch.ergon.dope.resolvable.clause.model.OrderExpression
 import ch.ergon.dope.resolvable.clause.model.RightJoinClause
 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.clause.model.SelectOrderByTypeClause
 import ch.ergon.dope.resolvable.clause.model.SelectWhereClause
 import ch.ergon.dope.resolvable.clause.model.StandardJoinClause
 import ch.ergon.dope.resolvable.clause.model.UnnestClause
@@ -27,7 +27,6 @@ import ch.ergon.dope.resolvable.fromable.Joinable
 import ch.ergon.dope.validtype.ArrayType
 import ch.ergon.dope.validtype.BooleanType
 import ch.ergon.dope.validtype.NumberType
-import ch.ergon.dope.validtype.StringType
 import ch.ergon.dope.validtype.ValidType
 
 interface ISelectOffsetClause<T : ValidType> : Clause {
@@ -46,9 +45,10 @@ interface ISelectOrderByClause<T : ValidType> : ISelectLimitClause<T> {
 }
 
 interface ISelectGroupByClause<T : ValidType> : ISelectOrderByClause<T> {
-    fun orderBy(stringField: Field<StringType>) = SelectOrderByClause(stringField, this)
-    fun orderBy(stringField: Field<StringType>, orderByType: OrderByType) =
-        SelectOrderByTypeClause(stringField, orderByType, this)
+    fun orderBy(expression: TypeExpression<out ValidType>, orderByType: OrderByType? = null) = SelectOrderByClause(
+        OrderExpression(expression, orderByType),
+        parentClause = this,
+    )
 }
 
 interface ISelectWhereClause<T : ValidType> : ISelectGroupByClause<T> {

diff --git a/core/src/main/kotlin/ch/ergon/dope/resolvable/clause/model/OrderByClause.kt b/core/src/main/kotlin/ch/ergon/dope/resolvable/clause/model/OrderByClause.kt
@@ -2,49 +2,58 @@ package ch.ergon.dope.resolvable.clause.model
 
 import ch.ergon.dope.DopeQuery
 import ch.ergon.dope.DopeQueryManager
+import ch.ergon.dope.resolvable.Resolvable
 import ch.ergon.dope.resolvable.clause.ISelectGroupByClause
 import ch.ergon.dope.resolvable.clause.ISelectOrderByClause
-import ch.ergon.dope.resolvable.expression.unaliased.type.Field
+import ch.ergon.dope.resolvable.expression.TypeExpression
 import ch.ergon.dope.resolvable.formatToQueryStringWithSymbol
-import ch.ergon.dope.validtype.StringType
 import ch.ergon.dope.validtype.ValidType
 
-enum class OrderByType(val type: String) {
+enum class OrderByType(val queryString: String) {
     ASC("ASC"),
     DESC("DESC"),
 }
 
 private const val ORDER_BY = "ORDER BY"
 
-open class SelectOrderByClause<T : ValidType>(private val stringField: Field<StringType>, private val parentClause: ISelectGroupByClause<T>) :
-    ISelectOrderByClause<T> {
-
+class SelectOrderByClause<T : ValidType>(
+    private val orderExpression: OrderExpression,
+    private vararg val additionalOrderExpressions: OrderExpression,
+    private val parentClause: ISelectGroupByClause<T>,
+) : ISelectOrderByClause<T> {
     override fun toDopeQuery(manager: DopeQueryManager): DopeQuery {
         val parentDopeQuery = parentClause.toDopeQuery(manager)
-        val stringDopeQuery = stringField.toDopeQuery(manager)
+        val orderExpressionDopeQuery = orderExpression.toDopeQuery(manager)
+        val additionalOrderExpressions = additionalOrderExpressions.map { it.toDopeQuery(manager) }
         return DopeQuery(
-            queryString = formatToQueryStringWithSymbol(parentDopeQuery.queryString, ORDER_BY, stringDopeQuery.queryString),
-            parameters = parentDopeQuery.parameters.merge(stringDopeQuery.parameters),
+            queryString = formatToQueryStringWithSymbol(
+                parentDopeQuery.queryString,
+                ORDER_BY,
+                orderExpressionDopeQuery.queryString,
+                *additionalOrderExpressions.map { it.queryString }.toTypedArray(),
+            ),
+            parameters = parentDopeQuery.parameters.merge(
+                orderExpressionDopeQuery.parameters,
+                *additionalOrderExpressions.map { it.parameters }.toTypedArray(),
+            ),
         )
     }
-}
 
-class SelectOrderByTypeClause<T : ValidType>(
-    private val stringField: Field<StringType>,
-    private val orderByType: OrderByType,
-    private val parentClause: ISelectGroupByClause<T>,
-) : SelectOrderByClause<T>(stringField, parentClause) {
+    fun thenOrderBy(typeExpression: TypeExpression<out ValidType>, orderByType: OrderByType? = null) =
+        SelectOrderByClause(
+            this.orderExpression,
+            *additionalOrderExpressions,
+            OrderExpression(typeExpression, orderByType),
+            parentClause = this.parentClause,
+        )
+}
 
+class OrderExpression(private val expression: TypeExpression<out ValidType>, private val orderByType: OrderByType? = null) : Resolvable {
     override fun toDopeQuery(manager: DopeQueryManager): DopeQuery {
-        val parentDopeQuery = parentClause.toDopeQuery(manager)
-        val stringDopeQuery = stringField.toDopeQuery(manager)
+        val typeDopeQuery = expression.toDopeQuery(manager)
         return DopeQuery(
-            queryString = formatToQueryStringWithSymbol(
-                parentDopeQuery.queryString,
-                ORDER_BY,
-                stringDopeQuery.queryString + " $orderByType",
-            ),
-            parameters = parentDopeQuery.parameters.merge(stringDopeQuery.parameters),
+            queryString = listOfNotNull(typeDopeQuery.queryString, orderByType?.queryString).joinToString(separator = " "),
+            parameters = typeDopeQuery.parameters,
         )
     }
 }
diff --git a/...ope/resolvable/expression/unaliased/type/function/stringfunction/MBPosition1Expression.kt b/...ope/resolvable/expression/unaliased/type/function/stringfunction/MBPosition1Expression.kt
@@ -3,10 +3,11 @@ package ch.ergon.dope.resolvable.expression.unaliased.type.function.stringfuncti
 import ch.ergon.dope.resolvable.expression.TypeExpression
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.FunctionExpression
 import ch.ergon.dope.resolvable.expression.unaliased.type.toDopeType
+import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
 
 class MBPosition1Expression(inStr: TypeExpression<StringType>, searchStr: TypeExpression<StringType>) :
-    FunctionExpression<StringType>("MB_POSITION1", inStr, searchStr)
+    FunctionExpression<NumberType>("MB_POSITION1", inStr, searchStr)
 
 fun mbPosition1(inStr: TypeExpression<StringType>, searchStr: TypeExpression<StringType>) =
     MBPosition1Expression(inStr, searchStr)

diff --git a/...dope/resolvable/expression/unaliased/type/function/stringfunction/MBPositionExpression.kt b/...dope/resolvable/expression/unaliased/type/function/stringfunction/MBPositionExpression.kt
@@ -3,10 +3,11 @@ package ch.ergon.dope.resolvable.expression.unaliased.type.function.stringfuncti
 import ch.ergon.dope.resolvable.expression.TypeExpression
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.FunctionExpression
 import ch.ergon.dope.resolvable.expression.unaliased.type.toDopeType
+import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
 
 class MBPositionExpression(inStr: TypeExpression<StringType>, searchStr: TypeExpression<StringType>) :
-    FunctionExpression<StringType>("MB_POSITION", inStr, searchStr)
+    FunctionExpression<NumberType>("MB_POSITION", inStr, searchStr)
 
 fun mbPosition(inStr: TypeExpression<StringType>, searchStr: TypeExpression<StringType>) =
     MBPositionExpression(inStr, searchStr)

diff --git a/...gon/dope/resolvable/expression/unaliased/type/function/stringfunction/NowStrExpression.kt b/...gon/dope/resolvable/expression/unaliased/type/function/stringfunction/NowStrExpression.kt
diff --git a/.../dope/resolvable/expression/unaliased/type/function/stringfunction/Position1Expression.kt b/.../dope/resolvable/expression/unaliased/type/function/stringfunction/Position1Expression.kt
@@ -3,10 +3,11 @@ package ch.ergon.dope.resolvable.expression.unaliased.type.function.stringfuncti
 import ch.ergon.dope.resolvable.expression.TypeExpression
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.FunctionExpression
 import ch.ergon.dope.resolvable.expression.unaliased.type.toDopeType
+import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
 
 class Position1Expression(inStr: TypeExpression<StringType>, searchStr: TypeExpression<StringType>) :
-    FunctionExpression<StringType>("POSITION1", inStr, searchStr)
+    FunctionExpression<NumberType>("POSITION1", inStr, searchStr)
 
 fun position1(inStr: TypeExpression<StringType>, searchStr: TypeExpression<StringType>) =
     Position1Expression(inStr, searchStr)

diff --git a/...n/dope/resolvable/expression/unaliased/type/function/stringfunction/PositionExpression.kt b/...n/dope/resolvable/expression/unaliased/type/function/stringfunction/PositionExpression.kt
@@ -3,10 +3,11 @@ package ch.ergon.dope.resolvable.expression.unaliased.type.function.stringfuncti
 import ch.ergon.dope.resolvable.expression.TypeExpression
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.FunctionExpression
 import ch.ergon.dope.resolvable.expression.unaliased.type.toDopeType
+import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
 
 class PositionExpression(inStr: TypeExpression<StringType>, searchStr: TypeExpression<StringType>) :
-    FunctionExpression<StringType>("POSITION", inStr, searchStr)
+    FunctionExpression<NumberType>("POSITION", inStr, searchStr)
 
 fun position(inStr: TypeExpression<StringType>, searchStr: TypeExpression<StringType>) =
     PositionExpression(inStr, searchStr)

diff --git a/...on/dope/resolvable/expression/unaliased/type/function/stringfunction/ReplaceExpression.kt b/...on/dope/resolvable/expression/unaliased/type/function/stringfunction/ReplaceExpression.kt
@@ -0,0 +1,126 @@
+package ch.ergon.dope.resolvable.expression.unaliased.type.function.stringfunction
+
+import ch.ergon.dope.resolvable.expression.TypeExpression
+import ch.ergon.dope.resolvable.expression.unaliased.type.function.FunctionExpression
+import ch.ergon.dope.resolvable.expression.unaliased.type.toDopeType
+import ch.ergon.dope.validtype.NumberType
+import ch.ergon.dope.validtype.StringType
+
+class ReplaceExpression(
+    inStr: TypeExpression<StringType>,
+    searchStr: TypeExpression<StringType>,
+    replace: TypeExpression<StringType>,
+    numberOfInstances: TypeExpression<NumberType>? = null,
+) : FunctionExpression<StringType>("REPLACE", inStr, searchStr, replace, numberOfInstances)
+
+fun replace(
+    inStr: TypeExpression<StringType>,
+    searchStr: TypeExpression<StringType>,
+    replace: TypeExpression<StringType>,
+    numberOfInstances: TypeExpression<NumberType>? = null,
+) = ReplaceExpression(inStr, searchStr, replace, numberOfInstances)
+
+fun replace(
+    inStr: TypeExpression<StringType>,
+    searchStr: TypeExpression<StringType>,
+    replace: TypeExpression<StringType>,
+    numberOfInstances: Int,
+) = replace(inStr, searchStr, replace, numberOfInstances.toDopeType())
+
+fun replace(
+    inStr: TypeExpression<StringType>,
+    searchStr: TypeExpression<StringType>,
+    replace: String,
+    numberOfInstances: TypeExpression<NumberType>? = null,
+) = replace(inStr, searchStr, replace.toDopeType(), numberOfInstances)
+
+fun replace(
+    inStr: TypeExpression<StringType>,
+    searchStr: TypeExpression<StringType>,
+    replace: String,
+    numberOfInstances: Int,
+) = replace(inStr, searchStr, replace.toDopeType(), numberOfInstances.toDopeType())
+
+fun replace(
+    inStr: TypeExpression<StringType>,
+    searchStr: String,
+    replace: TypeExpression<StringType>,
+    numberOfInstances: TypeExpression<NumberType>? = null,
+) = replace(inStr, searchStr.toDopeType(), replace, numberOfInstances)
+
+fun replace(
+    inStr: TypeExpression<StringType>,
+    searchStr: String,
+    replace: TypeExpression<StringType>,
+    numberOfInstances: Int,
+) = replace(inStr, searchStr.toDopeType(), replace, numberOfInstances.toDopeType())
+
+fun replace(
+    inStr: TypeExpression<StringType>,
+    searchStr: String,
+    replace: String,
+    numberOfInstances: TypeExpression<NumberType>? = null,
+) = replace(inStr, searchStr.toDopeType(), replace.toDopeType(), numberOfInstances)
+
+fun replace(
+    inStr: TypeExpression<StringType>,
+    searchStr: String,
+    replace: String,
+    numberOfInstances: Int,
+) = replace(inStr, searchStr.toDopeType(), replace.toDopeType(), numberOfInstances.toDopeType())
+
+fun replace(
+    inStr: String,
+    searchStr: TypeExpression<StringType>,
+    replace: TypeExpression<StringType>,
+    numberOfInstances: TypeExpression<NumberType>? = null,
+) = replace(inStr.toDopeType(), searchStr, replace, numberOfInstances)
+
+fun replace(
+    inStr: String,
+    searchStr: TypeExpression<StringType>,
+    replace: TypeExpression<StringType>,
+    numberOfInstances: Int,
+) = replace(inStr.toDopeType(), searchStr, replace, numberOfInstances.toDopeType())
+
+fun replace(
+    inStr: String,
+    searchStr: TypeExpression<StringType>,
+    replace: String,
+    numberOfInstances: TypeExpression<NumberType>? = null,
+) = replace(inStr.toDopeType(), searchStr, replace.toDopeType(), numberOfInstances)
+
+fun replace(
+    inStr: String,
+    searchStr: TypeExpression<StringType>,
+    replace: String,
+    numberOfInstances: Int,
+) = replace(inStr.toDopeType(), searchStr, replace.toDopeType(), numberOfInstances.toDopeType())
+
+fun replace(
+    inStr: String,
+    searchStr: String,
+    replace: TypeExpression<StringType>,
+    numberOfInstances: TypeExpression<NumberType>? = null,
+) = replace(inStr.toDopeType(), searchStr.toDopeType(), replace, numberOfInstances)
+
+fun replace(
+    inStr: String,
+    searchStr: String,
+    replace: TypeExpression<StringType>,
+    numberOfInstances: Int,
+) = replace(inStr.toDopeType(), searchStr.toDopeType(), replace, numberOfInstances.toDopeType())
+
+fun replace(
+    inStr: String,
+    searchStr: String,
+    replace: String,
+    numberOfInstances: TypeExpression<NumberType>? = null,
+) = replace(inStr.toDopeType(), searchStr.toDopeType(), replace.toDopeType(), numberOfInstances)
+
+fun replace(
+    inStr: String,
+    searchStr: String,
+    replace: String,
+    numberOfInstances: Int,
+) = replace(inStr.toDopeType(), searchStr.toDopeType(), replace.toDopeType(), numberOfInstances.toDopeType())
diff --git a/...rgon/dope/resolvable/expression/unaliased/type/function/stringfunction/SplitExpression.kt b/...rgon/dope/resolvable/expression/unaliased/type/function/stringfunction/SplitExpression.kt
@@ -3,10 +3,11 @@ package ch.ergon.dope.resolvable.expression.unaliased.type.function.stringfuncti
 import ch.ergon.dope.resolvable.expression.TypeExpression
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.FunctionExpression
 import ch.ergon.dope.resolvable.expression.unaliased.type.toDopeType
+import ch.ergon.dope.validtype.ArrayType
 import ch.ergon.dope.validtype.StringType
 
 class SplitExpression(inStr: TypeExpression<StringType>, inSubstring: TypeExpression<StringType>? = null) :
-    FunctionExpression<StringType>("SPLIT", inStr, inSubstring)
+    FunctionExpression<ArrayType<StringType>>("SPLIT", inStr, inSubstring)
 
 fun split(inStr: TypeExpression<StringType>, inSubstring: TypeExpression<StringType>? = null) =
     SplitExpression(inStr, inSubstring)

diff --git a/...n/dope/resolvable/expression/unaliased/type/function/stringfunction/SuffixesExpression.kt b/...n/dope/resolvable/expression/unaliased/type/function/stringfunction/SuffixesExpression.kt
@@ -3,10 +3,11 @@ package ch.ergon.dope.resolvable.expression.unaliased.type.function.stringfuncti
 import ch.ergon.dope.resolvable.expression.TypeExpression
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.FunctionExpression
 import ch.ergon.dope.resolvable.expression.unaliased.type.toDopeType
+import ch.ergon.dope.validtype.ArrayType
 import ch.ergon.dope.validtype.StringType
 
 class SuffixesExpression(inStr: TypeExpression<StringType>) :
-    FunctionExpression<StringType>("SUFFIXES", inStr)
+    FunctionExpression<ArrayType<StringType>>("SUFFIXES", inStr)
 
 fun suffixes(inStr: TypeExpression<StringType>) = SuffixesExpression(inStr)
 

diff --git a/...gon/dope/resolvable/expression/unaliased/type/function/stringfunction/TokensExpression.kt b/...gon/dope/resolvable/expression/unaliased/type/function/stringfunction/TokensExpression.kt
@@ -6,6 +6,7 @@ import ch.ergon.dope.resolvable.expression.TypeExpression
 import ch.ergon.dope.resolvable.expression.unaliased.type.function.stringfunction.factory.CustomTokenOptions
 import ch.ergon.dope.resolvable.formatStringListToQueryStringWithBrackets
 import ch.ergon.dope.resolvable.operator.FunctionOperator
+import ch.ergon.dope.validtype.ArrayType
 import ch.ergon.dope.validtype.StringType
 
 // Argument {"case":"lower"} is optional. Valid values are lower or upper.
@@ -14,7 +15,7 @@ import ch.ergon.dope.validtype.StringType
 class TokensExpression(
     private val inStr: List<String>,
     private val opt: CustomTokenOptions = CustomTokenOptions(),
-) : TypeExpression<StringType>, FunctionOperator {
+) : TypeExpression<ArrayType<StringType>>, FunctionOperator {
     override fun toDopeQuery(manager: DopeQueryManager): DopeQuery {
         val optDopeQuery = opt.toDopeQuery()
         return DopeQuery(