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

ColumnPath

data class ColumnPath(val path: List<String>) : List<String> , ColumnAccessor<Any?>

Path to a column in DataFrame.

Stores a list of column names that are used to retrieve columns through a chain of column groups.

Constructors

ColumnPath

constructor(path: List<String>)

constructor(name: String)

Types

Companion

internal object Companion

Properties

columnName

val columnName: String

name

internal val ColumnReference<*>.name: String

parentName

val parentName: String?

path

val path: List<String>

size

open override val size: Int

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.

allColumnsExceptAndUnpack

internal fun List<ColumnWithPath<*>>.allColumnsExceptAndUnpack(columns: Iterable<ColumnWithPath<*>>): List<ColumnWithPath<*>>

Returns a new list of column paths, except the ones inside columns. NOTE: The structure is not kept the same; if a column is removed, its parent will be removed as well, and all its siblings will be lifted out of the group. This also happens if a column is "removed" that does not exist in this.

allColumnsExceptKeepingStructure

internal fun List<ColumnWithPath<*>>.allColumnsExceptKeepingStructure(columns: Set<ColumnWithPath<*>>, removeEmptyGroups: Boolean = true): List<ColumnWithPath<*>>

Returns a new list of column paths, except the ones inside columns. NOTE: ColumnGroups are adapted to keep their structure. If a column inside a column group is excepted, it will be removed from the group. Empty groups will be removed if removeEmptyGroups== true

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.

anyNull

@PublishedApi

internal fun <T> Iterable<T>.anyNull(): Boolean

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

asList

fun <T> Iterable<T>.asList(): List<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?>

classes

internal fun Iterable<Any?>.classes(): Set<KClass<*>>

Returns a set containing the KClass of each element in the iterable.

collectTree

internal fun List<ColumnWithPath<*>>.collectTree(): TreeNode<DataColumn<*>?>

internal fun <D> List<ColumnWithPath<*>>.collectTree(emptyData: D, createData: (AnyCol) -> D): TreeNode<D>

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.

commonType

internal fun Iterable<KType?>.commonType(useStar: Boolean = true): KType

Returns the common supertype of the given types.

internal fun Iterable<KClass<*>>.commonType(nullable: Boolean, upperBound: KType? = null): KType

commonTypeListifyValues

internal fun Iterable<KType>.commonTypeListifyValues(useStar: Boolean = true): KType

Returns the common type of the given types including "listify" behaviour. Values and nulls will be wrapped in a list if they appear among other lists. For example: [Int, Nothing?, List<Int>] will become List<Int> instead of Any?. If there is another collection in there, it will become Any? anyway.

concat

fun <T> Iterable<DataColumn<T>>.concat(): DataColumn<T>

Returns a DataColumn containing all values from the columns in this iterable.

fun <T> Iterable<DataFrame<T>>.concat(): DataFrame<T>

Returns a DataFrame containing all rows from the DataFrames in this iterable.

@JvmName(name = "concatRows")

fun <T> Iterable<DataRow<T>?>.concat(): DataFrame<T>

Returns a DataFrame containing the rows in this iterable in iteration order.

contains

open operator override fun contains(element: String): Boolean

containsAll

open override fun containsAll(elements: Collection<String>): Boolean

convertToUnifiedNumberType

@JvmName(name = "convertNullableIterableToUnifiedNumberType")

internal fun Iterable<Number?>.convertToUnifiedNumberType(options: UnifiedNumberTypeOptions = UnifiedNumberTypeOptions.DEFAULT, commonNumberType: KType? = null): Iterable<Number?>

@JvmName(name = "convertIterableToUnifiedNumberType")

internal fun Iterable<Number>.convertToUnifiedNumberType(options: UnifiedNumberTypeOptions = UnifiedNumberTypeOptions.DEFAULT, commonNumberType: KType? = null): Iterable<Number>

Converts the elements of the given iterable of numbers into a common numeric type based on complexity. The common numeric type is determined using the provided commonNumberType parameter or calculated with Iterable.unifiedNumberTypeOrNull from the iterable's elements if not explicitly specified.

createDataFrameImpl

internal fun <T> Iterable<T>.~~createDataFrameImpl~~(clazz: KClass<*>, body: CreateDataFrameDslImpl<T>.() -> Unit): DataFrame<T>

@PublishedApi

internal fun <T> Iterable<T>.createDataFrameImpl(type: KType, body: CreateDataFrameDslImpl<T>.() -> Unit): DataFrame<T>

createType

internal fun Iterable<KClass<*>>.createType(nullable: Boolean, upperBound: KType? = null): KType

depth

internal fun ColumnPath.depth(): Int

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.

drop

fun drop(size: Int): ColumnPath

dropFirst

