client/io.github.octaviusframework.client.transaction

Package-level declarations

Types

SpreadParameters

class SpreadParameters(val source: TransactionValue<*>)

A value marked by spread, filling a parameter slot with a whole map's worth of parameters.

StepBuilder

class StepBuilder @PublishedApi constructor(val query: RunnableQuery<*>)

Turns a query into a step instead of running it.

StepHandle

class StepHandle<out T>(position: Int)

Names a step in a TransactionPlan, so that later steps can refer to what it will produce.

TransactionDefinition

data class TransactionDefinition(val propagation: TransactionPropagation = TransactionPropagation.REQUIRED, val isolation: TransactionIsolationLevel? = null, val readOnly: Boolean = false, val statementTimeout: Duration? = null, val transactionTimeout: Duration? = null)

How a transaction should be run.

TransactionPlan

class TransactionPlan

A sequence of operations to run as one transaction, assembled before any of it runs.

TransactionPlanResult

class TransactionPlanResult(results: Map<StepHandle<*>, Any?>, val size: Int)

What a TransactionPlan produced, by step.

TransactionPropagation

enum TransactionPropagation : Enum<TransactionPropagation>

What a transaction does when it is started inside one that is already running.

TransactionStep

class TransactionStep<T> @PublishedApi constructor(val query: RunnableQuery<*>, val params: Map<String, Any?>, val run: (Map<String, Any?>) -> T)

One operation of a TransactionPlan, described but not yet run.

TransactionValue

sealed class TransactionValue<out T>

A parameter value in a TransactionPlan step, which may not exist yet.

Functions

describePlan

internal fun describePlan(entries: List<TransactionPlan.PlannedStep>): String

The whole of what a plan will do, as text.

describeValue

internal fun describeValue(value: TransactionValue<*>, stepIndices: Map<StepHandle<*>, Int>? = null): String

Renders a value as the chain that will produce it.

map

fun <IN, OUT> TransactionValue<IN>.map(transformation: (IN) -> OUT): TransactionValue<OUT>

Applies transformation to this value once it resolves.

resolveParams

internal fun resolveParams(raw: Map<String, Any?>, results: Map<StepHandle<*>, Any?>, stepIndex: Int, stepIndices: Map<StepHandle<*>, Int>): Map<String, Any?>

Replaces the unresolved values in a step's parameters with what the earlier steps produced.

spread

fun TransactionValue<Map<String, Any?>>.spread(): SpreadParameters

Marks this map to be spread into parameters of its own rather than assigned to one.

toTransactionValue

fun <T> T.toTransactionValue(): TransactionValue.Value<T>

Wraps a value that is already known, for the occasional parameter map that mixes the two.

validatePlan

internal fun validatePlan(steps: List<TransactionPlan.PlannedStep>): Map<StepHandle<*>, Int>

Checks what can be checked about a plan without running any of it, before a transaction is opened.