• Home
• org.jetbrains.exposed
• exposed-kotlin-datetime
• 0.42.0
• source code
• KotlinDateFunctions.kt

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.jetbrains.exposed.sql.kotlin.datetime.KotlinDateFunctions.kt Maven / Gradle / Ivy

@file:Suppress("FunctionName")

package org.jetbrains.exposed.sql.kotlin.datetime

import kotlinx.datetime.Instant
import kotlinx.datetime.LocalDate
import kotlinx.datetime.LocalDateTime
import kotlinx.datetime.LocalTime
import org.jetbrains.exposed.sql.*
import org.jetbrains.exposed.sql.Function
import org.jetbrains.exposed.sql.vendors.H2Dialect
import org.jetbrains.exposed.sql.vendors.MysqlDialect
import org.jetbrains.exposed.sql.vendors.SQLServerDialect
import org.jetbrains.exposed.sql.vendors.currentDialect
import org.jetbrains.exposed.sql.vendors.h2Mode
import java.time.OffsetDateTime
import kotlin.time.Duration

internal class DateInternal(val expr: Expression<*>) : Function(KotlinLocalDateColumnType.INSTANCE) {
    override fun toQueryBuilder(queryBuilder: QueryBuilder) = queryBuilder { append("DATE(", expr, ")") }
}

@JvmName("LocalDateDateFunction")
fun  Date(expr: Expression): Function = DateInternal(expr)
@JvmName("LocalDateTimeDateFunction")
fun  Date(expr: Expression): Function = DateInternal(expr)
@JvmName("InstantDateFunction")
fun  Date(expr: Expression): Function = DateInternal(expr)

internal class TimeFunction(val expr: Expression<*>) : Function(KotlinLocalTimeColumnType.INSTANCE) {
    override fun toQueryBuilder(queryBuilder: QueryBuilder) = queryBuilder { append("Time(", expr, ")") }
}

@JvmName("LocalDateTimeFunction")
fun  Time(expr: Expression): Function = TimeFunction(expr)
@JvmName("LocalDateTimeTimeFunction")
fun  Time(expr: Expression): Function = TimeFunction(expr)
@JvmName("InstantTimeFunction")
fun  Time(expr: Expression): Function = TimeFunction(expr)

object CurrentDateTime : Function(KotlinLocalDateTimeColumnType.INSTANCE) {
    override fun toQueryBuilder(queryBuilder: QueryBuilder) = queryBuilder {
        +when {
            (currentDialect as? MysqlDialect)?.isFractionDateTimeSupported() == true -> "CURRENT_TIMESTAMP(6)"
            else -> "CURRENT_TIMESTAMP"
        }
    }

    @Deprecated(
        message = "This class is now a singleton, no need for its constructor call",
        replaceWith = ReplaceWith("this"),
        level = DeprecationLevel.HIDDEN,
    )
    operator fun invoke() = this
}

object CurrentDate : Function(KotlinLocalDateColumnType.INSTANCE) {
    override fun toQueryBuilder(queryBuilder: QueryBuilder) = queryBuilder {
        +when (currentDialect) {
            is MysqlDialect -> "CURRENT_DATE()"
            is SQLServerDialect -> "GETDATE()"
            else -> "CURRENT_DATE"
        }
    }
}

class CurrentTimestamp : Expression() {
    override fun toQueryBuilder(queryBuilder: QueryBuilder) = queryBuilder {
        +when {
            (currentDialect as? MysqlDialect)?.isFractionDateTimeSupported() == true -> "CURRENT_TIMESTAMP(6)"
            else -> "CURRENT_TIMESTAMP"
        }
    }
}

class YearInternal(val expr: Expression<*>) : Function(IntegerColumnType()) {
    override fun toQueryBuilder(queryBuilder: QueryBuilder) = queryBuilder {
        val dialect = currentDialect
        val functionProvider = when (dialect.h2Mode) {
            H2Dialect.H2CompatibilityMode.SQLServer -> (dialect as H2Dialect).originalFunctionProvider
            else -> dialect.functionProvider
        }
        functionProvider.year(expr, queryBuilder)
    }
}

@JvmName("LocalDateYearFunction")
fun  Year(expr: Expression): Function = YearInternal(expr)
@JvmName("LocalDateTimeYearFunction")
fun  Year(expr: Expression): Function = YearInternal(expr)
@JvmName("InstantYearFunction")
fun  Year(expr: Expression): Function = YearInternal(expr)

