Skip to content

Commit

Permalink
Merge pull request #57 from ergon/feature/dope-238-extend-string-func…
Browse files Browse the repository at this point in the history
…tions

DOPE-238: added missing string functions
  • Loading branch information
martinagallati-ergon authored Oct 7, 2024
2 parents d8022a9 + 670ccef commit 6869744
Show file tree
Hide file tree
Showing 104 changed files with 6,424 additions and 449 deletions.
Original file line number Diff line number Diff line change
Expand Up @@ -9,18 +9,18 @@ import ch.ergon.dope.validtype.ValidType

abstract class FunctionExpression<T : ValidType>(
private val symbol: String,
private vararg val expressions: UnaliasedExpression<T>,
private vararg val expressions: UnaliasedExpression<out ValidType>?,
) : TypeExpression<T>, FunctionOperator {
override fun toDopeQuery(manager: DopeQueryManager): DopeQuery {
val expressionsDopeQuery = expressions.map { it.toDopeQuery(manager) }
val expressionsDopeQuery = expressions.mapNotNull { it?.toDopeQuery(manager) }
return DopeQuery(
queryString = toFunctionQueryString(
symbol,
*expressionsDopeQuery.toTypedArray(),
),
parameters = expressionsDopeQuery.fold(
emptyMap(),
) { expressionParameters, expression -> expressionParameters + expression.parameters },
parameters = expressionsDopeQuery.fold(emptyMap()) { expressionParameters, expression ->
expressionParameters + expression.parameters
},
)
}
}
Original file line number Diff line number Diff line change
@@ -1,54 +1,28 @@
package ch.ergon.dope.resolvable.expression.unaliased.type.function.stringfunction

import ch.ergon.dope.DopeQuery
import ch.ergon.dope.DopeQueryManager
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.resolvable.operator.FunctionOperator
import ch.ergon.dope.validtype.StringType

// Separator is used as an argument and not as a formatting option
class Concat2Expression(
private val separator: TypeExpression<StringType>,
private val string: TypeExpression<StringType>,
private vararg val strings: TypeExpression<StringType>,
) : TypeExpression<StringType>, FunctionOperator {
override fun toDopeQuery(manager: DopeQueryManager): DopeQuery {
val separatorDopeQuery = separator.toDopeQuery(manager)
val stringDopeQuery = string.toDopeQuery(manager)
val stringsDopeQuery = strings.map { it.toDopeQuery(manager) }
return DopeQuery(
queryString = toFunctionQueryString(
symbol = "CONCAT2",
separatorDopeQuery,
stringDopeQuery,
*stringsDopeQuery.toTypedArray(),
),
parameters = separatorDopeQuery.parameters + stringDopeQuery.parameters + stringsDopeQuery.fold(
emptyMap(),
) { stringParameters, field -> stringParameters + field.parameters },
)
}
}
separator: TypeExpression<StringType>,
string: TypeExpression<StringType>,
vararg strings: TypeExpression<StringType>,
) : FunctionExpression<StringType>("CONCAT2", separator, string, *strings)

fun concat2(separator: TypeExpression<StringType>, string: TypeExpression<StringType>, vararg strings: TypeExpression<StringType>) =
Concat2Expression(separator, string, *strings)
fun concat2(
separator: TypeExpression<StringType>,
string: TypeExpression<StringType>,
vararg strings: TypeExpression<StringType>,
) = Concat2Expression(separator, string, *strings)

fun concat2(separator: String, string: String, vararg strings: String) = concat2(
separator.toDopeType(),
string.toDopeType(),
*wrapVarargsWithStringValueType(
*strings,
),
)
fun concat2(separator: String, string: String, vararg strings: String) =
concat2(separator.toDopeType(), string.toDopeType(), *strings.map { it.toDopeType() }.toTypedArray())

fun concat2(separator: TypeExpression<StringType>, string: String, vararg strings: String) = concat2(
separator,
string.toDopeType(),
*wrapVarargsWithStringValueType(
*strings,
),
)
fun concat2(separator: TypeExpression<StringType>, string: String, vararg strings: String) =
concat2(separator, string.toDopeType(), *strings.map { it.toDopeType() }.toTypedArray())

fun concat2(separator: String, string: TypeExpression<StringType>, vararg strings: TypeExpression<StringType>) =
concat2(separator.toDopeType(), string, *strings)
Original file line number Diff line number Diff line change
@@ -1,45 +1,27 @@
package ch.ergon.dope.resolvable.expression.unaliased.type.function.stringfunction

import ch.ergon.dope.DopeQuery
import ch.ergon.dope.DopeQueryManager
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.resolvable.operator.FunctionOperator
import ch.ergon.dope.validtype.StringType

