ConditionalValueOperators¶

interface ConditionalValueOperators : ValueOperators

Operators to conditionally create a value.

To learn more about aggregation operators, view AggregationOperators.

Inheritors¶

AggregationOperators

Types¶

`Case`¶

data class Case<Root : Any, T>(val condition: Value<Root, Boolean>, val value: Value<Root, T>)

A single case in a switch operator.

Properties¶

context¶

@LowLevelApi
abstract override val context: BsonContext

The strategy used when converting from KProperty1 to Field.

`field`¶

open val <Root, Type> KProperty1<Root, Type>.field: Field<Root, Type>

Converts a Kotlin property into a Field.

Functions¶

cond¶

open fun <R : Any, T> cond(
    condition: Value<R, Boolean>, 
    ifTrue: Value<R, T>, 
    ifFalse: Value<R, T>
): Value<R, T>

@JvmName(name = "condByValueByValueByField")
open fun <R : Any, T> cond(
    condition: Value<R, Boolean>, 
    ifTrue: Value<R, T>, 
    ifFalse: Field<R, T>
): Value<R, T>

@JvmName(name = "condByValueByValueByProperty")
open fun <R : Any, T> cond(
    condition: Value<R, Boolean>, 
    ifTrue: Value<R, T>, 
    ifFalse: KProperty1<R, T>
): Value<R, T>

inline fun <R : Any, T> cond(
    condition: Value<R, Boolean>, 
    ifTrue: Value<R, T>, 
    ifFalse: T
): Value<R, T>

@JvmName(name = "condByValueByFieldByValue")
open fun <R : Any, T> cond(
    condition: Value<R, Boolean>, 
    ifTrue: Field<R, T>, 
    ifFalse: Value<R, T>
): Value<R, T>

@JvmName(name = "condByValueByFieldByField")
open fun <R : Any, T> cond(
    condition: Value<R, Boolean>, 
    ifTrue: Field<R, T>, 
    ifFalse: Field<R, T>
): Value<R, T>

@JvmName(name = "condByValueByFieldByProperty")
open fun <R : Any, T> cond(
    condition: Value<R, Boolean>, 
    ifTrue: Field<R, T>, 
    ifFalse: KProperty1<R, T>
): Value<R, T>

@JvmName(name = "condByValueByFieldByResult")
inline fun <R : Any, T> cond(
    condition: Value<R, Boolean>, 
    ifTrue: Field<R, T>, 
    ifFalse: T
): Value<R, T>

@JvmName(name = "condByValueByPropertyByValue")
open fun <R : Any, T> cond(
    condition: Value<R, Boolean>, 
    ifTrue: KProperty1<R, T>, 
    ifFalse: Value<R, T>
): Value<R, T>

@JvmName(name = "condByValueByPropertyByField")
open fun <R : Any, T> cond(
    condition: Value<R, Boolean>, 
    ifTrue: KProperty1<R, T>, 
    ifFalse: Field<R, T>
): Value<R, T>

@JvmName(name = "condByValueByPropertyByProperty")
open fun <R : Any, T> cond(
    condition: Value<R, Boolean>, 
    ifTrue: KProperty1<R, T>, 
    ifFalse: KProperty1<R, T>
): Value<R, T>

@JvmName(name = "condByValueByPropertyByResult")
inline fun <R : Any, T> cond(
    condition: Value<R, Boolean>, 
    ifTrue: KProperty1<R, T>, 
    ifFalse: T
): Value<R, T>

inline fun <R : Any, T> cond(
    condition: Value<R, Boolean>, 
    ifTrue: T, 
    ifFalse: Value<R, T>
): Value<R, T>

@JvmName(name = "condByValueByResultByField")
inline fun <R : Any, T> cond(
    condition: Value<R, Boolean>, 
    ifTrue: T, 
    ifFalse: Field<R, T>
): Value<R, T>

@JvmName(name = "condByValueByResultByProperty")
inline fun <R : Any, T> cond(
    condition: Value<R, Boolean>, 
    ifTrue: T, 
    ifFalse: KProperty1<R, T>
): Value<R, T>