fun dropFirst(size: Int = 1): ColumnPath

Returns a shortened ColumnPath without the first size elements.

dropLast

fun dropLast(size: Int = 1): ColumnPath

Returns a shortened ColumnPath without the last size elements.

dropStartWrt

internal fun ColumnPath.dropStartWrt(otherPath: ColumnPath): ColumnPath

Drops the overlapping start of the child path with respect to the parent path, and returns the resulting ColumnPath.

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>

equalsByElement

internal fun <T> Iterable<T>.equalsByElement(other: Iterable<T>): 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>>

filterRequiredForSchema

internal fun Iterable<Marker>.filterRequiredForSchema(schema: DataFrameSchema): List<Marker>

flattenRecursively

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

Flattens a ColumnsResolver recursively.

internal fun Iterable<ColumnWithPath<*>>.flattenRecursively(): List<ColumnWithPath<*>>

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

open operator override fun get(index: Int): String

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

getAt

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

getTrueIndices

internal fun List<Boolean>.getTrueIndices(): List<Int>

getValue

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

open override fun getValue(row: AnyRow): Any?

getValueOrNull

open override fun getValueOrNull(row: AnyRow): Any?

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

indexOf

open override fun indexOf(element: String): Int

intersectSchemas

internal fun Iterable<DataFrameSchema>.intersectSchemas(): DataFrameSchema

isEmpty

open override fun isEmpty(): Boolean

iterator

open operator override fun iterator(): Iterator<String>

join

internal fun List<Code>.join(): String

joinOrNull

fun <T> Iterable<DataFrame<T>>.joinOrNull(joinType: JoinType = JoinType.Inner, selector: JoinColumnsSelector<T, T>? = null): DataFrame<T>?

Joins all DataFrames in this iterable into a single DataFrame.

joinToString

fun joinToString(separator: String = "/"): String

last

internal fun <T> List<T>.last(count: Int): List<T>

lastIndexOf

open override fun lastIndexOf(element: String): Int

length

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

listIterator

open override fun listIterator(): ListIterator<String>

open override fun listIterator(index: Int): ListIterator<String>

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

open override 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.

parent

fun parent(): ColumnPath?

path

open override fun path(): ColumnPath

plus

operator fun plus(name: String): ColumnPath

operator fun plus(otherPath: Iterable<String>): ColumnPath

operator fun plus(otherPath: ColumnPath): 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.

quickSelect

@PublishedApi

internal fun <T : Comparable<T>> List<T>.quickSelect(k: Int): T

Select the k't "smallest" element from list this

removeAt

internal fun <T> List<T>.removeAt(index: Int): List<T>

rename

open override fun rename(newName: String): ColumnPath

renamedColumn

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

renamedReference

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

replaceLast

fun replaceLast(name: String): ColumnPath

resolve

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

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

resolveSingle

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

rollingHash

internal fun <T> Iterable<T>.rollingHash(): Int

selectInternal

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

shortenPaths

internal fun <C> List<ColumnWithPath<C>>.shortenPaths(): List<ColumnWithPath<C>>

Shorten column paths as much as possible to keep them unique

shortPath

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

simplify

internal fun <T> List<ColumnWithPath<T>>.simplify(): List<ColumnWithPath<T>>

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

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.

sortWithConstructor

internal fun <T> Iterable<KCallable<T>>.sortWithConstructor(klass: KClass<*>): List<KCallable<T>>

Sorts this according to the order of their columnName in the primary/single constructor of klass if it exists, else, it falls back to lexicographical sorting.

splitByIndices

internal fun <T> List<T>.splitByIndices(startIndices: Sequence<Int>): Sequence<List<T>>

subList

open override fun subList(fromIndex: Int, toIndex: Int): List<String>

take

fun take(first: Int): ColumnPath

Returns a shortened ColumnPath containing just the first first elements.

takeLast

fun takeLast(last: Int): ColumnPath

Returns a shortened ColumnPath containing just the last last elements.

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.

toColumn

inline fun <reified T> Iterable<T>.~~toColumn~~(property: KProperty<T>): DataColumn<T>

inline fun <reified T> Iterable<T>.toColumn(ref: ColumnReference<T>): DataColumn<T>

inline fun <reified T> Iterable<T>.toColumn(name: String = "", infer: Infer = Infer.Nulls): DataColumn<T>

toColumnAccessor

fun ColumnPath.toColumnAccessor(): ColumnAccessor<Any?>

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

toColumnGroup

fun Iterable<BaseColumn<*>>.toColumnGroup(name: String): ColumnGroup<*>

fun <T> Iterable<BaseColumn<*>>.toColumnGroup(column: ColumnGroupAccessor<T>): ColumnGroup<T>

toColumnGroupAccessor