class ConcatExpression(
private val firstString: TypeExpression<StringType>,
private val secondString: TypeExpression<StringType>,
private vararg val stringTypes: TypeExpression<StringType>,
) : TypeExpression<StringType>, FunctionOperator {
override fun toDopeQuery(manager: DopeQueryManager): DopeQuery {
val firstStringDopeQuery = firstString.toDopeQuery(manager)
val secondStringDopeQuery = secondString.toDopeQuery(manager)
val stringTypesDopeQuery = stringTypes.map { it.toDopeQuery(manager) }
return DopeQuery(
queryString = toFunctionQueryString(
symbol = "CONCAT",
firstStringDopeQuery,
secondStringDopeQuery,
*stringTypesDopeQuery.toTypedArray(),
),
parameters = firstStringDopeQuery.parameters + secondStringDopeQuery.parameters + stringTypesDopeQuery.fold(
emptyMap(),
) { stringTypeParameters, field -> stringTypeParameters + field.parameters },
)
}
}
firstString: TypeExpression<StringType>,
secondString: TypeExpression<StringType>,
vararg stringTypes: TypeExpression<StringType>,
) : FunctionExpression<StringType>("CONCAT", firstString, secondString, *stringTypes)

fun concat(firstString: TypeExpression<StringType>, secondString: TypeExpression<StringType>, vararg strings: TypeExpression<StringType>) =
ConcatExpression(firstString, secondString, *strings)
fun concat(
firstString: TypeExpression<StringType>,
secondString: TypeExpression<StringType>,
vararg strings: TypeExpression<StringType>,
) = ConcatExpression(firstString, secondString, *strings)

fun concat(firstString: String, secondString: TypeExpression<StringType>, vararg strings: TypeExpression<StringType>) =
concat(firstString.toDopeType(), secondString, *strings)

fun concat(firstString: TypeExpression<StringType>, secondString: String, vararg strings: String) =
concat(firstString, secondString.toDopeType(), *wrapVarargsWithStringValueType(*strings))
concat(firstString, secondString.toDopeType(), *strings.map { it.toDopeType() }.toTypedArray())

fun concat(firstString: String, secondString: String, vararg strings: String) =
concat(firstString.toDopeType(), secondString.toDopeType(), *wrapVarargsWithStringValueType(*strings))

internal fun wrapVarargsWithStringValueType(vararg strings: String) = strings.map { it.toDopeType() }.toTypedArray()
concat(firstString.toDopeType(), secondString.toDopeType(), *strings.map { it.toDopeType() }.toTypedArray())
Original file line number Diff line number Diff line change
@@ -1,28 +1,18 @@
package ch.ergon.dope.resolvable.expression.unaliased.type.function.stringfunction

import ch.ergon.dope.DopeQuery
import ch.ergon.dope.DopeQueryManager
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.resolvable.operator.FunctionOperator
import ch.ergon.dope.validtype.BooleanType
import ch.ergon.dope.validtype.StringType

class ContainsExpression(
private val inStr: TypeExpression<StringType>,
private val searchStr: TypeExpression<StringType>,
) : TypeExpression<BooleanType>, FunctionOperator {
override fun toDopeQuery(manager: DopeQueryManager): DopeQuery {
val inStrDopeQuery = inStr.toDopeQuery(manager)
val searchStrDopeQuery = searchStr.toDopeQuery(manager)
return DopeQuery(
queryString = toFunctionQueryString(symbol = "CONTAINS", inStrDopeQuery, searchStrDopeQuery),
parameters = inStrDopeQuery.parameters + searchStrDopeQuery.parameters,
)
}
}
inStr: TypeExpression<StringType>,
searchStr: TypeExpression<StringType>,
) : FunctionExpression<BooleanType>("CONTAINS", inStr, searchStr)

fun contains(inStr: TypeExpression<StringType>, searchStr: TypeExpression<StringType>) = ContainsExpression(inStr, searchStr)
fun contains(inStr: TypeExpression<StringType>, searchStr: TypeExpression<StringType>) =
ContainsExpression(inStr, searchStr)

fun contains(inStr: String, searchStr: String) = contains(inStr.toDopeType(), searchStr.toDopeType())

Expand Down
Original file line number Diff line number Diff line change
@@ -1,39 +1,17 @@
package ch.ergon.dope.resolvable.expression.unaliased.type.function.stringfunction

import ch.ergon.dope.DopeQuery
import ch.ergon.dope.DopeQueryManager
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.resolvable.operator.FunctionOperator
import ch.ergon.dope.validtype.StringType