inline fun <R : Any, T> cond(
    condition: Value<R, Boolean>, 
    ifTrue: T, 
    ifFalse: T
): Value<R, T>

@JvmName(name = "condByFieldByValueByValue")
open fun <R : Any, T> cond(
    condition: Field<R, Boolean>, 
    ifTrue: Value<R, T>, 
    ifFalse: Value<R, T>
): Value<R, T>

@JvmName(name = "condByFieldByValueByField")
open fun <R : Any, T> cond(
    condition: Field<R, Boolean>, 
    ifTrue: Value<R, T>, 
    ifFalse: Field<R, T>
): Value<R, T>

@JvmName(name = "condByFieldByValueByProperty")
open fun <R : Any, T> cond(
    condition: Field<R, Boolean>, 
    ifTrue: Value<R, T>, 
    ifFalse: KProperty1<R, T>
): Value<R, T>

@JvmName(name = "condByFieldByValueByResult")
inline fun <R : Any, T> cond(
    condition: Field<R, Boolean>, 
    ifTrue: Value<R, T>, 
    ifFalse: T
): Value<R, T>

@JvmName(name = "condByFieldByFieldByValue")
open fun <R : Any, T> cond(
    condition: Field<R, Boolean>, 
    ifTrue: Field<R, T>, 
    ifFalse: Value<R, T>
): Value<R, T>

@JvmName(name = "condByFieldByFieldByField")
open fun <R : Any, T> cond(
    condition: Field<R, Boolean>, 
    ifTrue: Field<R, T>, 
    ifFalse: Field<R, T>
): Value<R, T>

@JvmName(name = "condByFieldByFieldByProperty")
open fun <R : Any, T> cond(
    condition: Field<R, Boolean>, 
    ifTrue: Field<R, T>, 
    ifFalse: KProperty1<R, T>
): Value<R, T>

@JvmName(name = "condByFieldByFieldByResult")
inline fun <R : Any, T> cond(
    condition: Field<R, Boolean>, 
    ifTrue: Field<R, T>, 
    ifFalse: T
): Value<R, T>

@JvmName(name = "condByFieldByPropertyByValue")
open fun <R : Any, T> cond(
    condition: Field<R, Boolean>, 
    ifTrue: KProperty1<R, T>, 
    ifFalse: Value<R, T>
): Value<R, T>

@JvmName(name = "condByFieldByPropertyByField")
open fun <R : Any, T> cond(
    condition: Field<R, Boolean>, 
    ifTrue: KProperty1<R, T>, 
    ifFalse: Field<R, T>
): Value<R, T>

@JvmName(name = "condByFieldByPropertyByProperty")
open fun <R : Any, T> cond(
    condition: Field<R, Boolean>, 
    ifTrue: KProperty1<R, T>, 
    ifFalse: KProperty1<R, T>
): Value<R, T>

@JvmName(name = "condByFieldByPropertyByResult")
inline fun <R : Any, T> cond(
    condition: Field<R, Boolean>, 
    ifTrue: KProperty1<R, T>, 
    ifFalse: T
): Value<R, T>

@JvmName(name = "condByFieldByResultByValue")
inline fun <R : Any, T> cond(
    condition: Field<R, Boolean>, 
    ifTrue: T, 
    ifFalse: Value<R, T>
): Value<R, T>

@JvmName(name = "condByFieldByResultByField")
inline fun <R : Any, T> cond(
    condition: Field<R, Boolean>, 
    ifTrue: T, 
    ifFalse: Field<R, T>
): Value<R, T>

@JvmName(name = "condByFieldByResultByProperty")
inline fun <R : Any, T> cond(
    condition: Field<R, Boolean>, 
    ifTrue: T, 
    ifFalse: KProperty1<R, T>
): Value<R, T>

@JvmName(name = "condByFieldByResultByResult")
inline fun <R : Any, T> cond(
    condition: Field<R, Boolean>, 
    ifTrue: T, 
    ifFalse: T
): Value<R, T>

@JvmName(name = "condByPropertyByValueByValue")
open fun <R : Any, T> cond(
    condition: KProperty1<R, Boolean>, 
    ifTrue: Value<R, T>, 
    ifFalse: Value<R, T>
): Value<R, T>

