Merge pull request #82 from ergon/feature/dope-197-date-functions

DOPE-197: date functions

Author: pgruntz

core/src/integrationTest/kotlin/ch/ergon/dope/functions/DateFunctionsIntegrationTest.kt

@@ -0,0 +1,36 @@
+package ch.ergon.dope.functions
+
+import ch.ergon.dope.QueryBuilder
+import ch.ergon.dope.integrationTest.BaseIntegrationTest
+import ch.ergon.dope.integrationTest.toMapValues
+import ch.ergon.dope.resolvable.expression.type.alias
+import ch.ergon.dope.resolvable.expression.type.arithmetic.add
+import ch.ergon.dope.resolvable.expression.type.collection.inArray
+import ch.ergon.dope.resolvable.expression.type.function.date.DateUnitType.DAY
+import ch.ergon.dope.resolvable.expression.type.function.date.DateUnitType.MONTH
+import ch.ergon.dope.resolvable.expression.type.function.date.dateRangeBy
+import ch.ergon.dope.resolvable.expression.type.function.date.differenceIn
+import ch.ergon.dope.resolvable.expression.type.function.date.localClockString
+import java.time.OffsetDateTime
+import java.time.format.DateTimeFormatter
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class DateFunctionsIntegrationTest : BaseIntegrationTest() {
+    @Test
+    fun `use string functions to create a new string`() {
+        val dopeQuery = QueryBuilder()
+            .select(
+                localClockString("YYYY-MM-DD").alias("localClock"),
+                "2023-10-05".differenceIn("2023-08-05", MONTH).add(3).alias("differenceInDays"),
+                "2025-09-09".inArray("2025-08-08".dateRangeBy("2025-10-10", DAY)).alias("inArray"),
+            ).build()
+
+        val queryResult = queryWithoutParameters(dopeQuery)
+        val result = queryResult.toMapValues()
+
+        assertEquals(OffsetDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd")), result["localClock"])
+        assertEquals(2 + 3, result["differenceInDays"])
+        assertEquals(true, result["inArray"])
+    }
+}

core/src/main/kotlin/ch/ergon/dope/resolvable/expression/type/function/date/ClockLocalExpression.kt

@@ -0,0 +1,12 @@
+package ch.ergon.dope.resolvable.expression.type.function.date
+
+import ch.ergon.dope.resolvable.expression.type.TypeExpression
+import ch.ergon.dope.resolvable.expression.type.function.FunctionExpression
+import ch.ergon.dope.resolvable.expression.type.toDopeType
+import ch.ergon.dope.validtype.StringType
+
+class ClockLocalExpression(format: TypeExpression<StringType>? = null) : FunctionExpression<StringType>("CLOCK_LOCAL", format)
+
+fun localClockString(format: TypeExpression<StringType>? = null) = ClockLocalExpression(format)
+
+fun localClockString(format: String) = localClockString(format.toDopeType())

core/src/main/kotlin/ch/ergon/dope/resolvable/expression/type/function/date/ClockMillisExpression.kt

@@ -0,0 +1,8 @@
+package ch.ergon.dope.resolvable.expression.type.function.date
+
+import ch.ergon.dope.resolvable.expression.type.function.FunctionExpression
+import ch.ergon.dope.validtype.NumberType
+
+class ClockMillisExpression() : FunctionExpression<NumberType>("CLOCK_MILLIS")
+
+fun clockMillis() = ClockMillisExpression()

core/src/main/kotlin/ch/ergon/dope/resolvable/expression/type/function/date/ClockStringExpression.kt

@@ -0,0 +1,12 @@
+package ch.ergon.dope.resolvable.expression.type.function.date
+
+import ch.ergon.dope.resolvable.expression.type.TypeExpression
+import ch.ergon.dope.resolvable.expression.type.function.FunctionExpression
+import ch.ergon.dope.resolvable.expression.type.toDopeType
+import ch.ergon.dope.validtype.StringType
+
+class ClockStringExpression(format: TypeExpression<StringType>? = null) : FunctionExpression<StringType>("CLOCK_STR", format)
+
+fun clockString(format: TypeExpression<StringType>? = null) = ClockStringExpression(format)
+
+fun clockString(format: String) = clockString(format.toDopeType())

core/src/main/kotlin/ch/ergon/dope/resolvable/expression/type/function/date/ClockTimezoneExpression.kt

@@ -0,0 +1,18 @@
+package ch.ergon.dope.resolvable.expression.type.function.date
+
+import ch.ergon.dope.resolvable.expression.type.TypeExpression
+import ch.ergon.dope.resolvable.expression.type.function.FunctionExpression
+import ch.ergon.dope.resolvable.expression.type.toDopeType
+import ch.ergon.dope.validtype.StringType
+
+class ClockTimezoneExpression(timeZone: TypeExpression<StringType>, format: TypeExpression<StringType>? = null) :
+    FunctionExpression<StringType>("CLOCK_TZ", timeZone, format)
+
+fun formattedClockIn(timeZone: TypeExpression<StringType>, format: TypeExpression<StringType>? = null) =
+    ClockTimezoneExpression(timeZone, format)
+
+fun formattedClockIn(timeZone: String, format: TypeExpression<StringType>? = null) = formattedClockIn(timeZone.toDopeType(), format)
+
+fun formattedClockIn(timeZone: TypeExpression<StringType>, format: String) = formattedClockIn(timeZone, format.toDopeType())
+
+fun formattedClockIn(timeZone: String, format: String) = formattedClockIn(timeZone.toDopeType(), format.toDopeType())

core/src/main/kotlin/ch/ergon/dope/resolvable/expression/type/function/date/ClockUtcExpression.kt

@@ -0,0 +1,12 @@
+package ch.ergon.dope.resolvable.expression.type.function.date
+
+import ch.ergon.dope.resolvable.expression.type.TypeExpression
+import ch.ergon.dope.resolvable.expression.type.function.FunctionExpression
+import ch.ergon.dope.resolvable.expression.type.toDopeType
+import ch.ergon.dope.validtype.StringType
+
+class ClockUtcExpression(format: TypeExpression<StringType>? = null) : FunctionExpression<StringType>("CLOCK_UTC", format)
+
+fun utcClockString(format: TypeExpression<StringType>? = null) = ClockUtcExpression(format)
+
+fun utcClockString(format: String) = utcClockString(format.toDopeType())

core/src/main/kotlin/ch/ergon/dope/resolvable/expression/type/function/date/DateAddExpression.kt

@@ -0,0 +1,57 @@
+package ch.ergon.dope.resolvable.expression.type.function.date
+
+import ch.ergon.dope.resolvable.expression.type.TypeExpression
+import ch.ergon.dope.resolvable.expression.type.function.FunctionExpression
+import ch.ergon.dope.resolvable.expression.type.toDopeType
+import ch.ergon.dope.validtype.NumberType
+import ch.ergon.dope.validtype.StringType
+
+class DateAddMillisExpression(date: TypeExpression<NumberType>, increment: TypeExpression<NumberType>, dateUnit: DateUnit) :
+    FunctionExpression<NumberType>("DATE_ADD_MILLIS", date, increment, dateUnit)
+
+class DateAddStrExpression(date: TypeExpression<StringType>, increment: TypeExpression<NumberType>, dateUnit: DateUnit) :
+    FunctionExpression<StringType>("DATE_ADD_STR", date, increment, dateUnit)
+
+@JvmName("millisPlusTypeDateComponent")
+fun TypeExpression<NumberType>.addDateUnit(
+    increment: TypeExpression<NumberType>,
+    dateUnit: DateUnit,
+) = DateAddMillisExpression(this, increment, dateUnit)
+
+@JvmName("millisPlusNumberDateComponent")
+fun TypeExpression<NumberType>.addDateUnit(
+    increment: Number,
+    dateUnit: DateUnit,
+) = addDateUnit(increment.toDopeType(), dateUnit)
+
+fun Number.addDateUnit(
+    increment: TypeExpression<NumberType>,
+    dateUnit: DateUnit,
+) = toDopeType().addDateUnit(increment, dateUnit)
+
+fun Number.addDateUnit(
+    increment: Number,
+    dateUnit: DateUnit,
+) = toDopeType().addDateUnit(increment.toDopeType(), dateUnit)
+
+@JvmName("strPlusTypeDateComponent")
+fun TypeExpression<StringType>.addDateUnit(
+    increment: TypeExpression<NumberType>,
+    dateUnit: DateUnit,
+) = DateAddStrExpression(this, increment, dateUnit)
+
+@JvmName("strPlusNumberDateComponent")
+fun TypeExpression<StringType>.addDateUnit(
+    increment: Number,
+    dateUnit: DateUnit,
+) = addDateUnit(increment.toDopeType(), dateUnit)
+
+fun String.addDateUnit(
+    increment: TypeExpression<NumberType>,
+    dateUnit: DateUnit,
+) = toDopeType().addDateUnit(increment, dateUnit)
+
+fun String.addDateUnit(
+    increment: Number,
+    dateUnit: DateUnit,
+) = toDopeType().addDateUnit(increment.toDopeType(), dateUnit)

core/src/main/kotlin/ch/ergon/dope/resolvable/expression/type/function/date/DateComponent.kt

@@ -0,0 +1,42 @@
+package ch.ergon.dope.resolvable.expression.type.function.date
+
+import ch.ergon.dope.DopeQueryManager
+import ch.ergon.dope.resolvable.expression.type.TypeExpression
+import ch.ergon.dope.resolvable.expression.type.toDopeType
+import ch.ergon.dope.validtype.StringType
+
+sealed interface DateComponent : TypeExpression<StringType>
+sealed interface DateUnit : DateComponent
+
+enum class DateUnitType(private val queryString: String) : DateUnit {
+    MILLENNIUM("MILLENNIUM"),
+    CENTURY("CENTURY"),
+    DECADE("DECADE"),
+    YEAR("YEAR"),
+    QUARTER("QUARTER"),
+    MONTH("MONTH"),
+    WEEK("WEEK"),
+    DAY("DAY"),
+    HOUR("HOUR"),
+    MINUTE("MINUTE"),
+    SECOND("SECOND"),
+    MILLISECOND("MILLISECOND"),
+    ;
+
+    override fun toDopeQuery(manager: DopeQueryManager) =
+        queryString.toDopeType().toDopeQuery(manager)
+}
+
+enum class DateComponentType(private val queryString: String) : DateComponent {
+    ISO_YEAR("ISO_YEAR"),
+    ISO_WEEK("ISO_WEEK"),
+    DAY_OF_YEAR("DAY_OF_YEAR"),
+    DAY_OF_WEEK("DAY_OF_WEEK"),
+    TIMEZONE("TIMEZONE"),
+    TIMEZONE_HOUR("TIMEZONE_HOUR"),
+    TIMEZONE_MINUTE("TIMEZONE_MINUTE"),
+    ;
+
+    override fun toDopeQuery(manager: DopeQueryManager) =
+        queryString.toDopeType().toDopeQuery(manager)
+}

core/src/main/kotlin/ch/ergon/dope/resolvable/expression/type/function/date/DateDiffExpression.kt

@@ -0,0 +1,57 @@
+package ch.ergon.dope.resolvable.expression.type.function.date
+
+import ch.ergon.dope.resolvable.expression.type.TypeExpression
+import ch.ergon.dope.resolvable.expression.type.function.FunctionExpression
+import ch.ergon.dope.resolvable.expression.type.toDopeType
+import ch.ergon.dope.validtype.NumberType
+import ch.ergon.dope.validtype.StringType
+
+class DateDiffMillisExpression(date: TypeExpression<NumberType>, other: TypeExpression<NumberType>, dateUnit: DateUnit) :
+    FunctionExpression<NumberType>("DATE_DIFF_MILLIS", date, other, dateUnit)
+
+class DateDiffStrExpression(date: TypeExpression<StringType>, other: TypeExpression<StringType>, dateUnit: DateUnit) :
+    FunctionExpression<NumberType>("DATE_DIFF_STR", date, other, dateUnit)
+
+@JvmName("millisDiffTypeDateComponent")
+fun TypeExpression<NumberType>.differenceIn(
+    other: TypeExpression<NumberType>,
+    dateUnit: DateUnit,
+) = DateDiffMillisExpression(this, other, dateUnit)
+
+@JvmName("millisDiffNumberDateComponent")
+fun TypeExpression<NumberType>.differenceIn(
+    other: Number,
+    dateUnit: DateUnit,
+) = differenceIn(other.toDopeType(), dateUnit)
+
+fun Number.differenceIn(
+    other: TypeExpression<NumberType>,
+    dateUnit: DateUnit,
+) = toDopeType().differenceIn(other, dateUnit)
+
+fun Number.differenceIn(
+    other: Number,
+    dateUnit: DateUnit,
+) = toDopeType().differenceIn(other.toDopeType(), dateUnit)
+
+@JvmName("strDiffTypeDateComponent")
+fun TypeExpression<StringType>.differenceIn(
+    other: TypeExpression<StringType>,
+    dateUnit: DateUnit,
+) = DateDiffStrExpression(this, other, dateUnit)
+
+@JvmName("strDiffNumberDateComponent")
+fun TypeExpression<StringType>.differenceIn(
+    other: String,
+    dateUnit: DateUnit,
+) = differenceIn(other.toDopeType(), dateUnit)
+
+fun String.differenceIn(
+    other: TypeExpression<StringType>,
+    dateUnit: DateUnit,
+) = toDopeType().differenceIn(other, dateUnit)
+
+fun String.differenceIn(
+    other: String,
+    dateUnit: DateUnit,
+) = toDopeType().differenceIn(other.toDopeType(), dateUnit)

core/src/main/kotlin/ch/ergon/dope/resolvable/expression/type/function/date/DateFormatStrExpression.kt

@@ -0,0 +1,17 @@
+package ch.ergon.dope.resolvable.expression.type.function.date
+
+import ch.ergon.dope.resolvable.expression.type.TypeExpression
+import ch.ergon.dope.resolvable.expression.type.function.FunctionExpression
+import ch.ergon.dope.resolvable.expression.type.toDopeType
+import ch.ergon.dope.validtype.StringType
+
+class DateFormatStrExpression(date: TypeExpression<StringType>, format: TypeExpression<StringType>) :
+    FunctionExpression<StringType>("DATE_FORMAT_STR", date, format)
+
+fun TypeExpression<StringType>.formatDate(format: TypeExpression<StringType>) = DateFormatStrExpression(this, format)
+
+fun TypeExpression<StringType>.formatDate(format: String) = formatDate(format.toDopeType())
+
+fun String.formatDate(format: TypeExpression<StringType>) = toDopeType().formatDate(format)
+
+fun String.formatDate(format: String) = toDopeType().formatDate(format.toDopeType())