class InitCapExpression(
private val inStr: TypeExpression<StringType>,
) : TypeExpression<StringType>, FunctionOperator {
override fun toDopeQuery(manager: DopeQueryManager): DopeQuery {
val inStrDopeQuery = inStr.toDopeQuery(manager)
return DopeQuery(
queryString = toFunctionQueryString(symbol = "INITCAP", inStrDopeQuery),
parameters = inStrDopeQuery.parameters,
)
}
}
class InitCapExpression(inStr: TypeExpression<StringType>) : FunctionExpression<StringType>("INITCAP", inStr)

fun initCap(inStr: TypeExpression<StringType>) = InitCapExpression(inStr)

fun initCap(inStr: String) = initCap(inStr.toDopeType())

class TitleExpression(
private val inStr: TypeExpression<StringType>,
) : TypeExpression<StringType>, FunctionOperator {
override fun toDopeQuery(manager: DopeQueryManager): DopeQuery {
val inStrDopeQuery = inStr.toDopeQuery(manager)
return DopeQuery(
queryString = toFunctionQueryString(symbol = "TITLE", inStrDopeQuery),
parameters = inStrDopeQuery.parameters,
)
}
}
class TitleExpression(inStr: TypeExpression<StringType>) : FunctionExpression<StringType>("TITLE", inStr)

fun title(inStr: TypeExpression<StringType>) = TitleExpression(inStr)

Expand Down
Original file line number Diff line number Diff line change
@@ -1,23 +1,12 @@
package ch.ergon.dope.resolvable.expression.unaliased.type.function.stringfunction

import ch.ergon.dope.DopeQuery
import ch.ergon.dope.DopeQueryManager
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.resolvable.operator.FunctionOperator
import ch.ergon.dope.validtype.NumberType
import ch.ergon.dope.validtype.StringType

class LengthExpression(
private val inStr: TypeExpression<StringType>,
) : TypeExpression<StringType>, FunctionOperator {
override fun toDopeQuery(manager: DopeQueryManager): DopeQuery {
val inStrDopeQuery = inStr.toDopeQuery(manager)
return DopeQuery(
queryString = toFunctionQueryString(symbol = "LENGTH", inStrDopeQuery),
parameters = inStrDopeQuery.parameters,
)
}
}
class LengthExpression(inStr: TypeExpression<StringType>) : FunctionExpression<NumberType>("LENGTH", inStr)

fun length(inStr: TypeExpression<StringType>) = LengthExpression(inStr)

Expand Down
Original file line number Diff line number Diff line change
@@ -1,23 +1,11 @@
package ch.ergon.dope.resolvable.expression.unaliased.type.function.stringfunction

import ch.ergon.dope.DopeQuery
import ch.ergon.dope.DopeQueryManager
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.resolvable.operator.FunctionOperator
import ch.ergon.dope.validtype.StringType

class LowerExpression(
private val inStr: TypeExpression<StringType>,
) : TypeExpression<StringType>, FunctionOperator {
override fun toDopeQuery(manager: DopeQueryManager): DopeQuery {
val inStrDopeQuery = inStr.toDopeQuery(manager)
return DopeQuery(
queryString = toFunctionQueryString(symbol = "LOWER", inStrDopeQuery),
parameters = inStrDopeQuery.parameters,
)
}
}
class LowerExpression(inStr: TypeExpression<StringType>) : FunctionExpression<StringType>("LOWER", inStr)

fun lower(inStr: TypeExpression<StringType>) = LowerExpression(inStr)

Expand Down
Original file line number Diff line number Diff line change
@@ -1,28 +1,16 @@
package ch.ergon.dope.resolvable.expression.unaliased.type.function.stringfunction

import ch.ergon.dope.DopeQuery
import ch.ergon.dope.DopeQueryManager
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.resolvable.operator.FunctionOperator
import ch.ergon.dope.validtype.NumberType
import ch.ergon.dope.validtype.StringType

class LpadExpression(
private val inStr: TypeExpression<StringType>,
private val size: TypeExpression<NumberType>,
private val prefix: TypeExpression<StringType>? = null,
) : TypeExpression<StringType>, FunctionOperator {
override fun toDopeQuery(manager: DopeQueryManager): DopeQuery {
val inStrDopeQuery = inStr.toDopeQuery(manager)
val sizeDopeQuery = size.toDopeQuery(manager)
val prefixDopeQuery = prefix?.toDopeQuery(manager)
return DopeQuery(
queryString = toFunctionQueryString(symbol = "LPAD", inStrDopeQuery, sizeDopeQuery, prefixDopeQuery),
parameters = inStrDopeQuery.parameters + sizeDopeQuery.parameters + prefixDopeQuery?.parameters.orEmpty(),
)
}
}
inStr: TypeExpression<StringType>,
size: TypeExpression<NumberType>,
prefix: TypeExpression<StringType>? = null,
) : FunctionExpression<StringType>("LPAD", inStr, size, prefix)

