core/org.jetbrains.kotlinx.dataframe.impl.columns/TransformableSingleColumn

TransformableSingleColumn

internal interface TransformableSingleColumn<out C> : SingleColumn<C>

Transformable SingleColumn

This type of SingleColumn can be transformed before being resolved.

This is especially useful for calls like singleInternal { }.atAnyDepthImpl(), where atAnyDepthImpl modifies the SingleColumn that singleInternal { } operates on to include ALL columns, including those inside column groups, before it's evaluated.

Functions

addFlag

internal fun <C> ColumnsResolver<C>.addFlag(flag: SortFlag): ColumnSetWithSortFlag<C>

allAfterInternal

@PublishedApi

internal inline fun ColumnsResolver<*>.allAfterInternal(crossinline colByPredicate: ColumnFilter<*>): ColumnSet<*>

Returns a new ColumnSet containing all columns after the first column that matches the given predicate.

allBeforeInternal

@PublishedApi

internal inline fun ColumnsResolver<*>.allBeforeInternal(crossinline colByPredicate: ColumnFilter<*>): ColumnSet<*>

Returns a new ColumnSet containing all columns before the first column that satisfies the given predicate.

allColsExceptInternal

internal fun SingleColumn<DataRow<*>>.allColsExceptInternal(other: ColumnsResolver<*>): ColumnSet<Any?>

Returns a new ColumnSet that contains all columns from inside the receiver column group except those specified in the "other" ColumnsResolver.

allColumnsInternal

@PublishedApi

internal fun ColumnsResolver<*>.allColumnsInternal(removePaths: Boolean = false): TransformableColumnSet<*>

If this is a SingleColumn containing a single ColumnGroup (like SingleColumn<AnyRow> or ColumnsSelectionDsl), it returns a (transformable) ColumnSet containing the children of this ColumnGroup, else it simply returns a (transformable) ColumnSet from this (like when this is a ColumnSet).

allFromInternal

@PublishedApi

internal inline fun ColumnsResolver<*>.allFromInternal(crossinline colByPredicate: ColumnFilter<*>): ColumnSet<*>

Returns a column set containing all columns from the internal column set that satisfy the given predicate.

allUpToInternal

@PublishedApi

internal inline fun ColumnsResolver<*>.allUpToInternal(crossinline colByPredicate: ColumnFilter<*>): ColumnSet<*>

Returns a ColumnSet containing all columns up to (and including) the first column that satisfies the given predicate.

asColumnGroup

fun <C> SingleColumn<C>.asColumnGroup(): SingleColumn<DataRow<C>>

@JvmName(name = "asColumnGroupDataRow")

fun <C> SingleColumn<DataRow<C>>.asColumnGroup(): SingleColumn<DataRow<C>>

Creates a ColumnAccessor<DataRow<C>> from this. This is especially useful when you want to use ColumnGroup functions in the ColumnsSelectionDsl but your column type is not recognized as a ColumnGroup. If you're not sure whether a column is recognized as ColumnGroup or not, you can always call asColumnGroup and it will return the same type if it is already a ColumnGroup.

asColumnSet

internal fun <C> ColumnsResolver<C>.asColumnSet(): ColumnSet<C>

@PublishedApi

internal fun <C> SingleColumn<C>.asColumnSet(): ColumnSet<C>

asComparable

fun <T> SingleColumn<T>.asComparable(): SingleColumn<Comparable<T>>

asNumbers

@JvmName(name = "asNumbersAnyNullable")

fun SingleColumn<Any?>.asNumbers(): SingleColumn<Number?>

@JvmName(name = "asNumbersAny")

fun SingleColumn<Any>.asNumbers(): SingleColumn<Number>

atAnyDepthImpl

internal fun <C> TransformableSingleColumn<C>.atAnyDepthImpl(includeGroups: Boolean = true, includeTopLevel: Boolean = true): SingleColumn<C>

AtAnyDepth implementation for TransformableSingleColumn. This converts a TransformableSingleColumn into a SingleColumn by redirecting SingleColumn.resolveSingle to TransformableSingleColumn.transformResolveSingle with a correctly configured AtAnyDepthTransformer.

cast

fun <C> ColumnsResolver<*>.cast(): ColumnsResolver<C>

fun <C> SingleColumn<*>.cast(): SingleColumn<C>