@JvmName(name = "condByPropertyByValueByField")
open fun <R : Any, T> cond(
    condition: KProperty1<R, Boolean>, 
    ifTrue: Value<R, T>, 
    ifFalse: Field<R, T>
): Value<R, T>

@JvmName(name = "condByPropertyByValueByProperty")
open fun <R : Any, T> cond(
    condition: KProperty1<R, Boolean>, 
    ifTrue: Value<R, T>, 
    ifFalse: KProperty1<R, T>
): Value<R, T>

@JvmName(name = "condByPropertyByValueByResult")
inline fun <R : Any, T> cond(
    condition: KProperty1<R, Boolean>, 
    ifTrue: Value<R, T>, 
    ifFalse: T
): Value<R, T>

@JvmName(name = "condByPropertyByFieldByValue")
open fun <R : Any, T> cond(
    condition: KProperty1<R, Boolean>, 
    ifTrue: Field<R, T>, 
    ifFalse: Value<R, T>
): Value<R, T>

@JvmName(name = "condByPropertyByFieldByField")
open fun <R : Any, T> cond(
    condition: KProperty1<R, Boolean>, 
    ifTrue: Field<R, T>, 
    ifFalse: Field<R, T>
): Value<R, T>

@JvmName(name = "condByPropertyByFieldByProperty")
open fun <R : Any, T> cond(
    condition: KProperty1<R, Boolean>, 
    ifTrue: Field<R, T>, 
    ifFalse: KProperty1<R, T>
): Value<R, T>

@JvmName(name = "condByPropertyByFieldByResult")
inline fun <R : Any, T> cond(
    condition: KProperty1<R, Boolean>, 
    ifTrue: Field<R, T>, 
    ifFalse: T
): Value<R, T>

@JvmName(name = "condByPropertyByPropertyByValue")
open fun <R : Any, T> cond(
    condition: KProperty1<R, Boolean>, 
    ifTrue: KProperty1<R, T>, 
    ifFalse: Value<R, T>
): Value<R, T>

@JvmName(name = "condByPropertyByPropertyByField")
open fun <R : Any, T> cond(
    condition: KProperty1<R, Boolean>, 
    ifTrue: KProperty1<R, T>, 
    ifFalse: Field<R, T>
): Value<R, T>

@JvmName(name = "condByPropertyByPropertyByProperty")
open fun <R : Any, T> cond(
    condition: KProperty1<R, Boolean>, 
    ifTrue: KProperty1<R, T>, 
    ifFalse: KProperty1<R, T>
): Value<R, T>

@JvmName(name = "condByPropertyByPropertyByResult")
inline fun <R : Any, T> cond(
    condition: KProperty1<R, Boolean>, 
    ifTrue: KProperty1<R, T>, 
    ifFalse: T
): Value<R, T>

@JvmName(name = "condByPropertyByResultByValue")
inline fun <R : Any, T> cond(
    condition: KProperty1<R, Boolean>, 
    ifTrue: T, 
    ifFalse: Value<R, T>
): Value<R, T>

@JvmName(name = "condByPropertyByResultByField")
inline fun <R : Any, T> cond(
    condition: KProperty1<R, Boolean>, 
    ifTrue: T, 
    ifFalse: Field<R, T>
): Value<R, T>

@JvmName(name = "condByPropertyByResultByProperty")
inline fun <R : Any, T> cond(
    condition: KProperty1<R, Boolean>, 
    ifTrue: T, 
    ifFalse: KProperty1<R, T>
): Value<R, T>

@JvmName(name = "condByPropertyByResultByResult")
inline fun <R : Any, T> cond(
    condition: KProperty1<R, Boolean>, 
    ifTrue: T, 
    ifFalse: T
): Value<R, T>

inline fun <R : Any, T> cond(
    condition: Boolean, 
    ifTrue: Value<R, T>, 
    ifFalse: Value<R, T>
): Value<R, T>

@JvmName(name = "condByResultByValueByField")
inline fun <R : Any, T> cond(
    condition: Boolean, 
    ifTrue: Value<R, T>, 
    ifFalse: Field<R, T>
): Value<R, T>

