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

BaseColumn

interface BaseColumn<out T> : ColumnReference<T>

Column with type, name/path and values Base interface for all three kinds of columns: ValueColumn, ColumnGroup and FrameColumn. Column operations that doesn't clash by signature with DataFrame operations can be defined for BaseColumn

Type Parameters

type of values contained in column.

Inheritors

DataColumn

ColumnGroup

Properties

isEmpty

internal val AnyBaseCol.isEmpty: Boolean

name

internal val ColumnReference<*>.name: String

size

internal val AnyBaseCol.size: Int

values

@PublishedApi

internal val <T> BaseColumn<T>.values: Iterable<T>

Functions

addFlag

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

addParent

internal fun <T> BaseColumn<T>.addParent(parent: ColumnGroup<*>): DataColumn<T>

addParentPath

internal fun <T> BaseColumn<T>.addParentPath(path: ColumnPath): ColumnWithPath<T>

addPath

internal fun <T> BaseColumn<T>.addPath(): ColumnWithPath<T>

internal fun <T> BaseColumn<T>.addPath(path: ColumnPath): ColumnWithPath<T>

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

checkEquals

internal fun <T> BaseColumn<T>.checkEquals(other: Any?): Boolean

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.

contains

abstract operator fun contains(value: T): Boolean

countDistinct

abstract fun countDistinct(): Int

defaultValue

abstract fun defaultValue(): T?

distinct

abstract fun distinct(): BaseColumn<T>

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

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

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 get(index: Int): T

Gets the row at given index.

abstract operator fun get(columnName: String): DataColumn<*>

open operator fun get(row: AnyRow): T

abstract operator fun get(indices: Iterable<Int>): BaseColumn<T>

open operator fun get(firstIndex: Int, vararg otherIndices: Int): BaseColumn<T>

Gets the rows at given indices.

abstract operator fun get(range: IntRange): BaseColumn<T>

Gets the rows at given range of indices.

getAt

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

getValue

open operator override fun getValue(thisRef: Any?, property: KProperty<*>): BaseColumn<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>

indices

fun AnyBaseCol.indices(): IntRange

kind

abstract fun kind(): ColumnKind

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>

maxWidth

internal fun BaseColumn<*>.maxWidth(): Int

Returns the max number of columns needed to display this column flattened

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.

onResolve

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): BaseColumn<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.

size

abstract fun size(): Int

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>

toDataFrame

fun BaseColumn<*>.toDataFrame(): DataFrame<*>

toList

open fun toList(): List<T>

toSet

abstract fun toSet(): Set<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.

type

abstract fun type(): KType

unaryMinus

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

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

unbox

internal fun AnyBaseCol.unbox(): AnyCol

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.

values

abstract fun values(): Iterable<T>

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>

BaseColumn

Type Parameters

See also

Inheritors

Properties

Functions