colsAtAnyDepthInternal

internal fun ColumnsResolver<*>.colsAtAnyDepthInternal(predicate: ColumnFilter<*>): ColumnSet<*>

Returns all columns inside this ColumnsResolver at any depth if they satisfy the given predicate.

colsInternal

@PublishedApi

internal inline fun ColumnsResolver<*>.colsInternal(crossinline predicate: ColumnFilter<*>): TransformableColumnSet<*>

If this ColumnsResolver is a SingleColumn, it returns a new ColumnSet containing the columns inside of this SingleColumn that match the given predicate.

internal fun ColumnsResolver<*>.colsInternal(indices: IntArray): TransformableColumnSet<*>

internal fun ColumnsResolver<*>.colsInternal(range: IntRange): TransformableColumnSet<*>

internal fun SingleColumn<DataRow<*>>.colsInternal(refs: Iterable<ColumnReference<*>>): ColumnSet<*>

colsOf

inline fun <reified C> SingleColumn<DataRow<*>>.colsOf(noinline filter: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<C>

fun <C> SingleColumn<DataRow<*>>.colsOf(type: KType, filter: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<C>

Returns a ColumnSet of columns from this that are a subtype of the given type C, optionally filtered by filter.

colsOfInternal

internal inline fun <C> ColumnsResolver<*>.colsOfInternal(type: KType, crossinline filter: ColumnFilter<C>): TransformableColumnSet<C>

If this ColumnsResolver is a SingleColumn, it returns a new ColumnSet containing the columns inside of this SingleColumn that match the given filter and are the given type.

columnGroupsInternal

internal inline fun ColumnsResolver<*>.columnGroupsInternal(crossinline filter: (ColumnGroup<*>) -> Boolean): ColumnSet<DataRow<*>>

Returns a ColumnSet containing the column groups that satisfy the given filter.

columnsOfKindInternal

internal inline fun ColumnsResolver<*>.columnsOfKindInternal(kinds: Set<ColumnKind>, crossinline filter: ColumnFilter<*>): TransformableColumnSet<*>

Returns a TransformableColumnSet containing the columns of given kind(s) that satisfy the given filter.

ensureIsColumnGroup

@PublishedApi

internal fun <C> SingleColumn<DataRow<C>>.ensureIsColumnGroup(): SingleColumn<DataRow<C>>

Checks the validity of this SingleColumn, by adding a check to see it's a ColumnGroup (so, a SingleColumn<*>) and throwing an IllegalArgumentException if it's not.

ensureIsFrameColumn

internal fun <C> SingleColumn<DataFrame<C>>.ensureIsFrameColumn(): SingleColumn<DataFrame<C>>

Checks the validity of this SingleColumn, by adding a check to see it's a FrameColumn (so, a SingleColumn<*>) and throwing an IllegalArgumentException if it's not.

ensureIsValueColumn

internal fun <C> SingleColumn<C>.ensureIsValueColumn(): SingleColumn<C>

Checks the validity of this SingleColumn, by adding a check to see it's a ValueColumn (so, a SingleColumn<*>) and throwing an IllegalArgumentException if it's not.

exceptInternal

@JvmName(name = "exceptInternalSingleColumn")

internal fun <C> SingleColumn<DataRow<C>>.exceptInternal(other: ColumnsResolver<*>): SingleColumn<DataRow<C>>

Returns a new SingleColumn> that has the same structure as the receiver, but excludes columns specified in the "other" ColumnsResolver.

extractJoinColumns

internal fun <C> ColumnsResolver<C>.extractJoinColumns(): List<ColumnMatch<C>>

flattenRecursively

internal fun ColumnsResolver<*>.flattenRecursively(includeGroups: Boolean = true, includeTopLevel: Boolean = true): ColumnsResolver<*>

Flattens a ColumnsResolver recursively.

frameColumnsInternal

internal inline fun ColumnsResolver<*>.frameColumnsInternal(crossinline filter: (FrameColumn<*>) -> Boolean): TransformableColumnSet<AnyFrame>

Returns a TransformableColumnSet containing the frame columns that satisfy the given filter.

getAt

internal fun <T> ColumnsResolver<T>.getAt(index: Int): SingleColumn<T>

onResolve

internal fun <A> SingleColumn<A>.onResolve(check: (ColumnWithPath<A>?) -> Unit): SingleColumn<A>

Helper function to perform runtime checks on a SingleColumn.

internal fun <A> TransformableSingleColumn<A>.onResolve(check: (ColumnWithPath<A>?) -> Unit): TransformableSingleColumn<A>

renamedColumn

internal fun <C> SingleColumn<C>.renamedColumn(newName: String): SingleColumn<C>

resolve

open override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>>

Resolves this ColumnsResolver as a List<ColumnWithPath<C>>. In many cases this function transforms a parent ColumnsResolver to reach the current ColumnsResolver result.

resolve

internal fun <C> ColumnsResolver<C>.resolve(df: DataFrame<*>, unresolvedColumnsPolicy: UnresolvedColumnsPolicy = UnresolvedColumnsPolicy.Fail): List<ColumnWithPath<C>>

resolveSingle

abstract fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>?

resolveSingle

internal fun <C> SingleColumn<C>.resolveSingle(df: DataFrame<*>, unresolvedColumnsPolicy: UnresolvedColumnsPolicy = UnresolvedColumnsPolicy.Fail): ColumnWithPath<C>?

selectInternal

internal fun <C, R> SingleColumn<DataRow<C>>.selectInternal(selector: ColumnsSelector<C, R>): ColumnSet<R>

simplifyInternal

internal fun ColumnsResolver<*>.simplifyInternal(): ColumnSet<*>

Simplifies structure by removing columns that are already present in column groups in this.

singleImpl

internal fun <T> ColumnsResolver<T>.singleImpl(): SingleColumn<T>

Converts this ColumnsResolver to a SingleColumn. resolveSingle will return the single column of this if there is only one, else it will throw an exception: In case of an empty ColumnsResolver, a NoSuchElementException will be thrown. In case of more than one column, an IllegalArgumentException will be thrown. If the result is used as a ColumnSet, null will be converted to an empty list.

singleInternal

internal fun <C> ColumnsResolver<C>.singleInternal(condition: ColumnFilter<C> = { true }): TransformableSingleColumn<C>

singleOrNullImpl

internal fun <T> ColumnsResolver<T>.singleOrNullImpl(): SingleColumn<T>

Converts this ColumnsResolver to a SingleColumn. resolveSingle will return the single column of this if there is only one, else it will return null. If the result used as a ColumnSet, null will be converted to an empty list.

transform

@PublishedApi

internal inline fun <A, B> ColumnsResolver<A>.transform(crossinline converter: (List<ColumnWithPath<A>>) -> List<ColumnWithPath>): TransformableColumnSet

Applies a transformation on this by converting its List<ColumnWithPath<A>] to List<ColumnWithPath<B>] using converter.