@JvmName(name = "condByResultByValueByProperty")
inline fun <R : Any, T> cond(
    condition: Boolean, 
    ifTrue: Value<R, T>, 
    ifFalse: KProperty1<R, T>
): Value<R, T>

inline fun <R : Any, T> cond(
    condition: Boolean, 
    ifTrue: Value<R, T>, 
    ifFalse: T
): Value<R, T>

@JvmName(name = "condByResultByFieldByValue")
inline fun <R : Any, T> cond(
    condition: Boolean, 
    ifTrue: Field<R, T>, 
    ifFalse: Value<R, T>
): Value<R, T>

@JvmName(name = "condByResultByFieldByField")
inline fun <R : Any, T> cond(
    condition: Boolean, 
    ifTrue: Field<R, T>, 
    ifFalse: Field<R, T>
): Value<R, T>

@JvmName(name = "condByResultByFieldByProperty")
inline fun <R : Any, T> cond(
    condition: Boolean, 
    ifTrue: Field<R, T>, 
    ifFalse: KProperty1<R, T>
): Value<R, T>

@JvmName(name = "condByResultByFieldByResult")
inline fun <R : Any, T> cond(
    condition: Boolean, 
    ifTrue: Field<R, T>, 
    ifFalse: T
): Value<R, T>

@JvmName(name = "condByResultByPropertyByValue")
inline fun <R : Any, T> cond(
    condition: Boolean, 
    ifTrue: KProperty1<R, T>, 
    ifFalse: Value<R, T>
): Value<R, T>

@JvmName(name = "condByResultByPropertyByField")
inline fun <R : Any, T> cond(
    condition: Boolean, 
    ifTrue: KProperty1<R, T>, 
    ifFalse: Field<R, T>
): Value<R, T>

@JvmName(name = "condByResultByPropertyByProperty")
inline fun <R : Any, T> cond(
    condition: Boolean, 
    ifTrue: KProperty1<R, T>, 
    ifFalse: KProperty1<R, T>
): Value<R, T>

@JvmName(name = "condByResultByPropertyByResult")
inline fun <R : Any, T> cond(
    condition: Boolean, 
    ifTrue: KProperty1<R, T>, 
    ifFalse: T
): Value<R, T>

inline fun <R : Any, T> cond(
    condition: Boolean, 
    ifTrue: T, 
    ifFalse: Value<R, T>
): Value<R, T>

@JvmName(name = "condByResultByResultByField")
inline fun <R : Any, T> cond(
    condition: Boolean, 
    ifTrue: T, 
    ifFalse: Field<R, T>
): Value<R, T>

@JvmName(name = "condByResultByResultByProperty")
inline fun <R : Any, T> cond(
    condition: Boolean, 
    ifTrue: T, 
    ifFalse: KProperty1<R, T>
): Value<R, T>

inline fun <R : Any, T> cond(
    condition: Boolean, 
    ifTrue: T, 
    ifFalse: T
): Value<R, T>

Decides between two values depending on the evaluation of a boolean value.

Example

class User(
    val name: String,
    val score: Int,
    val multiplier: Int,
)

users.updateManyWithPipeline {
    set {
        User::score set cond(
            condition = of(User::multiplier) gt of(2),
            ifTrue = of(User::score) * of(User::multiplier),
            ifFalse = of(User::score)
        )
    }
}

External resources

Official documentation

See also

switch: Specify multiple conditions.

div¶

open operator fun <Context : Any, Root, Child> Value<Context, Root>.div(field: Field<Root, Child>): Value<Context, Child>

@JvmName(name = "divFieldReceiver")
open operator fun <Context : Any, Root, Child> Field<Context, Root>.div(field: Field<Root, Child>): Value<Context, Child>

@JvmName(name = "divResultReceiver")
inline operator fun <Context : Any, Root, Child> Root.div(field: Field<Root, Child>): Value<Context, Child>

open operator fun <Context : Any, Root, Child> Value<Context, Root>.div(field: KProperty1<Root, Child>): Value<Context, Child>