internal class MonthInternal(val expr: Expression<*>) : Function(IntegerColumnType()) {
    override fun toQueryBuilder(queryBuilder: QueryBuilder) = queryBuilder {
        val dialect = currentDialect
        val functionProvider = when (dialect.h2Mode) {
            H2Dialect.H2CompatibilityMode.SQLServer -> (dialect as H2Dialect).originalFunctionProvider
            else -> dialect.functionProvider
        }
        functionProvider.month(expr, queryBuilder)
    }
}

@JvmName("LocalDateMonthFunction")
fun  Month(expr: Expression): Function = MonthInternal(expr)
@JvmName("LocalDateTimeMonthFunction")
fun  Month(expr: Expression): Function = MonthInternal(expr)
@JvmName("InstantMonthFunction")
fun  Month(expr: Expression): Function = MonthInternal(expr)

internal class DayInternal(val expr: Expression<*>) : Function(IntegerColumnType()) {
    override fun toQueryBuilder(queryBuilder: QueryBuilder) = queryBuilder {
        val dialect = currentDialect
        val functionProvider = when (dialect.h2Mode) {
            H2Dialect.H2CompatibilityMode.SQLServer -> (dialect as H2Dialect).originalFunctionProvider
            else -> dialect.functionProvider
        }
        functionProvider.day(expr, queryBuilder)
    }
}

@JvmName("LocalDateDayFunction")
fun  Day(expr: Expression): Function = DayInternal(expr)
@JvmName("LocalDateTimeDayFunction")
fun  Day(expr: Expression): Function = DayInternal(expr)
@JvmName("InstantDayFunction")
fun  Day(expr: Expression): Function = DayInternal(expr)

internal class HourInternal(val expr: Expression<*>) : Function(IntegerColumnType()) {
    override fun toQueryBuilder(queryBuilder: QueryBuilder) = queryBuilder {
        val dialect = currentDialect
        val functionProvider = when (dialect.h2Mode) {
            H2Dialect.H2CompatibilityMode.SQLServer -> (dialect as H2Dialect).originalFunctionProvider
            else -> dialect.functionProvider
        }
        functionProvider.hour(expr, queryBuilder)
    }
}

@JvmName("LocalDateHourFunction")
fun  Hour(expr: Expression): Function = HourInternal(expr)
@JvmName("LocalDateTimeHourFunction")
fun  Hour(expr: Expression): Function = HourInternal(expr)
@JvmName("InstantHourFunction")
fun  Hour(expr: Expression): Function = HourInternal(expr)

internal class MinuteInternal(val expr: Expression<*>) : Function(IntegerColumnType()) {
    override fun toQueryBuilder(queryBuilder: QueryBuilder) = queryBuilder {
        val dialect = currentDialect
        val functionProvider = when (dialect.h2Mode) {
            H2Dialect.H2CompatibilityMode.SQLServer -> (dialect as H2Dialect).originalFunctionProvider
            else -> dialect.functionProvider
        }
        functionProvider.minute(expr, queryBuilder)
    }
}

@JvmName("LocalDateMinuteFunction")
fun  Minute(expr: Expression): Function = MinuteInternal(expr)
@JvmName("LocalDateTimeMinuteFunction")
fun  Minute(expr: Expression): Function = MinuteInternal(expr)
@JvmName("InstantMinuteFunction")
fun  Minute(expr: Expression): Function = MinuteInternal(expr)

internal class SecondInternal(val expr: Expression<*>) : Function(IntegerColumnType()) {
    override fun toQueryBuilder(queryBuilder: QueryBuilder) = queryBuilder {
        val dialect = currentDialect
        val functionProvider = when (dialect.h2Mode) {
            H2Dialect.H2CompatibilityMode.SQLServer -> (dialect as H2Dialect).originalFunctionProvider
            else -> dialect.functionProvider
        }
        functionProvider.second(expr, queryBuilder)
    }
}

@JvmName("LocalDateSecondFunction")
fun  Second(expr: Expression): Function = SecondInternal(expr)
@JvmName("LocalDateTimeSecondFunction")
fun  Second(expr: Expression): Function = SecondInternal(expr)
@JvmName("InstantSecondFunction")
fun  Second(expr: Expression): Function = SecondInternal(expr)

// Extention

@JvmName("LocalDateDateExt")
fun  Expression.date() = Date(this)
@JvmName("LocalDateTimeDateExt")
fun  Expression.date() = Date(this)
@JvmName("InstantDateExt")
fun  Expression.date() = Date(this)