transformResolveSingle

abstract fun transformResolveSingle(context: ColumnResolutionContext, transformer: ColumnsResolverTransformer): ColumnWithPath<C>?

transformSingle

internal fun <A, B> SingleColumn<A>.transformSingle(converter: (ColumnWithPath<A>) -> List<ColumnWithPath>): ColumnSet

Applies a transformation on this SingleColumn by converting its single ColumnWithPath<A> to List<ColumnWithPath<B>] using converter. Since converter allows you to return multiple columns, the result is turned into a ColumnSet<B>.

transformSingleWithContext

internal fun <A, B> SingleColumn<A>.transformSingleWithContext(converter: ColumnResolutionContext.(ColumnWithPath<A>) -> List<ColumnWithPath>): ColumnSet

Applies a transformation on this SingleColumn by converting its single ColumnWithPath<A> to List<ColumnWithPath<B>] using converter but also providing the ColumnResolutionContext to the converter.

transformWithContext

internal fun <A, B> ColumnsResolver<A>.transformWithContext(converter: ColumnResolutionContext.(List<ColumnWithPath<A>>) -> List<ColumnWithPath>): TransformableColumnSet

Applies a transformation on this by converting its List<ColumnWithPath<A>] to List<ColumnWithPath<B>] using converter, but also providing the ColumnResolutionContext to the converter.

valueColumnsInternal

internal inline fun ColumnsResolver<*>.valueColumnsInternal(crossinline filter: (ValueColumn<*>) -> Boolean): TransformableColumnSet<*>

Returns a TransformableColumnSet containing the value columns that satisfy the given filter.

TransformableSingleColumn

Transformable SingleColumn

See also

Functions