core/org.jetbrains.kotlinx.dataframe.columns/ColumnAccessor

ColumnAccessor

interface ColumnAccessor<out T> : ColumnReference<T>

Combination of column path and column type.

Used to retrieve DataColumn from DataFrame or value from DataRow.

Can be created by column, columnGroup or frameColumn delegates.

Type Parameters

Expected type of values in the column

Inheritors

ColumnPath

ColumnAccessorImpl

Properties

name

internal val ColumnReference<*>.name: String

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>

cast

fun <T> ColumnAccessor<*>.cast(): ColumnAccessor<T>

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

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

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

castToNotNullable

fun <T> ColumnReference<T?>.castToNotNullable(): ColumnReference<T>

castToNullable

fun <T> ColumnReference<T>.castToNullable(): ColumnReference<T?>

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.

column

fun <T> ColumnReference<DataRow<*>>.column(): ColumnDelegate<T>

fun <T> ColumnReference<DataRow<*>>.column(name: String): ColumnAccessor<T>

fun <T> ColumnReference<DataRow<*>>.~~column~~(property: KProperty<T>): ColumnAccessor<T>

fun <T> ColumnReference<DataRow<*>>.column(path: ColumnPath): ColumnAccessor<T>

columnGroup

fun ColumnReference<DataRow<*>>.columnGroup(): ColumnDelegate<DataRow<*>>

fun ColumnReference<DataRow<*>>.columnGroup(name: String): ColumnAccessor<DataRow<*>>

fun <T> ColumnReference<DataRow<*>>.~~columnGroup~~(property: KProperty<T>): ColumnAccessor<DataRow<T>>

@JvmName(name = "columnGroupDataRowKProperty")

fun <T> ColumnReference<DataRow<*>>.~~columnGroup~~(property: KProperty<DataRow<T>>): ColumnAccessor<DataRow<T>>

fun ColumnReference<DataRow<*>>.columnGroup(path: ColumnPath): ColumnAccessor<DataRow<*>>

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.

div

operator fun ColumnReference<Int>.div(value: Int): ColumnReference<Int>

Returns a ColumnReference containing the results of dividing each element of this ColumnReference by value.

ensureIsColumnGroup

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

@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> ColumnAccessor<DataFrame<C>>.ensureIsFrameColumn(): ColumnAccessor<DataFrame<C>>

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> ColumnAccessor<C>.ensureIsValueColumn(): ColumnAccessor<C>

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.

infix fun <C> ColumnReference<C>.eq(value: C): ColumnReference<Boolean>

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.

frameColumn

fun ColumnReference<DataRow<*>>.frameColumn(): ColumnDelegate<DataFrame<*>>

fun ColumnReference<DataRow<*>>.frameColumn(name: String): ColumnAccessor<DataFrame<*>>

fun <T> ColumnReference<DataRow<*>>.~~frameColumn~~(property: KProperty<List<T>>): ColumnAccessor<DataFrame<T>>

@JvmName(name = "frameColumnDataFrameKProperty")

fun <T> ColumnReference<DataRow<*>>.~~frameColumn~~(property: KProperty<DataFrame<T>>): ColumnAccessor<DataFrame<T>>

fun ColumnReference<DataRow<*>>.frameColumn(path: ColumnPath): ColumnAccessor<DataFrame<*>>

frameColumnsInternal

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

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

get

abstract operator fun <C> get(column: ColumnReference<C>): ColumnAccessor<C>

getAt

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

getValue

open operator override fun getValue(thisRef: Any?, property: KProperty<*>): ColumnAccessor<T>

open fun getValue(row: AnyRow): T

getValueOrNull

open fun getValueOrNull(row: AnyRow): T?

infix fun <C : Comparable<C>> ColumnReference<C>.gt(value: C): ColumnReference<Boolean>

length

fun ColumnReference<String?>.~~length~~(): ColumnReference<Int>

lowercase

fun ColumnReference<String?>.~~lowercase~~(): ColumnReference<String?>

infix fun <C : Comparable<C>> ColumnReference<C>.lt(value: C): ColumnReference<Boolean>

map

internal inline fun <C, reified R> ColumnReference<C>.~~map~~(infer: Infer = Infer.Nulls, noinline transform: (C) -> R): ColumnReference<R>

minus

operator fun ColumnReference<Int>.minus(value: Int): ColumnReference<Int>

Returns a ColumnReference where each element is the result of subtracting value from the corresponding element of this ColumnReference.

name

abstract fun name(): String

neq

infix fun <C> ColumnReference<C>.~~neq~~(value: C): ColumnReference<Boolean>

not

@JvmName(name = "notBooleanNullable")

operator fun ColumnReference<Boolean?>.not(): ColumnReference<Boolean?>

Returns a ColumnReference containing the inverse Boolean values of this ColumnReference. Each null value in the original ColumnReference is preserved.

operator fun ColumnReference<Boolean>.not(): ColumnReference<Boolean>

Returns a ColumnReference containing the inverse Boolean values of this ColumnReference.

nullable

inline fun <reified T> ColumnAccessor<T>.nullable(): ColumnAccessor<T?>

onResolve

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

Helper function to perform runtime checks on a ColumnAccessor.

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

Helper function to perform runtime checks on a SingleColumn.

path

open fun path(): ColumnPath

plus

operator fun ColumnReference<Any?>.plus(str: String): ColumnReference<String>

Returns a ColumnReference of String values obtained by converting each element of this ColumnReference to a String and concatenating it with str.

operator fun ColumnReference<Int>.plus(value: Int): ColumnReference<Int>

Returns a ColumnReference where each element is the result of adding value to the corresponding element of this ColumnReference.

rename

abstract override fun rename(newName: String): ColumnAccessor<T>

renamedColumn

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

renamedReference

internal fun <C> ColumnReference<C>.renamedReference(newName: String): ColumnReference<C>

resolve

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

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>>

resolveFor

internal fun <C> ColumnReference<C>.resolveFor(df: AnyFrame): ColumnWithPath<C>?

resolveSingle

open override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<T>?

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>

shortPath

internal fun ColumnReference<*>.shortPath(): ColumnPath

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.

times

operator fun ColumnReference<Int>.times(value: Int): ColumnReference<Int>

Returns a ColumnReference containing the results of multiplying each element of this ColumnReference by value.

toColumnAccessor

fun <T> ColumnReference<T>.toColumnAccessor(): ColumnAccessor<T>

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.

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.

unaryMinus

operator fun ColumnReference<Int>.unaryMinus(): ColumnReference<Int>

Returns a ColumnReference containing negatives of the corresponding elements of this ColumnReference.

uppercase

fun ColumnReference<String?>.~~uppercase~~(): ColumnReference<String?>

valueColumn

fun ColumnReference<DataRow<*>>.valueColumn(): ColumnDelegate<Any?>

fun ColumnReference<DataRow<*>>.valueColumn(name: String): ColumnAccessor<Any?>

fun <T> ColumnReference<DataRow<*>>.~~valueColumn~~(property: KProperty<T>): ColumnAccessor<T>

fun ColumnReference<DataRow<*>>.valueColumn(path: ColumnPath): ColumnAccessor<Any?>

valueColumnsInternal

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

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

withValues

inline fun <reified T> ColumnReference<T>.~~withValues~~(values: Iterable<T>): ValueColumn<T>

inline fun <reified T> ColumnReference<T>.~~withValues~~(vararg values: T): ValueColumn<T>