@JvmName(name = "divFieldReceiver")
open operator fun <Context : Any, Root, Child> Field<Context, Root>.div(field: KProperty1<Root, Child>): Value<Context, Child>

@JvmName(name = "divResultReceiver")
inline operator fun <Context : Any, Root, Child> Root.div(field: KProperty1<Root, Child>): Value<Context, Child>

Refers to field as a nested field of the current value.

Examples

class User(
    val name: String,
)

class Data(
    val users: List<User>,
    val userNames: List<Int>,
)

data.aggregate()
    .set {
        Data::userNames set Data::users.map { it / User::name }
    }

External resources

Official documentation

`get`¶

open operator fun <Root, Type> KProperty1<Root, Collection<Type>>.get(index: Int): Field<Root, Type>

Refers to a specific item in an array, by its index.

open operator fun <Root, Type> KProperty1<Root, Map<String, Type>>.get(index: String): Field<Root, Type>

Refers to a specific item in a map, by its name.

open operator fun <Root, Type> Field<Root, Collection<Type>>.get(index: Int): Field<Root, Type>

Refers to a specific item in an array, by its index.

open operator fun <Root, Type> Field<Root, Map<String, Type>>.get(key: String): Field<Root, Type>

Refers to a specific item in a map, by its name.

of¶

open fun <Context : Any, Result> of(field: Field<Context, Result>): Value<Context, Result>

open fun <Context : Any, Result> of(field: KProperty1<Context, Result>): Value<Context, Result>

Refers to a field within an aggregation value.

Example

class Product(
    val acceptanceDate: Instant,
    val publishingDate: Instant,
)

val publishedBeforeAcceptance = products.find {
    expr {
        of(Product::publishingDate) lt of(Product::acceptanceDate)
    }
}

open fun <Result> of(value: Result, type: KType): Value<Any, Result>

inline fun <Result> of(value: Result): Value<Any, Result>

Refers to a Kotlin value within an aggregation value.

Example

class Product(
    val age: Int,
)

val publishedBeforeAcceptance = products.find {
    expr {
        of(Product::age) lt of(15)
    }
}

open fun of(value: BsonType): Value<Any, BsonType>

Refers to a BsonType within an aggregation value.

Example

class Product(
    val age: Int,
)

val publishedBeforeAcceptance = products.find {
    expr {
        of(Product::age).type eq of(BsonType.Int32)
    }
}

switch¶

open fun <R : Any, T> switch(vararg cases: ConditionalValueOperators.Case<R, T>, default: Value<R, T>? = null): Value<R, T>

@JvmName(name = "switchByField")
open fun <R : Any, T> switch(vararg cases: ConditionalValueOperators.Case<R, T>, default: Field<R, T>): Value<R, T>

@JvmName(name = "switchByProperty")
open fun <R : Any, T> switch(vararg cases: ConditionalValueOperators.Case<R, T>, default: KProperty1<R, T>): Value<R, T>

inline fun <R : Any, T> switch(vararg cases: ConditionalValueOperators.Case<R, T>, default: T): Value<R, T>

Selects one value based on multiple conditions.

Example

class User(
    val name: String,
    val score: Int,
    val role: String,
    val bonus: Int?,
)

users.updateManyWithPipeline {
    set {
        User::bonus set switch(
            User::role eq "GUEST" then 5,
            User::role eq "EMPLOYEE" then 6,
            User::role eq "ADMIN" then 7,
            default = -1,
        )
    }
}

External resources

Official documentation

See also

cond: Specify a single condition.
then: Keyword to declare the different cases.

then¶

open infix fun <R : Any, T> Value<R, Boolean>.then(value: Value<R, T>): ConditionalValueOperators.Case<R, T>

@JvmName(name = "thenByField")
open infix fun <R : Any, T> Value<R, Boolean>.then(value: Field<R, T>): ConditionalValueOperators.Case<R, T>

@JvmName(name = "thenByProperty")
open infix fun <R : Any, T> Value<R, Boolean>.then(value: KProperty1<R, T>): ConditionalValueOperators.Case<R, T>

infix inline fun <R : Any, T> Value<R, Boolean>.then(value: T): ConditionalValueOperators.Case<R, T>