@JvmName("LocalDateYearExt")
fun  Expression.year() = Year(this)
@JvmName("LocalDateTimeYearExt")
fun  Expression.year() = Year(this)
@JvmName("InstantYearExt")
fun  Expression.year() = Year(this)

@JvmName("LocalDateMonthExt")
fun  Expression.month() = Month(this)
@JvmName("LocalDateTimeMonthExt")
fun  Expression.month() = Month(this)
@JvmName("InstantMonthExt")
fun  Expression.month() = Month(this)

@JvmName("LocalDateDayExt")
fun  Expression.day() = Day(this)
@JvmName("LocalDateTimeDayExt")
fun  Expression.day() = Day(this)
@JvmName("InstantDayExt")
fun  Expression.day() = Day(this)

@JvmName("LocalDateHourExt")
fun  Expression.hour() = Hour(this)
@JvmName("LocalDateTimeHourExt")
fun  Expression.hour() = Hour(this)
@JvmName("InstantHourExt")
fun  Expression.hour() = Hour(this)

@JvmName("LocalDateMinuteExt")
fun  Expression.minute() = Minute(this)
@JvmName("LocalDateTimeMinuteExt")
fun  Expression.minute() = Minute(this)
@JvmName("InstantMinuteExt")
fun  Expression.minute() = Minute(this)

@JvmName("LocalDateSecondExt")
fun  Expression.second() = Second(this)
@JvmName("LocalDateTimeSecondExt")
fun  Expression.second() = Second(this)
@JvmName("InstantSecondExt")
fun  Expression.second() = Second(this)

fun dateParam(value: LocalDate): Expression = QueryParameter(value, KotlinLocalDateColumnType.INSTANCE)
fun timeParam(value: LocalTime): Expression = QueryParameter(value, KotlinLocalTimeColumnType.INSTANCE)
fun dateTimeParam(value: LocalDateTime): Expression = QueryParameter(value, KotlinLocalDateTimeColumnType.INSTANCE)
fun timestampParam(value: Instant): Expression = QueryParameter(value, KotlinInstantColumnType.INSTANCE)

fun timestampWithTimeZoneParam(value: OffsetDateTime): Expression =
    QueryParameter(value, KotlinOffsetDateTimeColumnType.INSTANCE)

fun durationParam(value: Duration): Expression = QueryParameter(value, KotlinDurationColumnType.INSTANCE)

fun dateLiteral(value: LocalDate): LiteralOp = LiteralOp(KotlinLocalDateColumnType.INSTANCE, value)
fun timeLiteral(value: LocalTime): LiteralOp = LiteralOp(KotlinLocalTimeColumnType.INSTANCE, value)
fun dateTimeLiteral(value: LocalDateTime): LiteralOp = LiteralOp(KotlinLocalDateTimeColumnType.INSTANCE, value)

fun timestampLiteral(value: Instant): LiteralOp = LiteralOp(KotlinInstantColumnType.INSTANCE, value)

fun timestampWithTimeZoneLiteral(value: OffsetDateTime): LiteralOp =
    LiteralOp(KotlinOffsetDateTimeColumnType.INSTANCE, value)

fun durationLiteral(value: Duration): LiteralOp = LiteralOp(KotlinDurationColumnType.INSTANCE, value)

fun CustomDateFunction(functionName: String, vararg params: Expression<*>): CustomFunction =
    CustomFunction(functionName, KotlinLocalDateColumnType.INSTANCE, *params)

fun CustomTimeFunction(functionName: String, vararg params: Expression<*>): CustomFunction =
    CustomFunction(functionName, KotlinLocalTimeColumnType.INSTANCE, *params)

fun CustomDateTimeFunction(functionName: String, vararg params: Expression<*>): CustomFunction =
    CustomFunction(functionName, KotlinLocalDateTimeColumnType.INSTANCE, *params)

fun CustomTimeStampFunction(functionName: String, vararg params: Expression<*>): CustomFunction =
    CustomFunction(functionName, KotlinInstantColumnType.INSTANCE, *params)

@Suppress("FunctionName")
fun CustomTimestampWithTimeZoneFunction(
    functionName: String,
    vararg params: Expression<*>
): CustomFunction = CustomFunction(functionName, KotlinOffsetDateTimeColumnType.INSTANCE, *params)

fun CustomDurationFunction(functionName: String, vararg params: Expression<*>): CustomFunction =
    CustomFunction(functionName, KotlinDurationColumnType.INSTANCE, *params)