fun lpad(
inStr: TypeExpression<StringType>,
Expand All @@ -33,24 +21,20 @@ fun lpad(
fun lpad(inStr: TypeExpression<StringType>, size: TypeExpression<NumberType>, prefix: String) =
lpad(inStr, size, prefix.toDopeType())

fun lpad(inStr: TypeExpression<StringType>, size: Number, prefix: TypeExpression<StringType>) =
fun lpad(inStr: TypeExpression<StringType>, size: Number, prefix: TypeExpression<StringType>? = null) =
lpad(inStr, size.toDopeType(), prefix)

fun lpad(inStr: String, size: TypeExpression<NumberType>, prefix: TypeExpression<StringType>) =
fun lpad(inStr: String, size: TypeExpression<NumberType>, prefix: TypeExpression<StringType>? = null) =
lpad(inStr.toDopeType(), size, prefix)

fun lpad(inStr: TypeExpression<StringType>, size: Number) = lpad(inStr, size.toDopeType())

fun lpad(inStr: TypeExpression<StringType>, size: Number, prefix: String) =
lpad(inStr, size.toDopeType(), prefix.toDopeType())

fun lpad(inStr: String, size: TypeExpression<NumberType>) = lpad(inStr.toDopeType(), size)

fun lpad(inStr: String, size: TypeExpression<NumberType>, prefix: String) =
lpad(inStr.toDopeType(), size, prefix.toDopeType())

fun lpad(inStr: String, size: Number, prefix: TypeExpression<StringType>) = lpad(inStr.toDopeType(), size.toDopeType(), prefix)

fun lpad(inStr: String, size: Number) = lpad(inStr.toDopeType(), size.toDopeType())
fun lpad(inStr: String, size: Number, prefix: TypeExpression<StringType>? = null) =
lpad(inStr.toDopeType(), size.toDopeType(), prefix)

fun lpad(inStr: String, size: Number, prefix: String) = lpad(inStr.toDopeType(), size.toDopeType(), prefix.toDopeType())
fun lpad(inStr: String, size: Number, prefix: String) =
lpad(inStr.toDopeType(), size.toDopeType(), prefix.toDopeType())
Original file line number Diff line number Diff line change
@@ -1,33 +1,18 @@
package ch.ergon.dope.resolvable.expression.unaliased.type.function.stringfunction

import ch.ergon.dope.DopeQuery
import ch.ergon.dope.DopeQueryManager
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.resolvable.operator.FunctionOperator
import ch.ergon.dope.validtype.StringType

class LtrimExpression(
private val inStr: TypeExpression<StringType>,
private val char: TypeExpression<StringType>? = null,
) : TypeExpression<StringType>, FunctionOperator {
override fun toDopeQuery(manager: DopeQueryManager): DopeQuery {
val inStrDopeQuery = inStr.toDopeQuery(manager)
val charDopeQuery = char?.toDopeQuery(manager)
return DopeQuery(
queryString = toFunctionQueryString(symbol = "LTRIM", inStrDopeQuery, charDopeQuery),
parameters = inStrDopeQuery.parameters + charDopeQuery?.parameters.orEmpty(),
)
}
}
class LtrimExpression(inStr: TypeExpression<StringType>, char: TypeExpression<StringType>? = null) :
FunctionExpression<StringType>("LTRIM", inStr, char)

fun ltrim(inStr: TypeExpression<StringType>, char: TypeExpression<StringType>? = null) =
LtrimExpression(inStr, char)

fun ltrim(inStr: TypeExpression<StringType>, char: String) = ltrim(inStr, char.toDopeType())

fun ltrim(inStr: String, char: TypeExpression<StringType>) = ltrim(inStr.toDopeType(), char)
fun ltrim(inStr: String, char: TypeExpression<StringType>? = null) = ltrim(inStr.toDopeType(), char)

fun ltrim(inStr: String, char: String) = ltrim(inStr.toDopeType(), char.toDopeType())

fun ltrim(inStr: String) = ltrim(inStr.toDopeType())
Original file line number Diff line number Diff line change
@@ -0,0 +1,13 @@
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 MBLengthExpression(inStr: TypeExpression<StringType>) : FunctionExpression<NumberType>("MB_LENGTH", inStr)

fun mbLength(inStr: TypeExpression<StringType>) = MBLengthExpression(inStr)

fun mbLength(inStr: String) = mbLength(inStr.toDopeType())
Loading

0 comments on commit 6869744

Please sign in to comment.