KQLite/com.kqlite.functions

Package-level declarations

Functions

ABS

fun <T : Number?> ABS(x: KQLiteColumn<T>): KQLiteColumn<T>

Represents the SQLite ABS() function, which computes the absolute value of a numeric expression.

ACOS

fun ACOS(x: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents SQLite ACOS() function. The input must be between -1.0 and 1.0.

ACOSH

fun ACOSH(x: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents the SQLite ACOSH() function, which computes the inverse hyperbolic cosine. The input value must be greater than or equal to 1.0.

ASIN

fun ASIN(x: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents the SQLite ASIN() function, which computes the arc sine. The input value must be between -1.0 and 1.0.

ASINH

fun ASINH(x: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents the SQLite ASINH() function, which computes the inverse hyperbolic sine.

ATAN

fun ATAN(x: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents the SQLite ATAN() function, which computes the arc tangent.

ATAN2

fun ATAN2(y: KQLiteColumn<out Number?>, x: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents the SQLite ATAN2(Y, X) function. It computes the arc tangent of Y/X but uses the signs of both Y and X to determine the quadrant of the result.

ATANH

fun ATANH(x: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents the SQLite ATANH() function, which computes the inverse hyperbolic tangent. The input value must be between -1.0 and 1.0, exclusive.

AVG

@JvmOverloads

fun <T> AVG(column: KQLiteColumn<T>, distinct: Boolean = false): KQLiteColumn<Double>

Represents the SQL AVG() aggregate function.

CAST

fun CAST(column: KQLiteColumn<*>, type: Int): KQLiteColumn<Any?>

Explicitly converts the data type of value from one type to another.

CEIL

fun CEIL(x: KQLiteColumn<out Number?>): KQLiteColumn<Long?>

Represents the SQLite CEIL() or CEILING() function, which rounds a number up to the next highest integer.

CEILING

fun CEILING(x: KQLiteColumn<out Number?>): KQLiteColumn<Long?>

An alias for the CEIL function. Represents the SQLite CEILING() function, which rounds a number up to the next highest integer.

CHAR

fun CHAR(vararg chars: KQLiteColumn<in Int>): KQLiteColumn<String>

Constructs a string by interpreting the integer arguments as Unicode code points.

COALESCE

fun COALESCE(vararg columns: KQLiteColumn<*>): KQLiteColumn<String?>

Returns a copy of its first non-NULL argument, or NULL if all arguments are NULL.

CONCAT

fun CONCAT(vararg columns: KQLiteColumn<*>): KQLiteColumn<String>

Concatenates two or more strings or columns together.

CONCAT

infix fun KQLiteColumn<*>.CONCAT(column: KQLiteColumn<*>): KQLiteColumn<String>

Concatenates this column with another column. This is an infix version of the CONCAT function, corresponding to the SQLite || operator.

infix fun KQLiteColumn<*>.CONCAT(literal: String): KQLiteColumn<String>

Concatenates two or more strings or columns together. This function corresponds to the SQLite CONCAT or || operator.

CONCAT_WS

fun CONCAT_WS(separator: String, vararg columns: KQLiteColumn<*>): KQLiteColumn<String?>

Concatenates two or more strings or columns with a specified separator.

COS

fun COS(x: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents the SQLite COS() function, which computes the cosine of a value.

COSH

fun COSH(x: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents the SQLite COSH() function, which computes the hyperbolic cosine.

COUNT

@JvmOverloads

fun COUNT(column: KQLiteColumn<*>? = null, distinct: Boolean = false): KQLiteColumn<Long>

Represents the SQL COUNT() aggregate function.

DATE

fun DATE(column: KQLiteColumn<out DateTimeModifier?>): KQLiteColumn<KQLiteDate>

fun DATE(julianday: Double): KQLiteColumn<KQLiteDate>

fun DATE(unixepoch: Long): KQLiteColumn<KQLiteDate>

@JvmOverloads

fun DATE(date: String? = null): KQLiteColumn<KQLiteDate>

fun DATE(year: Int, month: Int, day: Int): KQLiteColumn<KQLiteDate>

The DATE() function returns the date as text in this format: YYYY-MM-DD.

DATETIME

fun DATETIME(column: KQLiteColumn<out DateTimeModifier?>): KQLiteColumn<KQLiteDateTime>

fun DATETIME(julianday: Double): KQLiteColumn<KQLiteDateTime>

fun DATETIME(unixepoch: Long): KQLiteColumn<KQLiteDateTime>

@JvmOverloads

fun DATETIME(dateTime: String? = null): KQLiteColumn<KQLiteDateTime>

fun DATETIME(date: KQLiteColumn<out KQLiteDate?>, time: KQLiteColumn<out KQLiteTime?>? = null): KQLiteColumn<KQLiteDateTime>

The DATETIME() function returns the date and time as text in this format: YYYY-MM-DD HH:MM:SS.

DEGREES

fun DEGREES(x: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents the SQLite DEGREES() function, which converts a value from radians to degrees.

DISTINCT

fun <T> DISTINCT(column: KQLiteColumn<T>): KQLiteColumn<T>

Represents the SQL DISTINCT keyword used as a function-like wrapper.

EXP

fun EXP(x: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents the SQLite EXP() function, which computes e (Euler's number, approximately 2.71828) raised to the power of the input value.

FLOOR

fun FLOOR(x: KQLiteColumn<out Number?>): KQLiteColumn<Long?>

Represents the SQLite FLOOR() function, which rounds a number down to the next lowest integer.

FORMAT

fun FORMAT(format: String, vararg columns: KQLiteColumn<*>): KQLiteColumn<String>

Formats a string using a format template and a variable number of arguments.

GROUP_CONCAT

@JvmOverloads

fun GROUP_CONCAT(column: KQLiteColumn<*>, separator: String? = null, distinct: Boolean = false): KQLiteColumn<String>

Represents the SQL GROUP_CONCAT() aggregate function.

HEX

fun HEX(x: KQLiteColumn<*>): KQLiteColumn<String>

Converts a value into a hexadecimal string representation.

IFNULL

fun <T> IFNULL(x: KQLiteColumn<T>, y: KQLiteColumn<out T>): KQLiteColumn<T>

Returns the value of its first argument if it is not NULL, otherwise returns the value of its second argument.

IIF

fun IIF(expression: KQLiteColumn<out Boolean?>, trueValue: KQLiteColumn<*>, falseValue: KQLiteColumn<*>): KQLiteColumn<String>

Evaluates a boolean expression and returns one of two values accordingly.

INSTR

fun INSTR(x: KQLiteColumn<*>, y: KQLiteColumn<*>): KQLiteColumn<Long>

Finds the first occurrence of a substring within a string.

JSON

fun JSON(json: KQLiteColumn<*>): KQLiteColumn<KQLiteJson>

Interprets the value from the given column as JSON.

fun JSON(json: String): KQLiteColumn<KQLiteJson>

Interprets the given string as JSON.

JSON_ARRAY

fun JSON_ARRAY(vararg values: Any?): KQLiteColumn<KQLiteJsonArray>

Creates a new JSON array from a variable number of arguments.

JSON_ARRAY_LENGTH

@JvmOverloads

fun JSON_ARRAY_LENGTH(json: KQLiteColumn<out KQLiteJson?>, path: String? = null): KQLiteColumn<Int?>

Returns the number of elements in a JSON array.

JSON_ERROR_POSITION

fun JSON_ERROR_POSITION(json: KQLiteColumn<out KQLiteJson?>): KQLiteColumn<Int>

Returns the 1-based index of the character where a syntax error occurred in malformed JSON.

JSON_EXTRACT

fun JSON_EXTRACT(json: KQLiteColumn<out KQLiteJson?>, vararg path: String): KQLiteColumn<String?>

Extracts one or more values from a JSON string.

JSON_GROUP_ARRAY

fun JSON_GROUP_ARRAY(column: KQLiteColumn<*>): KQLiteColumn<KQLiteJsonArray>

An aggregate function that returns a JSON array containing all values from the specified column within a group.

JSON_GROUP_OBJECT

fun JSON_GROUP_OBJECT(key: KQLiteColumn<*>, value: KQLiteColumn<*>): KQLiteColumn<KQLiteJsonObject>

An aggregate function that returns a JSON object composed of key-value pairs from two specified columns within a group.

JSON_INSERT

fun <T : KQLiteJson> JSON_INSERT(json: KQLiteColumn<T>, vararg pathValue: Pair<String, Any?>): KQLiteColumn<T>

Inserts one or more values into a JSON document at specified paths.

JSON_OBJECT

fun JSON_OBJECT(vararg nameValue: Pair<String, Any?>): KQLiteColumn<KQLiteJsonObject>

Creates a new JSON object from a variable number of name-value pairs.

JSON_PATCH

fun <T : KQLiteJson> JSON_PATCH(json: KQLiteColumn<T>, patch: KQLiteColumn<out KQLiteJson?>): KQLiteColumn<T>

Applies a JSON patch to a JSON document.

JSON_PRETTY

@JvmOverloads

fun <T : KQLiteJson> JSON_PRETTY(json: KQLiteColumn<T>, format: String? = null): KQLiteColumn<T>

Formats a JSON string into a more human-readable, "pretty-printed" format.

JSON_QUOTE

fun JSON_QUOTE(value: Any?): KQLiteColumn<String>

Converts a SQL value into a JSON value.

JSON_REMOVE

fun <T : KQLiteJson> JSON_REMOVE(json: KQLiteColumn<T>, vararg path: String): KQLiteColumn<T>

Removes one or more elements from a JSON document at specified paths.

JSON_REPLACE

fun <T : KQLiteJson> JSON_REPLACE(json: KQLiteColumn<T>, vararg pathValue: Pair<String, Any?>): KQLiteColumn<T>

Replaces existing values in a JSON document at specified paths.

JSON_SET

fun <T : KQLiteJson> JSON_SET(json: KQLiteColumn<T>, vararg pathValue: Pair<String, Any?>): KQLiteColumn<T>

Inserts or replaces values in a JSON document at specified paths.

JSON_TYPE

@JvmOverloads

fun JSON_TYPE(json: KQLiteColumn<out KQLiteJson?>, path: String? = null): KQLiteColumn<String?>

Returns the "type" of a JSON value as a string.

JSON_VALID

@JvmOverloads

fun JSON_VALID(json: KQLiteColumn<*>, flag: Int? = null): KQLiteColumn<Boolean>

Checks if a string is a well-formed JSON document.

JSONB

fun JSONB(json: KQLiteColumn<*>): KQLiteColumn<KQLiteJson>

Interprets the value from the given column as JSON and returns its binary representation (BLOB).

fun JSONB(json: String): KQLiteColumn<KQLiteJson>

Interprets the given string as JSON and returns its binary representation (BLOB).

JSONB_ARRAY

fun JSONB_ARRAY(vararg values: Any?): KQLiteColumn<KQLiteJsonArray>

Similar to JSON_ARRAY but binary representation (BLOB).

JSONB_EXTRACT

fun JSONB_EXTRACT(json: KQLiteColumn<out KQLiteJson?>, vararg path: String): KQLiteColumn<String?>

Similar to JSON_EXTRACT but binary representation (BLOB).

JSONB_GROUP_ARRAY

fun JSONB_GROUP_ARRAY(column: KQLiteColumn<*>): KQLiteColumn<KQLiteJsonArray>

Similar to JSON_GROUP_ARRAY but binary representation (BLOB).

JSONB_GROUP_OBJECT

fun JSONB_GROUP_OBJECT(key: KQLiteColumn<*>, value: KQLiteColumn<*>): KQLiteColumn<KQLiteJsonObject>

Similar to JSON_GROUP_OBJECT but binary representation (BLOB).

JSONB_INSERT

fun <T : KQLiteJson> JSONB_INSERT(json: KQLiteColumn<T>, vararg pathValue: Pair<String, Any?>): KQLiteColumn<T>

Similar to JSON_INSERT but binary representation (BLOB).

JSONB_OBJECT

fun JSONB_OBJECT(vararg nameValue: Pair<String, Any?>): KQLiteColumn<KQLiteJsonObject>

Similar to JSON_OBJECT but binary representation (BLOB).

JSONB_PATCH

fun <T : KQLiteJson> JSONB_PATCH(json: KQLiteColumn<T>, patch: KQLiteColumn<out KQLiteJson?>): KQLiteColumn<T>

Similar to JSON_PATCH but binary representation (BLOB).

JSONB_REMOVE

fun <T : KQLiteJson> JSONB_REMOVE(json: KQLiteColumn<T>, vararg path: String): KQLiteColumn<T>

Similar to JSON_REMOVE but binary representation (BLOB).

JSONB_REPLACE

fun <T : KQLiteJson> JSONB_REPLACE(json: KQLiteColumn<T>, vararg pathValue: Pair<String, Any?>): KQLiteColumn<T>

Similar to JSON_REPLACE but binary representation (BLOB).

JSONB_SET

fun <T : KQLiteJson> JSONB_SET(json: KQLiteColumn<T>, vararg pathValue: Pair<String, Any?>): KQLiteColumn<T>

Similar to JSON_SET but binary representation (BLOB).

JULIANDAY

fun JULIANDAY(column: KQLiteColumn<out DateTimeModifier?>): KQLiteColumn<KQLiteJulianDay>

fun JULIANDAY(julianday: Double): KQLiteColumn<KQLiteJulianDay>

fun JULIANDAY(unixepoch: Long): KQLiteColumn<KQLiteJulianDay>

@JvmOverloads

fun JULIANDAY(date: String? = null): KQLiteColumn<KQLiteJulianDay>

The JULIANDAY() function returns the Julian day number - the number of days since noon in Greenwich on November 24, 4714BC.

LENGTH

fun LENGTH(column: KQLiteColumn<*>): KQLiteColumn<Long>

Returns the length of a value.

fun LN(x: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents the SQLite LN() function, which computes the natural logarithm (base-e) of a value.

LOG

@JvmOverloads

fun LOG(x: KQLiteColumn<out Number?>, base: KQLiteColumn<*>? = null): KQLiteColumn<Double?>

Represents the SQLite LOG() function, which computes the logarithm of a number.

LOG10

fun LOG10(x: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents the SQLite LOG10() function, which computes the base-10 logarithm of a number.

LOG2

fun LOG2(x: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents the SQLite LOG2() function, which computes the base-2 logarithm of a number.

LOWER

fun LOWER(column: KQLiteColumn<*>): KQLiteColumn<String>

Converts a string to all lowercase letters.

LTRIM

@JvmOverloads

fun LTRIM(column: KQLiteColumn<*>, trimChars: String? = null): KQLiteColumn<String>

Removes characters from the beginning (left side) of a string.

MAX

@JvmOverloads

fun <T> MAX(vararg columns: KQLiteColumn<T>, distinct: Boolean = false): KQLiteColumn<T>

Represents the SQL MAX() aggregate or scalar function.

MIN

@JvmOverloads

fun <T> MIN(vararg columns: KQLiteColumn<T>, distinct: Boolean = false): KQLiteColumn<T>

Represents the SQL MIN() aggregate or scalar function.

MOD

fun MOD(x: KQLiteColumn<out Number?>, y: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents the SQLite MOD(X, Y) function, which computes the floating-point remainder of the division of X by Y.

NULLIF

fun <T> NULLIF(x: KQLiteColumn<T>, y: KQLiteColumn<*>): KQLiteColumn<T?>

Returns NULL if the first argument is equal to the second argument, otherwise returns the first argument.

OCTET_LENGTH

fun OCTET_LENGTH(column: KQLiteColumn<*>): KQLiteColumn<Long>

Returns the length of a value in bytes (octets).

POW

fun POW(x: KQLiteColumn<out Number?>, y: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents the SQLite POW(X, Y) function, which computes X raised to the power of Y.

POWER

fun POWER(x: KQLiteColumn<out Number?>, y: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents the SQLite POWER(X, Y) function, which computes X raised to the power of Y.

PRINTF

fun PRINTF(format: String, vararg columns: KQLiteColumn<*>): KQLiteColumn<String>

Formats a string using a C-style printf() format string.

QUOTE

fun QUOTE(column: KQLiteColumn<*>): KQLiteColumn<String>

Wraps a value in a format suitable for inclusion in an SQL statement.

RADIANS

fun RADIANS(x: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents the SQLite RADIANS() function, which converts a value from degrees to radians.

RANDOM

fun RANDOM(): KQLiteColumn<Long>

Represents the SQLite RANDOM() function.

RANDOM_BLOB

fun RANDOM_BLOB(bytes: KQLiteColumn<Int>): KQLiteColumn<ByteArray>

Represents the SQLite randomblob(N) function.

REPLACE

fun REPLACE(column: KQLiteColumn<*>, oldValue: String, newValue: String): KQLiteColumn<String>

Replaces all occurrences of a specified substring with another substring.

ROUND

@JvmOverloads

fun <T : Number?> ROUND(column: KQLiteColumn<T>, digits: Int? = null): KQLiteColumn<T>

Represents the SQLite ROUND() function, which rounds a numeric value.

RTRIM

@JvmOverloads

fun RTRIM(column: KQLiteColumn<*>, trimChars: String? = null): KQLiteColumn<String>

Removes characters from the end (right side) of a string.

SIGN

fun SIGN(x: KQLiteColumn<out Number?>): KQLiteColumn<Int?>

Represents the SQLite SIGN() function, which returns the sign of a numeric value.

SIN

fun SIN(x: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents the SQLite SIN() function, which computes the sine of a value.

SINH

fun SINH(x: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents the SQLite SINH() function, which computes the hyperbolic sine.

SOUNDEX

fun SOUNDEX(column: KQLiteColumn<*>): KQLiteColumn<String?>

Computes the Soundex code of a string.

SQRT

fun SQRT(x: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents the SQLite SQRT() function, which computes the square root of a number.

STRFTIME

@JvmOverloads

fun STRFTIME(format: String, column: KQLiteColumn<out DateTimeModifier?>? = null): KQLiteColumn<KQLiteDateTime>

The STRFTIME() function returns a string representing the date and time, formatted according to the format string. The optional second argument is a time string, which defaults to 'now' if omitted.

STRING_AGG

@JvmOverloads

fun STRING_AGG(column: KQLiteColumn<*>, separator: String, distinct: Boolean = false): KQLiteColumn<String>

Represents the SQL STRING_AGG() aggregate function.

SUBSTR

@JvmOverloads

fun SUBSTR(column: KQLiteColumn<*>, start: Int, length: Int? = null): KQLiteColumn<String?>

Extracts a substring from a string.

SUBSTRING

@JvmOverloads

fun SUBSTRING(column: KQLiteColumn<*>, start: Int, length: Int? = null): KQLiteColumn<String>

Extracts a substring from a string. This is an alias for the SUBSTR function.

SUM

@JvmOverloads

fun <T : Number?> SUM(column: KQLiteColumn<T>, distinct: Boolean = false): KQLiteColumn<T>

Represents the SQL SUM() aggregate function.

TAN

fun TAN(x: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents the SQLite TAN() function, which computes the tangent of a value.

TANH

fun TANH(x: KQLiteColumn<out Number?>): KQLiteColumn<Double?>

Represents the SQLite TANH() function, which computes the hyperbolic tangent.

TIME

fun TIME(column: KQLiteColumn<out DateTimeModifier?>): KQLiteColumn<KQLiteTime>

fun TIME(julianday: Double): KQLiteColumn<KQLiteTime>

fun TIME(unixepoch: Long): KQLiteColumn<KQLiteTime>

@JvmOverloads

fun TIME(time: String? = null): KQLiteColumn<KQLiteTime>

@JvmOverloads

fun TIME(hour: Int, minute: Int, second: Int? = null, subsecond: Int? = null): KQLiteColumn<KQLiteTime>

The TIME() function returns the time as text in this format: HH:MM:SS.

TIMEDIFF

fun TIMEDIFF(columnA: KQLiteColumn<out DateTimeModifier?>, columnB: KQLiteColumn<out DateTimeModifier?>): KQLiteColumn<KQLiteDateTime>

The TIMEDIFF() function computes the time difference between two date/time values. It returns the result as a time string in the format (+|-)YYYY-MM-DD HH:MM:SS.SSS.

TOTAL

@JvmOverloads