fun ColumnPath.toColumnGroupAccessor(): ColumnAccessor<DataRow<*>>

toColumnGroupOf

fun <T> Iterable<BaseColumn<*>>.toColumnGroupOf(name: String): ColumnGroup<T>

toColumnOf

fun <T> ColumnPath.toColumnOf(): ColumnAccessor<T>

inline fun <reified T> Iterable<*>.toColumnOf(name: String = ""): DataColumn<T>

toColumnSet

@JvmName(name = "toColumnSetString")

fun Iterable<String>.toColumnSet(): ColumnSet<Any?>

@JvmName(name = "toColumnSetKProperty")

fun <C> Iterable<KProperty<C>>.toColumnSet(): ColumnSet<C>

@JvmName(name = "toColumnSetColumnPath")

fun Iterable<ColumnPath>.toColumnSet(): ColumnSet<Any?>

@JvmName(name = "toColumnSetColumnReference")

fun <C> Iterable<ColumnReference<C>>.toColumnSet(): ColumnSet<C>

fun Iterable<ColumnsResolver<*>>.toColumnSet(): ColumnSet<Any?>

@JvmName(name = "toColumnSetC")

fun <C> Iterable<ColumnsResolver<C>>.toColumnSet(): ColumnSet<C>

toColumnsSetOf

fun <C> Iterable<String>.toColumnsSetOf(): ColumnSet<C>

toDataFrame

inline fun <reified T> Iterable<T>.toDataFrame(): DataFrame<T>

@JvmName(name = "toDataFrameMapStringAnyNullable")

fun Iterable<Map<String, Any?>>.toDataFrame(): DataFrame<*>

@JvmName(name = "toDataFrameT")

fun <T> Iterable<DataRow<T>>.toDataFrame(): DataFrame<T>

@JvmName(name = "toDataFrameAnyColumn")

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

inline fun <reified T> Iterable<T>.toDataFrame(noinline body: CreateDataFrameDsl<T>.() -> Unit): DataFrame<T>

inline fun <reified T> Iterable<T>.toDataFrame(columnName: String): DataFrame<*>

inline fun <reified T> Iterable<T>.toDataFrame(vararg props: KProperty<*>, maxDepth: Int = 0): DataFrame<T>

fun <T> List<List<T>>.~~toDataFrame~~(containsColumns: Boolean = false): AnyFrame

fun <T> List<List<T>>.toDataFrame(header: List<String>?, containsColumns: Boolean = false): DataFrame<*>

Converts a list of lists into a DataFrame.

toDataFrameFromPairs

fun Iterable<Pair<String, Iterable<Any?>>>.toDataFrameFromPairs(): DataFrame<*>

@JvmName(name = "toDataFrameColumnPathAnyNullable")

fun Iterable<Pair<ColumnPath, Iterable<Any?>>>.toDataFrameFromPairs(): DataFrame<*>

@JvmName(name = "toDataFramePairColumnPathAnyCol")

fun <T> Iterable<Pair<ColumnPath, BaseColumn<*>>>.toDataFrameFromPairs(): DataFrame<T>

toFrameColumn

fun <T> Iterable<DataFrame<T>>.toFrameColumn(name: String = ""): FrameColumn<T>

toFrameColumnAccessor

fun ColumnPath.toFrameColumnAccessor(): ColumnAccessor<DataFrame<*>>

toPath

fun Iterable<String>.toPath(): ColumnPath

toString

open override fun toString(): String

toValueColumn

inline fun <reified T> Iterable<T>.toValueColumn(name: String = ""): ValueColumn<T>

inline fun <reified T> Iterable<T>.~~toValueColumn~~(column: KProperty<T>): ValueColumn<T>

inline fun <reified T> Iterable<T>.toValueColumn(column: ColumnAccessor<T>): ValueColumn<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.

types

internal fun Iterable<Any?>.types(): Set<KType>

Returns a set of KType objects representing the star-projected types of the runtime classes of all unique elements in the iterable.

unaryMinus

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

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

unifiedNumberClassOrNull

internal fun Iterable<KClass<*>>.unifiedNumberClassOrNull(options: UnifiedNumberTypeOptions = UnifiedNumberTypeOptions.DEFAULT): KClass<*>?

Determines the nearest common numeric type, in terms of complexity, all types in this.

unifiedNumberTypeOrNull

internal fun Iterable<KType>.unifiedNumberTypeOrNull(options: UnifiedNumberTypeOptions = UnifiedNumberTypeOptions.DEFAULT): KType?

Determines the nearest common numeric type, in terms of complexity, all types in this.

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.

withMostSuperclasses

internal fun Iterable<KClass<*>>.withMostSuperclasses(): KClass<*>?

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>