modelql-core/org.modelix.modelql.core/JoinStep

JoinStep

class JoinStep<E> : ProducingStep<E> , IConsumingStep<E> , IFluxStep<E>

Constructors

JoinStep

constructor()

Types

Descriptor

@Serializable

@SerialName(value = "join")

class Descriptor : CoreStepDescriptor

Properties

owner

open override val owner: QueryReference<*>

Functions

addConsumer

open override fun addConsumer(consumer: IConsumingStep<E>)

addProducer

open override fun addProducer(producer: IProducingStep<E>)

allowEmpty

fun <T> IFluxStep<T>.allowEmpty(): IFluxStep<T>

assertNotEmpty

fun <T> IFluxStep<T>.assertNotEmpty(): IFluxStep<T>

associate

fun <In, K, V> IFluxStep<In>.associate(keySelector: (IMonoStep<In>) -> IMonoStep<K>, valueSelector: (IMonoStep<In>) -> IMonoStep<V>): IMonoStep<Map<K, V>>

associateBy

fun <K, V> IFluxStep<V>.associateBy(keySelector: (IMonoStep<V>) -> IMonoStep<K>): IMonoStep<Map<K, V>>

associateWith

fun <K, V> IFluxStep<K>.associateWith(valueSelector: (IMonoStep<K>) -> IMonoStep<V>): IMonoStep<Map<K, V>>

asString

@JvmName(name = "asStringNullable")

fun IFluxStep<Any?>.asString(): IFluxStep<String?>

fun IFluxStep<Any>.asString(): IFluxStep<String>

bindFragment

fun <TIn, TContext> IFluxStep<TIn>.bindFragment(body: IRecursiveFragmentBuilder<TIn, TContext>.() -> Unit): IMonoStep<IBoundFragment<TContext>>

fun <TIn, TContext> IFluxStep<TIn>.bindFragment(fragment: IUnboundFragment<TIn, TContext>): IMonoStep<IBoundFragment<TContext>>

buildLocalMapping

fun <In, Out> IFluxStep<In>.buildLocalMapping(body: ILocalMappingBuilder<In, Out>.(IMonoStep<In>) -> Unit): IFluxStep<Out>

canBeEmpty

open override fun canBeEmpty(): Boolean

canBeMultiple

open override fun canBeMultiple(): Boolean

canEvaluateStatically

open fun canEvaluateStatically(): Boolean

connect

fun <T> IConsumingStep<T>.connect(producer: IProducingStep<T>)

fun <T> IProducingStep<T>.connect(consumer: IConsumingStep<T>)

count

fun IFluxStep<*>.count(): IMonoStep<Int>

createDescriptor

open override fun createDescriptor(context: QueryGraphDescriptorBuilder): JoinStep.Descriptor

createFlow

open override fun createFlow(context: IFlowInstantiationContext): StepFlow<E>

drop

fun <T> IFluxStep<T>.drop(count: Int): IFluxStep<T>

emptyStringIfNull

fun IFluxStep<String?>.emptyStringIfNull(): IFluxStep<String>

evaluateStatically

open fun evaluateStatically(): E

executeLocal

fun <In, Out> IFluxStep<In>.executeLocal(body: (In) -> Out): IFluxStep<Out>

filter

fun <T> IFluxStep<T>.filter(condition: IQueryBuilderContext<T, Boolean>.(IMonoStep<T>) -> IMonoStep<Boolean>): IFluxStep<T>

filterNotNull

fun <T : Any> IFluxStep<T?>.filterNotNull(): IFluxStep<T>

first

fun <Out> IProducingStep<Out>.first(): IMonoStep<Out>

firstOrNull

fun <E> IProducingStep<E>.firstOrNull(): IMonoStep<E?>

flatMap

fun <In, Out> IProducingStep<In>.flatMap(body: (IMonoStep<In>) -> IFluxStep<Out>): IFluxStep<Out>

fun <In, Out> IProducingStep<In>.flatMap(query: IFluxUnboundQuery<In, Out>): IFluxStep<Out>

getConsumers

open override fun getConsumers(): List<IConsumingStep<E>>

getOutputSerializer

open override fun getOutputSerializer(serializationContext: SerializationContext): KSerializer<out IStepOutput<E>>

getProducers

open override fun getProducers(): List<IProducingStep<E>>

getRootInputSteps

open fun getRootInputSteps(): Set<IStep>

hasSideEffect

open fun hasSideEffect(): Boolean

identity

fun <T> IFluxStep<T>.identity(): IFluxStep<T>

ifEmpty

@JvmName(name = "ifEmpty_flux_mono")

fun <In : Out, Out> IFluxStep<In>.ifEmpty(alternative: () -> IMonoStep<Out>): IFluxStep<Out>

ifEmptyFlux