@JvmName(name = "thenFieldReceiverByValue")
open infix fun <R : Any, T> Field<R, Boolean>.then(value: Value<R, T>): ConditionalValueOperators.Case<R, T>

@JvmName(name = "thenFieldReceiverByField")
open infix fun <R : Any, T> Field<R, Boolean>.then(value: Field<R, T>): ConditionalValueOperators.Case<R, T>

@JvmName(name = "thenFieldReceiverByProperty")
open infix fun <R : Any, T> Field<R, Boolean>.then(value: KProperty1<R, T>): ConditionalValueOperators.Case<R, T>

@JvmName(name = "thenFieldReceiverByResult")
infix inline fun <R : Any, T> Field<R, Boolean>.then(value: T): ConditionalValueOperators.Case<R, T>

@JvmName(name = "thenPropertyReceiverByValue")
open infix fun <R : Any, T> KProperty1<R, Boolean>.then(value: Value<R, T>): ConditionalValueOperators.Case<R, T>

@JvmName(name = "thenPropertyReceiverByField")
open infix fun <R : Any, T> KProperty1<R, Boolean>.then(value: Field<R, T>): ConditionalValueOperators.Case<R, T>

@JvmName(name = "thenPropertyReceiverByProperty")
open infix fun <R : Any, T> KProperty1<R, Boolean>.then(value: KProperty1<R, T>): ConditionalValueOperators.Case<R, T>

@JvmName(name = "thenPropertyReceiverByResult")
infix inline fun <R : Any, T> KProperty1<R, Boolean>.then(value: T): ConditionalValueOperators.Case<R, T>

@JvmName(name = "thenResultReceiverByValue")
infix inline fun <R : Any, T> Boolean.then(value: Value<R, T>): ConditionalValueOperators.Case<R, T>

@JvmName(name = "thenResultReceiverByField")
infix inline fun <R : Any, T> Boolean.then(value: Field<R, T>): ConditionalValueOperators.Case<R, T>

@JvmName(name = "thenResultReceiverByProperty")
infix inline fun <R : Any, T> Boolean.then(value: KProperty1<R, T>): ConditionalValueOperators.Case<R, T>

@JvmName(name = "thenResultReceiverByResult")
infix inline fun <R : Any, T> Boolean.then(value: T): ConditionalValueOperators.Case<R, T>

Instantiates a Case for the switch operator.

Example

class User(
    val name: String,
    val score: Int,
    val role: String,
    val bonus: Int?,
)

users.updateManyWithPipeline {
    set {
        User::bonus set switch(
            User::role eq "GUEST" then 5,
            User::role eq "EMPLOYEE" then 6,
            User::role eq "ADMIN" then 7,
            default = -1,
        )
    }
}

See also

switch

`unsafe`¶

open infix fun <Root, Child> KProperty1<Root, *>.unsafe(child: String): Field<Root, Child>

Refers to a field child of the current field, with no compile-time safety.

open infix fun <Root, Child> KProperty1<Root, *>.unsafe(child: KProperty1<*, Child>): Field<Root, Child>

Refers to a field child of the current field, without checking that it is a field available on the current object.

open infix fun <Root, Child> KProperty1<Root, *>.unsafe(child: Field<*, Child>): Field<Root, Child>

Refers to a field child of the current field, without checking that it is a field available on the current object.

open infix fun <Root, Child> Field<Root, *>.unsafe(child: KProperty1<*, Child>): Field<Root, Child>

Refers to a field child of the current field, without checking that it is a field available on the current object.

open infix fun <Root, Child> Field<Root, *>.unsafe(child: Field<*, Child>): Field<Root, Child>

Refers to a field child of the current field, without checking that it is a field available on the current object.

open infix fun <Root, Type, Child> Field<Root, Type>.unsafe(child: String): Field<Root, Child>

Refers to a field child of the current field, with no compile-time safety.

ConditionalValueOperators¶

Inheritors¶

Types¶

Case¶

Properties¶

context¶

field¶

Functions¶

cond¶

div¶

get¶

of¶

switch¶

then¶

unsafe¶

`Case`¶

`field`¶

`get`¶

`unsafe`¶