@JvmName(name = "ifEmpty_flux_flux")

fun <In : Out, Out> IFluxStep<In>.ifEmptyFlux(alternative: () -> IFluxStep<Out>): IFluxStep<Out>

inputIsConsumedMultipleTimes

open fun inputIsConsumedMultipleTimes(): Boolean

inSet

fun <T> IFluxStep<T>.inSet(values: IMonoStep<Set<T>>): IFluxStep<Boolean>

fun IFluxStep<String?>.inSet(values: Set<String>): IFluxStep<Boolean>

isEmpty

fun IProducingStep<Any?>.isEmpty(): IMonoStep<Boolean>

isNotEmpty

fun IProducingStep<Any?>.isNotEmpty(): IMonoStep<Boolean>

isSingle

fun IProducingStep<*>.isSingle(): Boolean

map

fun <In, Out> IFluxStep<In>.map(body: IStepSharingContext.(IMonoStep<In>) -> IMonoStep<Out>): IFluxStep<Out>

fun <In, Out> IFluxStep<In>.map(query: IMonoUnboundQuery<In, Out>): IFluxStep<Out>

mapIfNotNull

fun <In : Any, Out> IFluxStep<In?>.mapIfNotNull(body: IQueryBuilderContext<In, Out>.(IMonoStep<In>) -> IMonoStep<Out>): IFluxStep<Out?>

mapLocal

fun <In, Out> IFluxStep<In>.mapLocal(body: (In) -> Out): IFluxStep<Out>

mapLocal2

fun <In, Out> IFluxStep<In>.~~mapLocal2~~(body: ILocalMappingBuilder<In, Out>.(IMonoStep<In>) -> Unit): IFluxStep<Out>

needsCoroutineScope

open fun needsCoroutineScope(): Boolean

nullIfEmpty

fun <Out> IFluxStep<Out>.nullIfEmpty(): IFluxStep<Out?>

orNull

fun <Out> IFluxStep<Out>.orNull(): IFluxStep<Out?>

outputIsConsumedMultipleTimes

open fun outputIsConsumedMultipleTimes(): Boolean

plus

operator fun IFluxStep<Int>.plus(other: Int): IFluxStep<Int>

operator fun <Common> IProducingStep<Common>.plus(other: IProducingStep<Common>): IFluxStep<Common>

fun <T> IFluxStep<T>.print(prefix: String = ""): IFluxStep<T>

requiresSingularQueryInput

open override fun requiresSingularQueryInput(): Boolean

requiresWriteAccess

open fun requiresWriteAccess(): Boolean

single

fun <E> IFluxStep<E>.single(): IMonoStep<E>

take

fun <T> IFluxStep<T>.take(count: Int): IFluxStep<T>

toBoolean

fun IFluxStep<String?>.toBoolean(): IFluxStep<Boolean>

toInt

fun IFluxStep<String?>.toInt(): IFluxStep<Int>

toList

fun <T> IFluxStep<T>.toList(): IMonoStep<List<T>>

toMap

fun <K, V> IFluxStep<IZip2Output<*, K, V>>.toMap(): IMonoStep<Map<K, V>>

toSet

fun <T> IFluxStep<T>.toSet(): IMonoStep<Set<T>>

toString

open override fun toString(): String

validate

open fun validate()

withIndex

fun <T> IFluxStep<T>.withIndex(): IFluxStep<IWithIndex<T>>

zip

fun <Common, T1 : Common, T2 : Common> IProducingStep<T1>.zip(other2: IProducingStep<T2>): IFluxStep<IZip2Output<Common, T1, T2>>

fun <T> IProducingStep<T>.zip(vararg others: IProducingStep<T>): IFluxStep<IZipOutput<T>>

fun <Common, T1 : Common, T2 : Common, T3 : Common> IProducingStep<T1>.zip(other2: IProducingStep<T2>, other3: IProducingStep<T3>): IFluxStep<IZip3Output<Common, T1, T2, T3>>

fun <Common, T1 : Common, T2 : Common, T3 : Common, T4 : Common> IProducingStep<T1>.zip(other2: IProducingStep<T2>, other3: IProducingStep<T3>, other4: IProducingStep<T4>): IFluxStep<IZip4Output<Common, T1, T2, T3, T4>>

fun <Common, T1 : Common, T2 : Common, T3 : Common, T4 : Common, T5 : Common> IProducingStep<T1>.zip(other2: IProducingStep<T2>, other3: IProducingStep<T3>, other4: IProducingStep<T4>, other5: IProducingStep<T5>): IFluxStep<IZip5Output<Common, T1, T2, T3, T4, T5>>

zipN

fun <T> IProducingStep<T>.zipN(vararg others: IProducingStep<T>): IFluxStep<IZipOutput<T>>