core/org.jetbrains.kotlinx.dataframe.api/JoinDsl

JoinDsl

interface JoinDsl<out A, out B> : ColumnsSelectionDsl<A>

A specialized ColumnsSelectionDsl that allows specifying join matching columns with different names in left and right DataFrames.

JoinDsl allows you to define the columns used for joining DataFrames and provides methods to match columns with different names between the left and right side.

Provides the left DataFrame both as the receiver (this) and as the argument (it), allowing you to reference its columns directly. Use right to access columns from the right DataFrame, and match to explicitly pair columns with different names.

See also Columns selection via DSL.

For more information: See join on the documentation website.

Examples

// Join by two columns with the same names in both dataframes
dfLeft.join(dfRight) { name and city }

// Join by one column with different names —
// "firstName" in the left dataframe and "name" in the right one
dfLeft.join(dfRight) { left -> left.firstName match right.name }

// Match columns using String API
dfLeft.join(dfRight) { "symbol" match right.getValue<Char>("char") }
Content copied to clipboard

Types

Link copied to clipboard
object Companion

Properties

Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_count")
val ColumnsScope<ColumnDescription?>.count: DataColumn<Int?>
@get:JvmName(name = "ColumnDescription_count")
val ColumnsScope<ColumnDescription>.count: DataColumn<Int>
@get:JvmName(name = "NullableValueCount_count")
val ColumnsScope<ValueCount?>.count: DataColumn<Int?>
@get:JvmName(name = "ValueCount_count")
val ColumnsScope<ValueCount>.count: DataColumn<Int>
Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_freq")
val ColumnsScope<ColumnDescription?>.freq: DataColumn<Int?>
@get:JvmName(name = "ColumnDescription_freq")
val ColumnsScope<ColumnDescription>.freq: DataColumn<Int>
Link copied to clipboard
@get:JvmName(name = "NullableKeyValueProperty_key")
val ColumnsScope<KeyValueProperty<*>?>.key: DataColumn<String?>
@get:JvmName(name = "KeyValueProperty_key")
val ColumnsScope<KeyValueProperty<*>>.key: DataColumn<String>
Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_max")
val ColumnsScope<ColumnDescription?>.max: DataColumn<Any?>
@get:JvmName(name = "ColumnDescription_max")
val ColumnsScope<ColumnDescription>.max: DataColumn<Any>
Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_mean")
val ColumnsScope<ColumnDescription?>.mean: DataColumn<Double?>
@get:JvmName(name = "ColumnDescription_mean")
val ColumnsScope<ColumnDescription>.mean: DataColumn<Double>
Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_median")
val ColumnsScope<ColumnDescription?>.median: DataColumn<Any?>
@get:JvmName(name = "ColumnDescription_median")
val ColumnsScope<ColumnDescription>.median: DataColumn<Any>
Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_min")
val ColumnsScope<ColumnDescription?>.min: DataColumn<Any?>
@get:JvmName(name = "ColumnDescription_min")
val ColumnsScope<ColumnDescription>.min: DataColumn<Any>
Link copied to clipboard
@get:JvmName(name = "NameValuePairAny_name")
val ColumnsContainer<NameValuePair<*>>.name: DataColumn<String>
@get:JvmName(name = "NullableColumnDescription_name")
val ColumnsScope<ColumnDescription?>.name: DataColumn<String?>
@get:JvmName(name = "ColumnDescription_name")
val ColumnsScope<ColumnDescription>.name: DataColumn<String>
@get:JvmName(name = "NullableNameValuePair_name")
val <V> ColumnsScope<NameValuePair<V>?>.name: DataColumn<String?>
@get:JvmName(name = "NameValuePair_name")
val <V> ColumnsScope<NameValuePair<V>>.name: DataColumn<String>
@get:JvmName(name = "NullableNameValueProperty_name")
val <T> ColumnsScope<NameValueProperty<T>?>.name: DataColumn<String?>
@get:JvmName(name = "NameValueProperty_name")
val <T> ColumnsScope<NameValueProperty<T>>.name: DataColumn<String>

@get:JvmName(name = "NullableKeyValueProperty_name")
val ColumnsScope<KeyValueProperty<*>?>.name: DataColumn<String?>
@get:JvmName(name = "KeyValueProperty_name")
val ColumnsScope<KeyValueProperty<*>>.name: DataColumn<String>

Accesses the 'key' column of this KeyValueProperty ColumnsContainer.

Link copied to clipboard
internal val ColumnsContainer<*>.ncol: Int
Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_nulls")
val ColumnsScope<ColumnDescription?>.nulls: DataColumn<Int?>
@get:JvmName(name = "ColumnDescription_nulls")
val ColumnsScope<ColumnDescription>.nulls: DataColumn<Int>
Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_p25")
val ColumnsScope<ColumnDescription?>.p25: DataColumn<Any?>
@get:JvmName(name = "ColumnDescription_p25")
val ColumnsScope<ColumnDescription>.p25: DataColumn<Any>
Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_p75")
val ColumnsScope<ColumnDescription?>.p75: DataColumn<Any?>
@get:JvmName(name = "ColumnDescription_p75")
val ColumnsScope<ColumnDescription>.p75: DataColumn<Any>
Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_path")
val ColumnsScope<ColumnDescription?>.path: DataColumn<ColumnPath?>
@get:JvmName(name = "ColumnDescription_path")
val ColumnsScope<ColumnDescription>.path: DataColumn<ColumnPath>
Link copied to clipboard
abstract val right: DataFrame<B>

Provides access to columns of the right DataFrame for further matching with left columns match.

Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_std")
val ColumnsScope<ColumnDescription?>.std: DataColumn<Double?>
@get:JvmName(name = "ColumnDescription_std")
val ColumnsScope<ColumnDescription>.std: DataColumn<Double>
Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_top")
val ColumnsScope<ColumnDescription?>.top: DataColumn<Any?>
@get:JvmName(name = "ColumnDescription_top")
val ColumnsScope<ColumnDescription>.top: DataColumn<Any>
Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_type")
val ColumnsScope<ColumnDescription?>.type: DataColumn<String?>
@get:JvmName(name = "ColumnDescription_type")
val ColumnsScope<ColumnDescription>.type: DataColumn<String>
Link copied to clipboard
@get:JvmName(name = "NullableColumnDescription_unique")
val ColumnsScope<ColumnDescription?>.unique: DataColumn<Int?>
@get:JvmName(name = "ColumnDescription_unique")
val ColumnsScope<ColumnDescription>.unique: DataColumn<Int>
Link copied to clipboard
@get:JvmName(name = "NameValuePairAny_value")
val ColumnsContainer<NameValuePair<*>>.value: DataColumn<*>
@get:JvmName(name = "NullableKeyValueProperty_value")
val <T> ColumnsScope<KeyValueProperty<T>?>.value: DataColumn<T?>
@get:JvmName(name = "KeyValueProperty_value")
val <T> ColumnsScope<KeyValueProperty<T>>.value: DataColumn<T>
@get:JvmName(name = "NullableNameValuePair_value")
val <V> ColumnsScope<NameValuePair<V>?>.value: DataColumn<V?>
@get:JvmName(name = "NameValuePair_value")
val <V> ColumnsScope<NameValuePair<V>>.value: DataColumn<V>
@get:JvmName(name = "NullableNameValueProperty_value")
val <T> ColumnsScope<NameValueProperty<T>?>.value: DataColumn<T?>
@get:JvmName(name = "NameValueProperty_value")
val <T> ColumnsScope<NameValueProperty<T>>.value: DataColumn<T>
@get:JvmName(name = "NullableValueProperty_value")
val <T> ColumnsScope<ValueProperty<T>?>.value: DataColumn<T?>
@get:JvmName(name = "ValueProperty_value")
val <T> ColumnsScope<ValueProperty<T>>.value: DataColumn<T>

Functions

Link copied to clipboard
open fun ColumnsSelectionDsl<*>.all(): ColumnSet<*>

Creates a new ColumnSet that contains all columns from this, the opposite of none.

open fun <C> ColumnSet<C>.all(): ColumnSet<C>

Creates a new ColumnSet that contains all columns from this, the opposite of none.

Link copied to clipboard
open fun ColumnsSelectionDsl<*>.allAfter(column: String): ColumnSet<*>
open fun ColumnsSelectionDsl<*>.allAfter(column: KProperty<*>): ColumnSet<*>
open fun ColumnsSelectionDsl<*>.allAfter(column: ColumnPath): ColumnSet<*>
open fun ColumnsSelectionDsl<*>.allAfter(column: ColumnReference<*>): ColumnSet<*>
open fun <T> ColumnsSelectionDsl<T>.allAfter(column: ColumnSelector<T, *>): ColumnSet<*>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns after column, excluding column itself.

open fun <C> ColumnSet<C>.allAfter(column: (ColumnWithPath<C>) -> Boolean): ColumnSet<C>
open fun <C> ColumnSet<C>.allAfter(column: String): ColumnSet<C>
open fun <C> ColumnSet<C>.allAfter(column: KProperty<*>): ColumnSet<C>
open fun <C> ColumnSet<C>.allAfter(column: ColumnPath): ColumnSet<C>
open fun <C> ColumnSet<C>.allAfter(column: ColumnReference<*>): ColumnSet<C>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns after column, excluding column itself.

Link copied to clipboard
open fun ColumnsSelectionDsl<*>.allBefore(column: String): ColumnSet<*>
open fun ColumnsSelectionDsl<*>.allBefore(column: KProperty<*>): ColumnSet<*>
open fun ColumnsSelectionDsl<*>.allBefore(column: ColumnPath): ColumnSet<*>
open fun ColumnsSelectionDsl<*>.allBefore(column: ColumnReference<*>): ColumnSet<*>
open fun <T> ColumnsSelectionDsl<T>.allBefore(column: ColumnSelector<T, *>): ColumnSet<*>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns before column, excluding column itself.

open fun <C> ColumnSet<C>.allBefore(column: (ColumnWithPath<C>) -> Boolean): ColumnSet<C>
open fun <C> ColumnSet<C>.allBefore(column: String): ColumnSet<C>
open fun <C> ColumnSet<C>.allBefore(column: KProperty<*>): ColumnSet<C>
open fun <C> ColumnSet<C>.allBefore(column: ColumnPath): ColumnSet<C>
open fun <C> ColumnSet<C>.allBefore(column: ColumnReference<*>): ColumnSet<C>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns before column, excluding column itself.

Link copied to clipboard
open fun String.allCols(): ColumnSet<*>

Creates a new ColumnSet that contains all columns from this, the opposite of none.

open fun KProperty<*>.allCols(): ColumnSet<*>

Creates a new ColumnSet that contains all columns from this, the opposite of none.

open fun ColumnPath.allCols(): ColumnSet<*>

Creates a new ColumnSet that contains all columns from this, the opposite of none.

open fun SingleColumn<DataRow<*>>.allCols(): ColumnSet<*>

Creates a new ColumnSet that contains all columns from this, the opposite of none.

Link copied to clipboard
open fun String.allColsAfter(column: ColumnSelector<*, *>): ColumnSet<*>
open fun String.allColsAfter(column: String): ColumnSet<*>
open fun String.allColsAfter(column: KProperty<*>): ColumnSet<*>
open fun String.allColsAfter(column: ColumnPath): ColumnSet<*>
open fun String.allColsAfter(column: ColumnReference<*>): ColumnSet<*>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns after column, excluding column itself.

open fun KProperty<*>.allColsAfter(column: String): ColumnSet<*>
open fun KProperty<*>.allColsAfter(column: KProperty<*>): ColumnSet<*>
open fun KProperty<*>.allColsAfter(column: ColumnPath): ColumnSet<*>
open fun KProperty<*>.allColsAfter(column: ColumnReference<*>): ColumnSet<*>
open fun <C> KProperty<C>.allColsAfter(column: ColumnSelector<C, *>): ColumnSet<*>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns after column, excluding column itself.

open fun ColumnPath.allColsAfter(column: ColumnSelector<*, *>): ColumnSet<*>
open fun ColumnPath.allColsAfter(column: String): ColumnSet<*>
open fun ColumnPath.allColsAfter(column: KProperty<*>): ColumnSet<*>
open fun ColumnPath.allColsAfter(column: ColumnPath): ColumnSet<*>
open fun ColumnPath.allColsAfter(column: ColumnReference<*>): ColumnSet<*>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns after column, excluding column itself.

open fun SingleColumn<DataRow<*>>.allColsAfter(column: String): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.allColsAfter(column: KProperty<*>): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.allColsAfter(column: ColumnPath): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.allColsAfter(column: ColumnReference<*>): ColumnSet<*>
open fun <T> SingleColumn<DataRow<T>>.allColsAfter(column: ColumnSelector<T, *>): ColumnSet<*>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns after column, excluding column itself.

Link copied to clipboard
open fun String.allColsBefore(column: ColumnSelector<*, *>): ColumnSet<*>
open fun String.allColsBefore(column: String): ColumnSet<*>
open fun String.allColsBefore(column: KProperty<*>): ColumnSet<*>
open fun String.allColsBefore(column: ColumnPath): ColumnSet<*>
open fun String.allColsBefore(column: ColumnReference<*>): ColumnSet<*>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns before column, excluding column itself.

open fun KProperty<*>.allColsBefore(column: String): ColumnSet<*>
open fun KProperty<*>.allColsBefore(column: KProperty<*>): ColumnSet<*>
open fun KProperty<*>.allColsBefore(column: ColumnPath): ColumnSet<*>
open fun KProperty<*>.allColsBefore(column: ColumnReference<*>): ColumnSet<*>
open fun <C> KProperty<C>.allColsBefore(column: ColumnSelector<C, *>): ColumnSet<*>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns before column, excluding column itself.

open fun ColumnPath.allColsBefore(column: ColumnSelector<*, *>): ColumnSet<*>
open fun ColumnPath.allColsBefore(column: String): ColumnSet<*>
open fun ColumnPath.allColsBefore(column: KProperty<*>): ColumnSet<*>
open fun ColumnPath.allColsBefore(column: ColumnPath): ColumnSet<*>
open fun ColumnPath.allColsBefore(column: ColumnReference<*>): ColumnSet<*>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns before column, excluding column itself.

open fun SingleColumn<DataRow<*>>.allColsBefore(column: String): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.allColsBefore(column: KProperty<*>): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.allColsBefore(column: ColumnPath): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.allColsBefore(column: ColumnReference<*>): ColumnSet<*>
open fun <T> SingleColumn<DataRow<T>>.allColsBefore(column: ColumnSelector<T, *>): ColumnSet<*>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns before column, excluding column itself.

Link copied to clipboard
open fun String.allColsExcept(selector: ColumnsSelector<*, *>): ColumnSet<*>
open fun String.allColsExcept(vararg others: String): ColumnSet<*>
open fun String.allColsExcept(vararg others: KProperty<*>): ColumnSet<*>
open fun String.allColsExcept(vararg others: ColumnPath): ColumnSet<*>
open fun KProperty<*>.allColsExcept(vararg others: String): ColumnSet<*>
open fun KProperty<*>.allColsExcept(vararg others: KProperty<*>): ColumnSet<*>
open fun KProperty<*>.allColsExcept(vararg others: ColumnPath): ColumnSet<*>
open fun <C> KProperty<C>.allColsExcept(selector: ColumnsSelector<C, *>): ColumnSet<*>
open fun ColumnPath.allColsExcept(selector: ColumnsSelector<*, *>): ColumnSet<*>
open fun ColumnPath.allColsExcept(vararg others: String): ColumnSet<*>
open fun ColumnPath.allColsExcept(vararg others: KProperty<*>): ColumnSet<*>
open fun ColumnPath.allColsExcept(vararg others: ColumnPath): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.allColsExcept(vararg others: String): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.allColsExcept(vararg others: KProperty<*>): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.allColsExcept(vararg others: ColumnPath): ColumnSet<*>
open fun <C> SingleColumn<DataRow<C>>.allColsExcept(selector: ColumnsSelector<C, *>): ColumnSet<*>

Exclude a selection of columns from the current selection using the Columns Selection DSL.

open fun String.allColsExcept(other: ColumnsResolver<*>): ColumnSet<*>
open fun String.allColsExcept(vararg others: ColumnsResolver<*>): ColumnSet<*>
open fun KProperty<*>.allColsExcept(other: ColumnsResolver<*>): ColumnSet<*>
open fun KProperty<*>.allColsExcept(vararg others: ColumnsResolver<*>): ColumnSet<*>
open fun ColumnPath.allColsExcept(other: ColumnsResolver<*>): ColumnSet<*>
open fun ColumnPath.allColsExcept(vararg others: ColumnsResolver<*>): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.allColsExcept(other: ColumnsResolver<*>): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.allColsExcept(vararg others: ColumnsResolver<*>): ColumnSet<*>
Link copied to clipboard
open fun String.allColsFrom(column: ColumnSelector<*, *>): ColumnSet<*>
open fun String.allColsFrom(column: String): ColumnSet<*>
open fun String.allColsFrom(column: KProperty<*>): ColumnSet<*>
open fun String.allColsFrom(column: ColumnPath): ColumnSet<*>
open fun String.allColsFrom(column: ColumnReference<*>): ColumnSet<*>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns from column, including column itself.

open fun KProperty<*>.allColsFrom(column: String): ColumnSet<*>
open fun KProperty<*>.allColsFrom(column: KProperty<*>): ColumnSet<*>
open fun KProperty<*>.allColsFrom(column: ColumnPath): ColumnSet<*>
open fun KProperty<*>.allColsFrom(column: ColumnReference<*>): ColumnSet<*>
open fun <C> KProperty<C>.allColsFrom(column: ColumnSelector<C, *>): ColumnSet<*>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns from column, including column itself.

open fun ColumnPath.allColsFrom(column: ColumnSelector<*, *>): ColumnSet<*>
open fun ColumnPath.allColsFrom(column: String): ColumnSet<*>
open fun ColumnPath.allColsFrom(column: KProperty<*>): ColumnSet<*>
open fun ColumnPath.allColsFrom(column: ColumnPath): ColumnSet<*>
open fun ColumnPath.allColsFrom(column: ColumnReference<*>): ColumnSet<*>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns from column, including column itself.

open fun SingleColumn<DataRow<*>>.allColsFrom(column: String): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.allColsFrom(column: KProperty<*>): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.allColsFrom(column: ColumnPath): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.allColsFrom(column: ColumnReference<*>): ColumnSet<*>
open fun <T> SingleColumn<DataRow<T>>.allColsFrom(column: ColumnSelector<T, *>): ColumnSet<*>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns from column, including column itself.

Link copied to clipboard
open fun String.allColsUpTo(column: ColumnSelector<*, *>): ColumnSet<*>
open fun String.allColsUpTo(column: String): ColumnSet<*>
open fun String.allColsUpTo(column: KProperty<*>): ColumnSet<*>
open fun String.allColsUpTo(column: ColumnPath): ColumnSet<*>
open fun String.allColsUpTo(column: ColumnReference<*>): ColumnSet<*>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns up to column, including column itself.

open fun KProperty<*>.allColsUpTo(column: String): ColumnSet<*>
open fun KProperty<*>.allColsUpTo(column: KProperty<*>): ColumnSet<*>
open fun KProperty<*>.allColsUpTo(column: ColumnPath): ColumnSet<*>
open fun KProperty<*>.allColsUpTo(column: ColumnReference<*>): ColumnSet<*>
open fun <C> KProperty<C>.allColsUpTo(column: ColumnSelector<C, *>): ColumnSet<*>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns up to column, including column itself.

open fun ColumnPath.allColsUpTo(column: ColumnSelector<*, *>): ColumnSet<*>
open fun ColumnPath.allColsUpTo(column: String): ColumnSet<*>
open fun ColumnPath.allColsUpTo(column: KProperty<*>): ColumnSet<*>
open fun ColumnPath.allColsUpTo(column: ColumnPath): ColumnSet<*>
open fun ColumnPath.allColsUpTo(column: ColumnReference<*>): ColumnSet<*>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns up to column, including column itself.

open fun SingleColumn<DataRow<*>>.allColsUpTo(column: String): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.allColsUpTo(column: KProperty<*>): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.allColsUpTo(column: ColumnPath): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.allColsUpTo(column: ColumnReference<*>): ColumnSet<*>
open fun <T> SingleColumn<DataRow<T>>.allColsUpTo(column: ColumnSelector<T, *>): ColumnSet<*>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns up to column, including column itself.

Link copied to clipboard
open fun ColumnsSelectionDsl<*>.allExcept(vararg others: String): ColumnSet<*>
open fun ColumnsSelectionDsl<*>.allExcept(vararg others: KProperty<*>): ColumnSet<*>
open fun ColumnsSelectionDsl<*>.allExcept(vararg others: ColumnPath): ColumnSet<*>
open fun ColumnsSelectionDsl<*>.allExcept(vararg others: ColumnsResolver<*>): ColumnSet<*>
open fun <C> ColumnsSelectionDsl<C>.allExcept(selector: ColumnsSelector<C, *>): ColumnSet<*>

Exclude a selection of columns from the current selection using the Columns Selection DSL.

Link copied to clipboard
open fun ColumnsSelectionDsl<*>.allFrom(column: String): ColumnSet<*>
open fun ColumnsSelectionDsl<*>.allFrom(column: KProperty<*>): ColumnSet<*>
open fun ColumnsSelectionDsl<*>.allFrom(column: ColumnPath): ColumnSet<*>
open fun ColumnsSelectionDsl<*>.allFrom(column: ColumnReference<*>): ColumnSet<*>
open fun <T> ColumnsSelectionDsl<T>.allFrom(column: ColumnSelector<T, *>): ColumnSet<*>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns from column, including column itself.

open fun <C> ColumnSet<C>.allFrom(column: (ColumnWithPath<C>) -> Boolean): ColumnSet<C>
open fun <C> ColumnSet<C>.allFrom(column: String): ColumnSet<C>
open fun <C> ColumnSet<C>.allFrom(column: KProperty<*>): ColumnSet<C>
open fun <C> ColumnSet<C>.allFrom(column: ColumnPath): ColumnSet<C>
open fun <C> ColumnSet<C>.allFrom(column: ColumnReference<*>): ColumnSet<C>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns from column, including column itself.

Link copied to clipboard
open fun ColumnsSelectionDsl<*>.allUpTo(column: String): ColumnSet<*>
open fun ColumnsSelectionDsl<*>.allUpTo(column: KProperty<*>): ColumnSet<*>
open fun ColumnsSelectionDsl<*>.allUpTo(column: ColumnPath): ColumnSet<*>
open fun ColumnsSelectionDsl<*>.allUpTo(column: ColumnReference<*>): ColumnSet<*>
open fun <T> ColumnsSelectionDsl<T>.allUpTo(column: ColumnSelector<T, *>): ColumnSet<*>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns up to column, including column itself.

open fun <C> ColumnSet<C>.allUpTo(column: (ColumnWithPath<C>) -> Boolean): ColumnSet<C>
open fun <C> ColumnSet<C>.allUpTo(column: String): ColumnSet<C>
open fun <C> ColumnSet<C>.allUpTo(column: KProperty<*>): ColumnSet<C>
open fun <C> ColumnSet<C>.allUpTo(column: ColumnPath): ColumnSet<C>
open fun <C> ColumnSet<C>.allUpTo(column: ColumnReference<*>): ColumnSet<C>

Creates a new ColumnSet that contains a subset of columns from this, containing all columns up to column, including column itself.

Link copied to clipboard
open infix fun <C> String.and(other: () -> ColumnsResolver<C>): ColumnSet<*>
open infix fun String.and(other: String): ColumnSet<*>
open infix fun <C> String.and(other: KProperty<C>): ColumnSet<*>
open infix fun <C> String.and(other: ColumnsResolver<C>): ColumnSet<*>
open infix fun <C> KProperty<C>.and(other: () -> ColumnsResolver<C>): ColumnSet<C>
open infix fun <C> KProperty<C>.and(other: String): ColumnSet<*>
open infix fun <C> KProperty<C>.and(other: KProperty<C>): ColumnSet<C>
open infix fun <C> KProperty<C>.and(other: ColumnsResolver<C>): ColumnSet<C>
open infix fun <C> ColumnsResolver<C>.and(other: () -> ColumnsResolver<C>): ColumnSet<C>
open infix fun <C> ColumnsResolver<C>.and(other: String): ColumnSet<*>
open infix fun <C> ColumnsResolver<C>.and(other: KProperty<C>): ColumnSet<C>
open infix fun <C> ColumnsResolver<C>.and(other: ColumnsResolver<C>): ColumnSet<C>

The and operator allows you to combine selections of columns or simply select multiple columns at once.

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
@JvmName(name = "colUnTyped")
open fun col(name: String): ColumnAccessor<*>
open fun <C> col(name: String): ColumnAccessor<C>
open fun <C> col(property: KProperty<C>): SingleColumn<C>
open fun <C> col(col: ColumnAccessor<C>): ColumnAccessor<C>
@JvmName(name = "colUnTyped")
open fun col(path: ColumnPath): ColumnAccessor<*>
open fun <C> col(path: ColumnPath): ColumnAccessor<C>
@JvmName(name = "colUnTyped")
open fun String.col(index: Int): SingleColumn<*>
open fun <C> String.col(index: Int): SingleColumn<C>
@JvmName(name = "colUnTyped")
open fun String.col(name: String): ColumnAccessor<*>
open fun <C> String.col(name: String): ColumnAccessor<C>
open fun <C> String.col(property: KProperty<C>): ColumnAccessor<C>
open fun <C> String.col(col: ColumnAccessor<C>): ColumnAccessor<C>
@JvmName(name = "colUnTyped")
open fun String.col(path: ColumnPath): ColumnAccessor<*>
open fun <C> String.col(path: ColumnPath): ColumnAccessor<C>
@JvmName(name = "colUnTyped")
open fun KProperty<*>.col(index: Int): SingleColumn<*>
open fun <C> KProperty<*>.col(index: Int): SingleColumn<C>
@JvmName(name = "colUnTyped")
open fun KProperty<*>.col(name: String): ColumnAccessor<*>
open fun <C> KProperty<*>.col(name: String): ColumnAccessor<C>
open fun <C> KProperty<*>.col(property: KProperty<C>): ColumnAccessor<C>
open fun <C> KProperty<*>.col(col: ColumnAccessor<C>): ColumnAccessor<C>
@JvmName(name = "colUnTyped")
open fun KProperty<*>.col(path: ColumnPath): ColumnAccessor<*>
open fun <C> KProperty<*>.col(path: ColumnPath): ColumnAccessor<C>
@JvmName(name = "colUnTyped")
open fun ColumnsSelectionDsl<*>.col(index: Int): SingleColumn<*>
open fun <C> ColumnsSelectionDsl<*>.col(index: Int): SingleColumn<C>
@JvmName(name = "colUnTyped")
open fun ColumnAccessor<DataRow<*>>.col(name: String): ColumnAccessor<*>
open fun <C> ColumnAccessor<DataRow<*>>.col(name: String): ColumnAccessor<C>
open fun <C> ColumnAccessor<DataRow<*>>.col(property: KProperty<C>): ColumnAccessor<C>
open fun <C> ColumnAccessor<DataRow<*>>.col(col: ColumnAccessor<C>): ColumnAccessor<C>
@JvmName(name = "colUnTyped")
open fun ColumnAccessor<DataRow<*>>.col(path: ColumnPath): ColumnAccessor<*>
open fun <C> ColumnAccessor<DataRow<*>>.col(path: ColumnPath): ColumnAccessor<C>
@JvmName(name = "colUnTyped")
open fun ColumnPath.col(index: Int): SingleColumn<*>
open fun <C> ColumnPath.col(index: Int): SingleColumn<C>
@JvmName(name = "colUnTyped")
open fun ColumnPath.col(name: String): ColumnAccessor<*>
open fun <C> ColumnPath.col(name: String): ColumnAccessor<C>
open fun <C> ColumnPath.col(property: KProperty<C>): ColumnAccessor<C>
open fun <C> ColumnPath.col(col: ColumnAccessor<C>): ColumnAccessor<C>
@JvmName(name = "colUnTyped")
open fun ColumnPath.col(path: ColumnPath): ColumnAccessor<*>
open fun <C> ColumnPath.col(path: ColumnPath): ColumnAccessor<C>
open fun <C> ColumnSet<C>.col(index: Int): SingleColumn<C>
@JvmName(name = "colUnTyped")
open fun SingleColumn<DataRow<*>>.col(index: Int): SingleColumn<*>
open fun <C> SingleColumn<DataRow<*>>.col(index: Int): SingleColumn<C>
@JvmName(name = "colUnTyped")
open fun SingleColumn<DataRow<*>>.col(name: String): SingleColumn<*>
open fun <C> SingleColumn<DataRow<*>>.col(name: String): SingleColumn<C>
open fun <C> SingleColumn<DataRow<*>>.col(property: KProperty<C>): SingleColumn<C>
open fun <C> SingleColumn<DataRow<*>>.col(col: ColumnAccessor<C>): SingleColumn<C>
@JvmName(name = "colUnTyped")
open fun SingleColumn<DataRow<*>>.col(path: ColumnPath): SingleColumn<*>
open fun <C> SingleColumn<DataRow<*>>.col(path: ColumnPath): SingleColumn<C>

Creates a ColumnAccessor (or SingleColumn) for a column with the given argument which can be either an index (Int) or a reference to a column (String, ColumnPath, KProperty, or ColumnAccessor; any Access APIs).

Link copied to clipboard
@JvmName(name = "colGroupUnTyped")
open fun colGroup(name: String): ColumnAccessor<DataRow<*>>
open fun <C> colGroup(name: String): ColumnAccessor<DataRow<C>>
open fun <C> colGroup(property: KProperty<C>): SingleColumn<DataRow<C>>
@JvmName(name = "colGroupDataRowKProperty")
open fun <C> colGroup(property: KProperty<DataRow<C>>): SingleColumn<DataRow<C>>
open fun <C> colGroup(colGroup: ColumnAccessor<DataRow<C>>): ColumnAccessor<DataRow<C>>
@JvmName(name = "colGroupUnTyped")
open fun colGroup(path: ColumnPath): ColumnAccessor<DataRow<*>>
open fun <C> colGroup(path: ColumnPath): ColumnAccessor<DataRow<C>>
@JvmName(name = "colGroupUnTyped")
open fun String.colGroup(index: Int): SingleColumn<DataRow<*>>
open fun <C> String.colGroup(index: Int): SingleColumn<DataRow<C>>
@JvmName(name = "colGroupUnTyped")
open fun String.colGroup(name: String): ColumnAccessor<DataRow<*>>
open fun <C> String.colGroup(name: String): ColumnAccessor<DataRow<C>>
open fun <C> String.colGroup(property: KProperty<C>): ColumnAccessor<DataRow<C>>
@JvmName(name = "colGroupDataRowKProperty")
open fun <C> String.colGroup(property: KProperty<DataRow<C>>): ColumnAccessor<DataRow<C>>
open fun <C> String.colGroup(colGroup: ColumnAccessor<DataRow<C>>): ColumnAccessor<DataRow<C>>
@JvmName(name = "colGroupUnTyped")
open fun String.colGroup(path: ColumnPath): ColumnAccessor<DataRow<*>>
open fun <C> String.colGroup(path: ColumnPath): ColumnAccessor<DataRow<C>>
@JvmName(name = "colGroupUnTyped")
open fun KProperty<*>.colGroup(index: Int): SingleColumn<DataRow<*>>
open fun <C> KProperty<*>.colGroup(index: Int): SingleColumn<DataRow<C>>
@JvmName(name = "colGroupUnTyped")
open fun KProperty<*>.colGroup(name: String): ColumnAccessor<DataRow<*>>
open fun <C> KProperty<*>.colGroup(name: String): ColumnAccessor<DataRow<C>>
open fun <C> KProperty<*>.colGroup(property: KProperty<C>): ColumnAccessor<DataRow<C>>
@JvmName(name = "colGroupDataRowKProperty")
open fun <C> KProperty<*>.colGroup(property: KProperty<DataRow<C>>): ColumnAccessor<DataRow<C>>
open fun <C> KProperty<*>.colGroup(colGroup: ColumnAccessor<DataRow<C>>): ColumnAccessor<DataRow<C>>
@JvmName(name = "colGroupUnTyped")
open fun KProperty<*>.colGroup(path: ColumnPath): ColumnAccessor<DataRow<*>>
open fun <C> KProperty<*>.colGroup(path: ColumnPath): ColumnAccessor<DataRow<C>>
@JvmName(name = "colGroupUnTyped")
open fun ColumnsSelectionDsl<*>.colGroup(index: Int): SingleColumn<DataRow<*>>
open fun <C> ColumnsSelectionDsl<*>.colGroup(index: Int): SingleColumn<DataRow<C>>
@JvmName(name = "colGroupUnTyped")
open fun ColumnAccessor<DataRow<*>>.colGroup(name: String): ColumnAccessor<DataRow<*>>
open fun <C> ColumnAccessor<DataRow<*>>.colGroup(name: String): ColumnAccessor<DataRow<C>>
open fun <C> ColumnAccessor<DataRow<*>>.colGroup(property: KProperty<C>): ColumnAccessor<DataRow<C>>
@JvmName(name = "colGroupDataRowKProperty")
open fun <C> ColumnAccessor<DataRow<*>>.colGroup(property: KProperty<DataRow<C>>): ColumnAccessor<DataRow<C>>
open fun <C> ColumnAccessor<DataRow<*>>.colGroup(colGroup: ColumnAccessor<DataRow<C>>): ColumnAccessor<DataRow<C>>
@JvmName(name = "colGroupUnTyped")
open fun ColumnAccessor<DataRow<*>>.colGroup(path: ColumnPath): ColumnAccessor<DataRow<*>>
open fun <C> ColumnAccessor<DataRow<*>>.colGroup(path: ColumnPath): ColumnAccessor<DataRow<C>>
@JvmName(name = "colGroupUnTyped")
open fun ColumnPath.colGroup(index: Int): SingleColumn<DataRow<*>>
open fun <C> ColumnPath.colGroup(index: Int): SingleColumn<DataRow<C>>
@JvmName(name = "colGroupUnTyped")
open fun ColumnPath.colGroup(name: String): ColumnAccessor<DataRow<*>>
open fun <C> ColumnPath.colGroup(name: String): ColumnAccessor<DataRow<C>>
open fun <C> ColumnPath.colGroup(property: KProperty<C>): ColumnAccessor<DataRow<C>>
@JvmName(name = "colGroupDataRowKProperty")
open fun <C> ColumnPath.colGroup(property: KProperty<DataRow<C>>): ColumnAccessor<DataRow<C>>
open fun <C> ColumnPath.colGroup(colGroup: ColumnAccessor<DataRow<C>>): ColumnAccessor<DataRow<C>>
@JvmName(name = "colGroupUnTyped")
open fun ColumnPath.colGroup(path: ColumnPath): ColumnAccessor<DataRow<*>>
open fun <C> ColumnPath.colGroup(path: ColumnPath): ColumnAccessor<DataRow<C>>
open fun ColumnSet<*>.colGroup(index: Int): SingleColumn<DataRow<*>>
@JvmName(name = "ColumnSetDataRowColGroupIndex")
open fun <C> ColumnSet<DataRow<C>>.colGroup(index: Int): SingleColumn<DataRow<C>>
@JvmName(name = "colGroupUnTyped")
open fun SingleColumn<DataRow<*>>.colGroup(index: Int): SingleColumn<DataRow<*>>
open fun <C> SingleColumn<DataRow<*>>.colGroup(index: Int): SingleColumn<DataRow<C>>
@JvmName(name = "colGroupUnTyped")
open fun SingleColumn<DataRow<*>>.colGroup(name: String): SingleColumn<DataRow<*>>
open fun <C> SingleColumn<DataRow<*>>.colGroup(name: String): SingleColumn<DataRow<C>>
open fun <C> SingleColumn<DataRow<*>>.colGroup(property: KProperty<C>): SingleColumn<DataRow<C>>
@JvmName(name = "colGroupDataRowKProperty")
open fun <C> SingleColumn<DataRow<*>>.colGroup(property: KProperty<DataRow<C>>): SingleColumn<DataRow<C>>
open fun <C> SingleColumn<DataRow<*>>.colGroup(colGroup: ColumnAccessor<DataRow<C>>): SingleColumn<DataRow<C>>
@JvmName(name = "colGroupUnTyped")
open fun SingleColumn<DataRow<*>>.colGroup(path: ColumnPath): SingleColumn<DataRow<*>>
open fun <C> SingleColumn<DataRow<*>>.colGroup(path: ColumnPath): SingleColumn<DataRow<C>>

Creates a ColumnAccessor (or SingleColumn) for a column group with the given argument which can be either an index (Int) or a reference to a column (String, ColumnPath, KProperty, or ColumnAccessor; any Access APIs).

Link copied to clipboard
open fun String.colGroups(filter: Predicate<ColumnGroup<*>> = { true }): ColumnSet<DataRow<*>>

Creates a subset of columns from this that are ColumnGroups.

open fun KProperty<*>.colGroups(filter: Predicate<ColumnGroup<*>> = { true }): ColumnSet<DataRow<*>>

Creates a subset of columns from this that are ColumnGroups.

open fun ColumnsSelectionDsl<*>.colGroups(filter: Predicate<ColumnGroup<*>> = { true }): ColumnSet<DataRow<*>>

Creates a subset of columns from this that are ColumnGroups.

open fun ColumnPath.colGroups(filter: Predicate<ColumnGroup<*>> = { true }): ColumnSet<DataRow<*>>

Creates a subset of columns from this that are ColumnGroups.

open fun ColumnSet<*>.colGroups(filter: Predicate<ColumnGroup<*>> = { true }): ColumnSet<DataRow<*>>

Creates a subset of columns from this that are ColumnGroups.

open fun SingleColumn<DataRow<*>>.colGroups(filter: Predicate<ColumnGroup<*>> = { true }): ColumnSet<DataRow<*>>

Creates a subset of columns from this that are ColumnGroups.

Link copied to clipboard
open fun String.cols(): ColumnSet<*>
open fun ColumnsSelectionDsl<*>.cols(): ColumnSet<*>
open fun ColumnPath.cols(): ColumnSet<*>
open fun <C> ColumnSet<C>.cols(): ColumnSet<C>
open fun SingleColumn<DataRow<*>>.cols(): ColumnSet<*>

open fun String.cols(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>
@JvmName(name = "colsUnTyped")
open fun String.cols(firstCol: String, vararg otherCols: String): ColumnSet<*>
open fun <T> String.cols(firstCol: String, vararg otherCols: String): ColumnSet<T>
open fun <C> String.cols(firstCol: KProperty<C>, vararg otherCols: KProperty<C>): ColumnSet<C>
@JvmName(name = "colsUnTyped")
open fun String.cols(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<*>
open fun <T> String.cols(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<T>
open fun <C> String.cols(firstCol: ColumnReference<C>, vararg otherCols: ColumnReference<C>): ColumnSet<C>

Creates a subset of columns (ColumnSet) from this.

@JvmName(name = "colsUnTyped")
open fun String.cols(range: IntRange): ColumnSet<*>
open fun <T> String.cols(range: IntRange): ColumnSet<T>

Retrieves multiple columns from this in the form of a ColumnSet by a range of indices. If any of the indices in the range are out of bounds, an IndexOutOfBoundsException is thrown.

open fun KProperty<*>.cols(predicate: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>
@JvmName(name = "colsUnTyped")
open fun KProperty<*>.cols(firstCol: String, vararg otherCols: String): ColumnSet<*>
open fun <T> KProperty<*>.cols(firstCol: String, vararg otherCols: String): ColumnSet<T>
open fun <C> KProperty<*>.cols(firstCol: KProperty<C>, vararg otherCols: KProperty<C>): ColumnSet<C>
@JvmName(name = "colsUnTyped")
open fun KProperty<*>.cols(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<*>
open fun <T> KProperty<*>.cols(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<T>
open fun <C> KProperty<*>.cols(firstCol: ColumnReference<C>, vararg otherCols: ColumnReference<C>): ColumnSet<C>

Creates a subset of columns (ColumnSet) from this.

@JvmName(name = "colsUnTyped")
open fun KProperty<*>.cols(range: IntRange): ColumnSet<*>
open fun <T> KProperty<*>.cols(range: IntRange): ColumnSet<T>

Retrieves multiple columns from this in the form of a ColumnSet by a range of indices. If any of the indices in the range are out of bounds, an IndexOutOfBoundsException is thrown.

open fun ColumnsSelectionDsl<*>.cols(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>
@JvmName(name = "colsUnTyped")
open fun ColumnsSelectionDsl<*>.cols(firstCol: String, vararg otherCols: String): ColumnSet<*>
open fun <T> ColumnsSelectionDsl<*>.cols(firstCol: String, vararg otherCols: String): ColumnSet<T>
open fun <C> ColumnsSelectionDsl<*>.cols(firstCol: KProperty<C>, vararg otherCols: KProperty<C>): ColumnSet<C>
@JvmName(name = "colsUnTyped")
open fun ColumnsSelectionDsl<*>.cols(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<*>
open fun <T> ColumnsSelectionDsl<*>.cols(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<T>
open fun <C> ColumnsSelectionDsl<*>.cols(firstCol: ColumnReference<C>, vararg otherCols: ColumnReference<C>): ColumnSet<C>

Creates a subset of columns (ColumnSet) from this.

@JvmName(name = "colsUnTyped")
open fun ColumnsSelectionDsl<*>.cols(range: IntRange): ColumnSet<*>
open fun <T> ColumnsSelectionDsl<*>.cols(range: IntRange): ColumnSet<T>

Retrieves multiple columns from this in the form of a ColumnSet by a range of indices. If any of the indices in the range are out of bounds, an IndexOutOfBoundsException is thrown.

open fun ColumnPath.cols(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>
@JvmName(name = "colsUnTyped")
open fun ColumnPath.cols(firstCol: String, vararg otherCols: String): ColumnSet<*>
open fun <T> ColumnPath.cols(firstCol: String, vararg otherCols: String): ColumnSet<T>
open fun <C> ColumnPath.cols(firstCol: KProperty<C>, vararg otherCols: KProperty<C>): ColumnSet<C>
@JvmName(name = "colsUnTyped")
open fun ColumnPath.cols(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<*>
open fun <T> ColumnPath.cols(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<T>
open fun <C> ColumnPath.cols(firstCol: ColumnReference<C>, vararg otherCols: ColumnReference<C>): ColumnSet<C>

Creates a subset of columns (ColumnSet) from this.

@JvmName(name = "colsUnTyped")
open fun ColumnPath.cols(range: IntRange): ColumnSet<*>
open fun <T> ColumnPath.cols(range: IntRange): ColumnSet<T>

Retrieves multiple columns from this in the form of a ColumnSet by a range of indices. If any of the indices in the range are out of bounds, an IndexOutOfBoundsException is thrown.

open fun <C> ColumnSet<C>.cols(predicate: (ColumnWithPath<C>) -> Boolean): ColumnSet<C>

Creates a subset of columns (ColumnSet) from this.

open fun <C> ColumnSet<C>.cols(range: IntRange): ColumnSet<C>

Retrieves multiple columns from this in the form of a ColumnSet by a range of indices. If any of the indices in the range are out of bounds, an IndexOutOfBoundsException is thrown.

open fun SingleColumn<DataRow<*>>.cols(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>
@JvmName(name = "colsUnTyped")
open fun SingleColumn<DataRow<*>>.cols(firstCol: String, vararg otherCols: String): ColumnSet<*>
open fun <T> SingleColumn<DataRow<*>>.cols(firstCol: String, vararg otherCols: String): ColumnSet<T>
open fun <C> SingleColumn<DataRow<*>>.cols(firstCol: KProperty<C>, vararg otherCols: KProperty<C>): ColumnSet<C>
@JvmName(name = "colsUnTyped")
open fun SingleColumn<DataRow<*>>.cols(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<*>
open fun <T> SingleColumn<DataRow<*>>.cols(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<T>
open fun <C> SingleColumn<DataRow<*>>.cols(firstCol: ColumnReference<C>, vararg otherCols: ColumnReference<C>): ColumnSet<C>

Creates a subset of columns (ColumnSet) from this.

@JvmName(name = "colsUnTyped")
open fun SingleColumn<DataRow<*>>.cols(range: IntRange): ColumnSet<*>
open fun <T> SingleColumn<DataRow<*>>.cols(range: IntRange): ColumnSet<T>

Retrieves multiple columns from this in the form of a ColumnSet by a range of indices. If any of the indices in the range are out of bounds, an IndexOutOfBoundsException is thrown.

@JvmName(name = "colsUnTyped")
open fun String.cols(firstIndex: Int, vararg otherIndices: Int): ColumnSet<*>
open fun <T> String.cols(firstIndex: Int, vararg otherIndices: Int): ColumnSet<T>

Retrieves one or multiple columns from this in the form of a ColumnSet by their indices. If any of the indices are out of bounds, an IndexOutOfBoundsException is thrown.

@JvmName(name = "colsUnTyped")
open fun KProperty<*>.cols(firstIndex: Int, vararg otherIndices: Int): ColumnSet<*>
open fun <T> KProperty<*>.cols(firstIndex: Int, vararg otherIndices: Int): ColumnSet<T>

Retrieves one or multiple columns from this in the form of a ColumnSet by their indices. If any of the indices are out of bounds, an IndexOutOfBoundsException is thrown.

@JvmName(name = "colsUnTyped")
open fun ColumnsSelectionDsl<*>.cols(firstIndex: Int, vararg otherIndices: Int): ColumnSet<*>
open fun <T> ColumnsSelectionDsl<*>.cols(firstIndex: Int, vararg otherIndices: Int): ColumnSet<T>

Retrieves one or multiple columns from this in the form of a ColumnSet by their indices. If any of the indices are out of bounds, an IndexOutOfBoundsException is thrown.

@JvmName(name = "colsUnTyped")
open fun ColumnPath.cols(firstIndex: Int, vararg otherIndices: Int): ColumnSet<*>
open fun <T> ColumnPath.cols(firstIndex: Int, vararg otherIndices: Int): ColumnSet<T>

Retrieves one or multiple columns from this in the form of a ColumnSet by their indices. If any of the indices are out of bounds, an IndexOutOfBoundsException is thrown.

open fun <C> ColumnSet<C>.cols(firstIndex: Int, vararg otherIndices: Int): ColumnSet<C>

Retrieves one or multiple columns from this in the form of a ColumnSet by their indices. If any of the indices are out of bounds, an IndexOutOfBoundsException is thrown.

@JvmName(name = "colsUnTyped")
open fun SingleColumn<DataRow<*>>.cols(firstIndex: Int, vararg otherIndices: Int): ColumnSet<*>
open fun <T> SingleColumn<DataRow<*>>.cols(firstIndex: Int, vararg otherIndices: Int): ColumnSet<T>

Retrieves one or multiple columns from this in the form of a ColumnSet by their indices. If any of the indices are out of bounds, an IndexOutOfBoundsException is thrown.

Link copied to clipboard
open fun String.colsAtAnyDepth(): ColumnSet<*>
open fun String.colsAtAnyDepth(predicate: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>

Returns all columns in this at any depth (so also inside Column Groups)

open fun ColumnsSelectionDsl<*>.colsAtAnyDepth(): ColumnSet<*>
open fun ColumnsSelectionDsl<*>.colsAtAnyDepth(predicate: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>

Returns all columns in this at any depth (so also inside Column Groups)

open fun ColumnPath.colsAtAnyDepth(): ColumnSet<*>
open fun ColumnPath.colsAtAnyDepth(predicate: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>

Returns all columns in this at any depth (so also inside Column Groups)

open fun ColumnSet<*>.colsAtAnyDepth(): ColumnSet<*>
open fun ColumnSet<*>.colsAtAnyDepth(predicate: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>

Returns all columns in this at any depth (so also inside Column Groups)

open fun SingleColumn<DataRow<*>>.colsAtAnyDepth(): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.colsAtAnyDepth(predicate: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>

Returns all columns in this at any depth (so also inside Column Groups)

open fun KProperty<*>.colsAtAnyDepth(predicate: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>

Returns all columns in this at any depth (so also inside Column Groups)

Link copied to clipboard
open fun String.colsInGroups(): ColumnSet<*>
open fun String.colsInGroups(predicate: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>

colsInGroups is a function that returns all columns at the top-levels of all column groups in this. This is useful if you want to select all columns that are "one level deeper".

open fun ColumnsSelectionDsl<*>.colsInGroups(): ColumnSet<*>
open fun ColumnsSelectionDsl<*>.colsInGroups(predicate: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>

colsInGroups is a function that returns all columns at the top-levels of all column groups in this. This is useful if you want to select all columns that are "one level deeper".

open fun ColumnPath.colsInGroups(): ColumnSet<*>
open fun ColumnPath.colsInGroups(predicate: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>

colsInGroups is a function that returns all columns at the top-levels of all column groups in this. This is useful if you want to select all columns that are "one level deeper".

open fun ColumnSet<*>.colsInGroups(): ColumnSet<*>
open fun ColumnSet<*>.colsInGroups(predicate: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>

colsInGroups is a function that returns all columns at the top-levels of all column groups in this. This is useful if you want to select all columns that are "one level deeper".

open fun SingleColumn<DataRow<*>>.colsInGroups(): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.colsInGroups(predicate: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>

colsInGroups is a function that returns all columns at the top-levels of all column groups in this. This is useful if you want to select all columns that are "one level deeper".

open fun KProperty<*>.colsInGroups(predicate: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>

colsInGroups is a function that returns all columns at the top-levels of all column groups in this. This is useful if you want to select all columns that are "one level deeper".

Link copied to clipboard
open fun String.colsNameContains(regex: Regex): ColumnSet<*>

Returns a ColumnSet containing all columns from this having regex in their name.

open fun KProperty<*>.colsNameContains(regex: Regex): ColumnSet<*>

Returns a ColumnSet containing all columns from this having regex in their name.

open fun ColumnPath.colsNameContains(regex: Regex): ColumnSet<*>

Returns a ColumnSet containing all columns from this having regex in their name.

open fun SingleColumn<DataRow<*>>.colsNameContains(regex: Regex): ColumnSet<*>

Returns a ColumnSet containing all columns from this having regex in their name.

open fun String.colsNameContains(text: CharSequence, ignoreCase: Boolean = false): ColumnSet<*>

Returns a ColumnSet containing all columns from this having text in their name.

open fun KProperty<*>.colsNameContains(text: CharSequence, ignoreCase: Boolean = false): ColumnSet<*>

Returns a ColumnSet containing all columns from this having text in their name.

open fun ColumnPath.colsNameContains(text: CharSequence, ignoreCase: Boolean = false): ColumnSet<*>

Returns a ColumnSet containing all columns from this having text in their name.

open fun SingleColumn<DataRow<*>>.colsNameContains(text: CharSequence, ignoreCase: Boolean = false): ColumnSet<*>

Returns a ColumnSet containing all columns from this having text in their name.

Link copied to clipboard
open fun String.colsNameEndsWith(suffix: CharSequence, ignoreCase: Boolean = false): ColumnSet<*>

Returns a ColumnSet containing all columns from this ending with suffix in their name.

open fun KProperty<*>.colsNameEndsWith(suffix: CharSequence, ignoreCase: Boolean = false): ColumnSet<*>

Returns a ColumnSet containing all columns from this ending with suffix in their name.

open fun ColumnPath.colsNameEndsWith(suffix: CharSequence, ignoreCase: Boolean = false): ColumnSet<*>

Returns a ColumnSet containing all columns from this ending with suffix in their name.

open fun SingleColumn<DataRow<*>>.colsNameEndsWith(suffix: CharSequence, ignoreCase: Boolean = false): ColumnSet<*>

Returns a ColumnSet containing all columns from this ending with suffix in their name.

Link copied to clipboard
open fun String.colsNameStartsWith(prefix: CharSequence, ignoreCase: Boolean = false): ColumnSet<*>

Returns a ColumnSet containing all columns from this starting with prefix in their name.

open fun KProperty<*>.colsNameStartsWith(prefix: CharSequence, ignoreCase: Boolean = false): ColumnSet<*>

Returns a ColumnSet containing all columns from this starting with prefix in their name.

open fun ColumnPath.colsNameStartsWith(prefix: CharSequence, ignoreCase: Boolean = false): ColumnSet<*>

Returns a ColumnSet containing all columns from this starting with prefix in their name.

open fun SingleColumn<DataRow<*>>.colsNameStartsWith(prefix: CharSequence, ignoreCase: Boolean = false): ColumnSet<*>

Returns a ColumnSet containing all columns from this starting with prefix in their name.

Link copied to clipboard
open fun <C> String.colsOf(type: KType, filter: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<*>

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

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

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

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

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

Link copied to clipboard
inline fun <reified C> ColumnsSelectionDsl<*>.colsOf(noinline filter: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<C>
fun <C> ColumnsSelectionDsl<*>.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.

Link copied to clipboard
open fun String.colsOfKind(kind: ColumnKind, vararg others: ColumnKind, filter: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>

Creates a subset of columns from this that are of the given kind(s).

open fun KProperty<*>.colsOfKind(kind: ColumnKind, vararg others: ColumnKind, filter: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>

Creates a subset of columns from this that are of the given kind(s).

open fun ColumnsSelectionDsl<*>.colsOfKind(kind: ColumnKind, vararg others: ColumnKind, filter: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>

Creates a subset of columns from this that are of the given kind(s).

open fun ColumnPath.colsOfKind(kind: ColumnKind, vararg others: ColumnKind, filter: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>

Creates a subset of columns from this that are of the given kind(s).

open fun ColumnSet<*>.colsOfKind(kind: ColumnKind, vararg others: ColumnKind, filter: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>

Creates a subset of columns from this that are of the given kind(s).

open fun SingleColumn<DataRow<*>>.colsOfKind(kind: ColumnKind, vararg others: ColumnKind, filter: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>

Creates a subset of columns from this that are of the given kind(s).

Link copied to clipboard
open fun String.colsWithoutNulls(): ColumnSet<Any>

Returns a new ColumnSet that contains only columns in this that do not have null values.

open fun KProperty<*>.colsWithoutNulls(): ColumnSet<Any>

Returns a new ColumnSet that contains only columns in this that do not have null values.

open fun ColumnPath.colsWithoutNulls(): ColumnSet<Any>

Returns a new ColumnSet that contains only columns in this that do not have null values.

open fun SingleColumn<DataRow<*>>.colsWithoutNulls(): ColumnSet<Any>

Returns a new ColumnSet that contains only columns in this that do not have null values.

Link copied to clipboard
abstract fun columns(): List<DataColumn<*>>
Link copied to clipboard
abstract fun columnsCount(): Int
Link copied to clipboard
operator fun ColumnsContainer<*>.contains(column: KProperty<*>): Boolean
operator fun ColumnsContainer<*>.contains(column: ColumnReference<*>): Boolean
Link copied to clipboard
abstract fun containsColumn(name: String): Boolean
abstract fun containsColumn(path: ColumnPath): Boolean
Link copied to clipboard
Link copied to clipboard
open fun <C> ColumnSet<C>.distinct(): ColumnSet<C>

Returns a new ColumnSet from this ColumnSet containing only distinct columns (by path). This is useful when you've selected the same column multiple times but only want it once.

Link copied to clipboard
open fun ColumnsSelectionDsl<*>.drop(n: Int): ColumnSet<*>
open fun <C> ColumnSet<C>.drop(n: Int): ColumnSet<C>

This operation collects all columns from this except the first n into a ColumnSet.

Link copied to clipboard
open fun String.dropCols(n: Int): ColumnSet<*>
open fun KProperty<*>.dropCols(n: Int): ColumnSet<*>
open fun ColumnPath.dropCols(n: Int): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.dropCols(n: Int): ColumnSet<*>

This operation collects all columns from this except the first n into a ColumnSet.

Link copied to clipboard
open fun String.dropColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>
open fun KProperty<*>.dropColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>
open fun ColumnPath.dropColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.dropColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>

This operation drops the first columns from this while they adhere to the predicate, stops as soon as it encounters one that does not, and collects the remaining columns into a ColumnSet.

Link copied to clipboard
open fun ColumnsSelectionDsl<*>.dropLast(n: Int = 1): ColumnSet<*>
open fun <C> ColumnSet<C>.dropLast(n: Int = 1): ColumnSet<C>

This operation collects all columns from this except the last n into a ColumnSet.

Link copied to clipboard
open fun String.dropLastCols(n: Int): ColumnSet<*>
open fun KProperty<*>.dropLastCols(n: Int): ColumnSet<*>
open fun ColumnPath.dropLastCols(n: Int): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.dropLastCols(n: Int): ColumnSet<*>

This operation collects all columns from this except the last n into a ColumnSet.

Link copied to clipboard
open fun String.dropLastColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>
open fun KProperty<*>.dropLastColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>
open fun ColumnPath.dropLastColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.dropLastColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>

This operation drops the last columns from this while they adhere to the predicate, stops as soon as it encounters one that does not, and collects the remaining columns into a ColumnSet.

Link copied to clipboard
open fun ColumnsSelectionDsl<*>.dropLastWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>
open fun <C> ColumnSet<C>.dropLastWhile(predicate: (ColumnWithPath<C>) -> Boolean): ColumnSet<C>

This operation drops the last columns from this while they adhere to the predicate, stops as soon as it encounters one that does not, and collects the remaining columns into a ColumnSet.

Link copied to clipboard
open fun ColumnsSelectionDsl<*>.dropWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>
open fun <C> ColumnSet<C>.dropWhile(predicate: (ColumnWithPath<C>) -> Boolean): ColumnSet<C>

This operation drops the first columns from this while they adhere to the predicate, stops as soon as it encounters one that does not, and collects the remaining columns into a ColumnSet.

Link copied to clipboard
open fun String.except(selector: ColumnsSelector<*, *>): SingleColumn<DataRow<*>>
open fun String.except(vararg others: String): SingleColumn<DataRow<*>>
open fun String.except(vararg others: KProperty<*>): SingleColumn<DataRow<*>>
open fun String.except(vararg others: ColumnPath): SingleColumn<DataRow<*>>
open fun <C> KProperty<C>.except(selector: ColumnsSelector<C, *>): SingleColumn<DataRow<C>>
open fun <C> KProperty<C>.except(vararg others: String): SingleColumn<DataRow<C>>
open fun <C> KProperty<C>.except(vararg others: KProperty<*>): SingleColumn<DataRow<C>>
open fun <C> KProperty<C>.except(vararg others: ColumnPath): SingleColumn<DataRow<C>>
@JvmName(name = "KPropertyDataRowExceptNew")
open fun <C> KProperty<DataRow<C>>.except(vararg others: String): SingleColumn<DataRow<C>>
@JvmName(name = "KPropertyDataRowExceptNew")
open fun <C> KProperty<DataRow<C>>.except(vararg others: KProperty<*>): SingleColumn<DataRow<C>>
@JvmName(name = "KPropertyDataRowExceptNew")
open fun <C> KProperty<DataRow<C>>.except(vararg others: ColumnPath): SingleColumn<DataRow<C>>
open fun ColumnPath.except(selector: ColumnsSelector<*, *>): SingleColumn<DataRow<*>>
open fun ColumnPath.except(vararg others: String): SingleColumn<DataRow<*>>
open fun ColumnPath.except(vararg others: KProperty<*>): SingleColumn<DataRow<*>>
open fun ColumnPath.except(vararg others: ColumnPath): SingleColumn<DataRow<*>>
open infix fun <C> ColumnSet<C>.except(selector: () -> ColumnsResolver<*>): ColumnSet<C>
open infix fun <C> ColumnSet<C>.except(other: String): ColumnSet<C>
open infix fun <C> ColumnSet<C>.except(other: KProperty<C>): ColumnSet<C>
open infix fun <C> ColumnSet<C>.except(other: ColumnPath): ColumnSet<C>
open infix fun <C> ColumnSet<C>.except(other: ColumnsResolver<*>): ColumnSet<C>
open fun <C> ColumnSet<C>.except(vararg others: String): ColumnSet<C>
open fun <C> ColumnSet<C>.except(vararg others: KProperty<C>): ColumnSet<C>
open fun <C> ColumnSet<C>.except(vararg others: ColumnPath): ColumnSet<C>
open fun <C> ColumnSet<C>.except(vararg others: ColumnsResolver<*>): ColumnSet<C>
open fun <C> SingleColumn<DataRow<C>>.except(selector: ColumnsSelector<C, *>): SingleColumn<DataRow<C>>
open fun <C> SingleColumn<DataRow<C>>.except(vararg others: String): SingleColumn<DataRow<C>>
open fun <C> SingleColumn<DataRow<C>>.except(vararg others: KProperty<*>): SingleColumn<DataRow<C>>
open fun <C> SingleColumn<DataRow<C>>.except(vararg others: ColumnPath): SingleColumn<DataRow<C>>

Exclude a selection of columns from the current selection using the Columns Selection DSL.

open fun String.except(other: ColumnsResolver<*>): SingleColumn<DataRow<*>>
open fun String.except(vararg others: ColumnsResolver<*>): SingleColumn<DataRow<*>>
open fun KProperty<*>.except(other: ColumnsResolver<*>): SingleColumn<DataRow<*>>
open fun KProperty<*>.except(vararg others: ColumnsResolver<*>): SingleColumn<DataRow<*>>
open fun ColumnPath.except(other: ColumnsResolver<*>): SingleColumn<DataRow<*>>
open fun ColumnPath.except(vararg others: ColumnsResolver<*>): SingleColumn<DataRow<*>>
open fun <C> SingleColumn<DataRow<C>>.except(vararg others: ColumnsResolver<*>): SingleColumn<DataRow<C>>
Link copied to clipboard
inline fun <T, reified R> ColumnsSelectionDsl<T>.expr(name: String = "", infer: Infer = Infer.Nulls, noinline expression: AddExpression<T, R>): DataColumn<R>

Creates a temporary new column by defining an expression to fill up each row.

Link copied to clipboard
open fun <C> ColumnSet<C>.filter(predicate: (ColumnWithPath<C>) -> Boolean): ColumnSet<C>

Creates a subset of columns (ColumnSet) from the current ColumnSet that adhere to the given predicate.

Link copied to clipboard
open fun ColumnsSelectionDsl<*>.first(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*>

Returns the first column from this that adheres to the optional given condition. If no column adheres to the given condition, NoSuchElementException is thrown.

open fun <C> ColumnSet<C>.first(condition: (ColumnWithPath<C>) -> Boolean = { true }): SingleColumn<C>

Returns the first column from this that adheres to the optional given condition. If no column adheres to the given condition, NoSuchElementException is thrown.

Link copied to clipboard
open fun String.firstCol(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*>

Returns the first column from this that adheres to the optional given condition. If no column adheres to the given condition, NoSuchElementException is thrown.

open fun KProperty<*>.firstCol(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*>

Returns the first column from this that adheres to the optional given condition. If no column adheres to the given condition, NoSuchElementException is thrown.

open fun ColumnPath.firstCol(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*>

Returns the first column from this that adheres to the optional given condition. If no column adheres to the given condition, NoSuchElementException is thrown.

open fun SingleColumn<DataRow<*>>.firstCol(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*>

Returns the first column from this that adheres to the optional given condition. If no column adheres to the given condition, NoSuchElementException is thrown.

Link copied to clipboard
@JvmName(name = "frameColUnTyped")
open fun frameCol(name: String): ColumnAccessor<DataFrame<*>>
open fun <C> frameCol(name: String): ColumnAccessor<DataFrame<C>>
open fun <C> frameCol(property: KProperty<List<C>>): SingleColumn<DataFrame<C>>
@JvmName(name = "frameColDataFrameKProperty")
open fun <C> frameCol(property: KProperty<DataFrame<C>>): SingleColumn<DataFrame<C>>
open fun <C> frameCol(frameCol: ColumnAccessor<DataFrame<C>>): ColumnAccessor<DataFrame<C>>
@JvmName(name = "frameColUnTyped")
open fun frameCol(path: ColumnPath): ColumnAccessor<DataFrame<*>>
open fun <C> frameCol(path: ColumnPath): ColumnAccessor<DataFrame<C>>
@JvmName(name = "frameColUnTyped")
open fun String.frameCol(index: Int): SingleColumn<DataFrame<*>>
open fun <C> String.frameCol(index: Int): SingleColumn<DataFrame<C>>
@JvmName(name = "frameColUnTyped")
open fun String.frameCol(name: String): ColumnAccessor<DataFrame<*>>
open fun <C> String.frameCol(name: String): ColumnAccessor<DataFrame<C>>
open fun <C> String.frameCol(property: KProperty<List<C>>): ColumnAccessor<DataFrame<C>>
@JvmName(name = "frameColDataFrameKProperty")
open fun <C> String.frameCol(property: KProperty<DataFrame<C>>): ColumnAccessor<DataFrame<C>>
open fun <C> String.frameCol(frameCol: ColumnAccessor<DataFrame<C>>): ColumnAccessor<DataFrame<C>>
@JvmName(name = "frameColUnTyped")
open fun String.frameCol(path: ColumnPath): ColumnAccessor<DataFrame<*>>
open fun <C> String.frameCol(path: ColumnPath): ColumnAccessor<DataFrame<C>>
@JvmName(name = "frameColUnTyped")
open fun KProperty<*>.frameCol(index: Int): SingleColumn<DataFrame<*>>
open fun <C> KProperty<*>.frameCol(index: Int): SingleColumn<DataFrame<C>>
@JvmName(name = "frameColUnTyped")
open fun KProperty<*>.frameCol(name: String): ColumnAccessor<DataFrame<*>>
open fun <C> KProperty<*>.frameCol(name: String): ColumnAccessor<DataFrame<C>>
open fun <C> KProperty<*>.frameCol(property: KProperty<List<C>>): ColumnAccessor<DataFrame<C>>
@JvmName(name = "frameColDataFrameKProperty")
open fun <C> KProperty<*>.frameCol(property: KProperty<DataFrame<C>>): ColumnAccessor<DataFrame<C>>
open fun <C> KProperty<*>.frameCol(frameCol: ColumnAccessor<DataFrame<C>>): ColumnAccessor<DataFrame<C>>
@JvmName(name = "frameColUnTyped")
open fun KProperty<*>.frameCol(path: ColumnPath): ColumnAccessor<DataFrame<*>>
open fun <C> KProperty<*>.frameCol(path: ColumnPath): ColumnAccessor<DataFrame<C>>
@JvmName(name = "frameColUnTyped")
open fun ColumnsSelectionDsl<*>.frameCol(index: Int): SingleColumn<DataFrame<*>>
open fun <C> ColumnsSelectionDsl<*>.frameCol(index: Int): SingleColumn<DataFrame<C>>
@JvmName(name = "frameColUnTyped")
open fun ColumnAccessor<DataRow<*>>.frameCol(name: String): ColumnAccessor<DataFrame<*>>
open fun <C> ColumnAccessor<DataRow<*>>.frameCol(name: String): ColumnAccessor<DataFrame<C>>
open fun <C> ColumnAccessor<DataRow<*>>.frameCol(property: KProperty<List<C>>): ColumnAccessor<DataFrame<C>>
@JvmName(name = "frameColDataFrameKProperty")
open fun <C> ColumnAccessor<DataRow<*>>.frameCol(property: KProperty<DataFrame<C>>): ColumnAccessor<DataFrame<C>>
open fun <C> ColumnAccessor<DataRow<*>>.frameCol(frameCol: ColumnAccessor<DataFrame<C>>): ColumnAccessor<DataFrame<C>>
@JvmName(name = "frameColUnTyped")
open fun ColumnAccessor<DataRow<*>>.frameCol(path: ColumnPath): ColumnAccessor<DataFrame<*>>
open fun <C> ColumnAccessor<DataRow<*>>.frameCol(path: ColumnPath): ColumnAccessor<DataFrame<C>>
@JvmName(name = "frameColUnTyped")
open fun ColumnPath.frameCol(index: Int): SingleColumn<DataFrame<*>>
open fun <C> ColumnPath.frameCol(index: Int): SingleColumn<DataFrame<C>>
@JvmName(name = "frameColUnTyped")
open fun ColumnPath.frameCol(name: String): ColumnAccessor<DataFrame<*>>
open fun <C> ColumnPath.frameCol(name: String): ColumnAccessor<DataFrame<C>>
open fun <C> ColumnPath.frameCol(property: KProperty<List<C>>): ColumnAccessor<DataFrame<C>>
@JvmName(name = "frameColDataFrameKProperty")
open fun <C> ColumnPath.frameCol(property: KProperty<DataFrame<C>>): ColumnAccessor<DataFrame<C>>
open fun <C> ColumnPath.frameCol(frameCol: ColumnAccessor<DataFrame<C>>): ColumnAccessor<DataFrame<C>>
@JvmName(name = "frameColUnTyped")
open fun ColumnPath.frameCol(path: ColumnPath): ColumnAccessor<DataFrame<*>>
open fun <C> ColumnPath.frameCol(path: ColumnPath): ColumnAccessor<DataFrame<C>>
open fun ColumnSet<*>.frameCol(index: Int): SingleColumn<DataFrame<*>>
@JvmName(name = "ColumnSetDataFrameFrameColIndex")
open fun <C> ColumnSet<DataFrame<C>>.frameCol(index: Int): SingleColumn<DataFrame<C>>
@JvmName(name = "frameColUnTyped")
open fun SingleColumn<DataRow<*>>.frameCol(index: Int): SingleColumn<DataFrame<*>>
open fun <C> SingleColumn<DataRow<*>>.frameCol(index: Int): SingleColumn<DataFrame<C>>
@JvmName(name = "frameColUnTyped")
open fun SingleColumn<DataRow<*>>.frameCol(name: String): SingleColumn<DataFrame<*>>
open fun <C> SingleColumn<DataRow<*>>.frameCol(name: String): SingleColumn<DataFrame<C>>
open fun <C> SingleColumn<DataRow<*>>.frameCol(property: KProperty<List<C>>): SingleColumn<DataFrame<C>>
@JvmName(name = "frameColDataFrameKProperty")
open fun <C> SingleColumn<DataRow<*>>.frameCol(property: KProperty<DataFrame<C>>): SingleColumn<DataFrame<C>>
open fun <C> SingleColumn<DataRow<*>>.frameCol(frameCol: ColumnAccessor<DataFrame<C>>): SingleColumn<DataFrame<C>>
@JvmName(name = "frameColUnTyped")
open fun SingleColumn<DataRow<*>>.frameCol(path: ColumnPath): SingleColumn<DataFrame<*>>
open fun <C> SingleColumn<DataRow<*>>.frameCol(path: ColumnPath): SingleColumn<DataFrame<C>>

Creates a ColumnAccessor (or SingleColumn) for a frame column with the given argument which can be either an index (Int) or a reference to a column (String, ColumnPath, KProperty, or ColumnAccessor; any Access APIs).

Link copied to clipboard
open fun String.frameCols(filter: Predicate<FrameColumn<*>> = { true }): ColumnSet<DataFrame<*>>

Creates a subset of columns from this that are FrameColumns.

open fun KProperty<*>.frameCols(filter: Predicate<FrameColumn<*>> = { true }): ColumnSet<DataFrame<*>>

Creates a subset of columns from this that are FrameColumns.

open fun ColumnsSelectionDsl<*>.frameCols(filter: Predicate<FrameColumn<*>> = { true }): ColumnSet<DataFrame<*>>

Creates a subset of columns from this that are FrameColumns.

open fun ColumnPath.frameCols(filter: Predicate<FrameColumn<*>> = { true }): ColumnSet<DataFrame<*>>

Creates a subset of columns from this that are FrameColumns.

open fun ColumnSet<*>.frameCols(filter: Predicate<FrameColumn<*>> = { true }): ColumnSet<DataFrame<*>>

Creates a subset of columns from this that are FrameColumns.

open fun SingleColumn<DataRow<*>>.frameCols(filter: Predicate<FrameColumn<*>> = { true }): ColumnSet<DataFrame<*>>

Creates a subset of columns from this that are FrameColumns.

Link copied to clipboard
abstract fun <C> get(columns: ColumnsSelector<A, C>): List<DataColumn<C>>
open fun <C> get(column: ColumnSelector<A, C>): DataColumn<C>
open operator override fun get(columnName: String): DataColumn<*>
open operator fun <R> get(column: KProperty<R>): DataColumn<R>
open operator fun <R> get(column: KProperty<DataFrame<R>>): FrameColumn<R>
open operator fun <R> get(column: KProperty<DataRow<R>>): ColumnGroup<R>
open operator fun <R> get(column: DataColumn<R>): DataColumn<R>
open operator fun <R> get(column: DataColumn<DataFrame<R>>): FrameColumn<R>
open operator fun <R> get(column: DataColumn<DataRow<R>>): ColumnGroup<R>
open operator fun get(columnPath: ColumnPath): DataColumn<*>
open operator fun <R> get(column: ColumnReference<R>): DataColumn<R>
open operator fun <R> get(column: ColumnReference<DataFrame<R>>): FrameColumn<R>
open operator fun <R> get(column: ColumnReference<DataRow<R>>): ColumnGroup<R>

open operator fun <C> ColumnSet<C>.get(index: Int): SingleColumn<C>

Creates a ColumnAccessor (or SingleColumn) for a column with the given argument which can be either an index (Int) or a reference to a column (String, ColumnPath, KProperty, or ColumnAccessor; any Access APIs).

open operator fun String.get(predicate: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>
open operator fun String.get(firstCol: String, vararg otherCols: String): ColumnSet<*>
open operator fun <C> String.get(firstCol: KProperty<C>, vararg otherCols: KProperty<C>): ColumnSet<C>
open operator fun String.get(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<*>
open operator fun <C> String.get(firstCol: ColumnReference<C>, vararg otherCols: ColumnReference<C>): ColumnSet<C>

Creates a subset of columns (ColumnSet) from this.

open operator fun KProperty<*>.get(predicate: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>
open operator fun KProperty<*>.get(firstCol: String, vararg otherCols: String): ColumnSet<*>
open operator fun <C> KProperty<*>.get(firstCol: KProperty<C>, vararg otherCols: KProperty<C>): ColumnSet<C>
open operator fun KProperty<*>.get(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<*>
open operator fun <C> KProperty<*>.get(firstCol: ColumnReference<C>, vararg otherCols: ColumnReference<C>): ColumnSet<C>

Creates a subset of columns (ColumnSet) from this.

open operator fun ColumnsSelectionDsl<*>.get(predicate: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>
open operator fun ColumnsSelectionDsl<*>.get(firstCol: String, vararg otherCols: String): ColumnSet<*>
open operator fun <C> ColumnsSelectionDsl<*>.get(firstCol: KProperty<C>, vararg otherCols: KProperty<C>): ColumnSet<C>
open operator fun ColumnsSelectionDsl<*>.get(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<*>
open operator fun <C> ColumnsSelectionDsl<*>.get(firstCol: ColumnReference<C>, vararg otherCols: ColumnReference<C>): ColumnSet<C>

Creates a subset of columns (ColumnSet) from this.

open operator fun ColumnPath.get(predicate: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>
open operator fun ColumnPath.get(firstCol: String, vararg otherCols: String): ColumnSet<*>
open operator fun <C> ColumnPath.get(firstCol: KProperty<C>, vararg otherCols: KProperty<C>): ColumnSet<C>
open operator fun ColumnPath.get(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<*>
open operator fun <C> ColumnPath.get(firstCol: ColumnReference<C>, vararg otherCols: ColumnReference<C>): ColumnSet<C>

Creates a subset of columns (ColumnSet) from this.

open operator fun <C> ColumnSet<C>.get(predicate: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<C>

Creates a subset of columns (ColumnSet) from this.

open operator fun <C> ColumnSet<C>.get(range: IntRange): ColumnSet<C>

Retrieves multiple columns from this in the form of a ColumnSet by a range of indices. If any of the indices in the range are out of bounds, an IndexOutOfBoundsException is thrown.

open operator fun SingleColumn<DataRow<*>>.get(predicate: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*>
open operator fun SingleColumn<DataRow<*>>.get(firstCol: String, vararg otherCols: String): ColumnSet<*>
open operator fun <C> SingleColumn<DataRow<*>>.get(firstCol: KProperty<C>, vararg otherCols: KProperty<C>): ColumnSet<C>
open operator fun SingleColumn<DataRow<*>>.get(firstCol: ColumnPath, vararg otherCols: ColumnPath): ColumnSet<*>
open operator fun <C> SingleColumn<DataRow<*>>.get(firstCol: ColumnReference<C>, vararg otherCols: ColumnReference<C>): ColumnSet<C>

Creates a subset of columns (ColumnSet) from this.

open operator fun <C> ColumnSet<C>.get(firstIndex: Int, vararg otherIndices: Int): ColumnSet<C>

Retrieves one or multiple columns from this in the form of a ColumnSet by their indices. If any of the indices are out of bounds, an IndexOutOfBoundsException is thrown.

open operator fun String.get(column: String): ColumnPath

Creates a ColumnPath from the receiver and the given column name column. This is a shorthand for pathOf("myColumnName", "myNestedColumnName") and is often used in combination with ColumnPath.invoke to retrieve the value of a nested column. For instance:

open operator fun <T, R> KProperty<T>.get(column: KProperty<R>): DataColumn<R>
open operator fun <T, R> KProperty<T>.get(column: KProperty<DataFrame<R>>): FrameColumn<R>
open operator fun <T, R> KProperty<T>.get(column: KProperty<DataRow<R>>): ColumnGroup<R>
@JvmName(name = "KPropertyDataRowGet")
open operator fun <T, R> KProperty<DataRow<T>>.get(column: KProperty<R>): DataColumn<R>
@JvmName(name = "KPropertyDataRowGet")
open operator fun <T, R> KProperty<DataRow<T>>.get(column: KProperty<DataFrame<R>>): FrameColumn<R>
@JvmName(name = "KPropertyDataRowGet")
open operator fun <T, R> KProperty<DataRow<T>>.get(column: KProperty<DataRow<R>>): ColumnGroup<R>

Retrieves the value of this KProperty Accessor from the DataFrame.

open operator fun ColumnPath.get(column: String): ColumnPath

As extension to "myColumn"["myNestedColumn"], this function enables "myColumn"["myNestedColumn"]["myDoublyNestedColumn"] as alternative to pathOf("myColumn", "myNestedColumn", "myDoublyNestedColumn")

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
abstract fun getColumnIndex(name: String): Int
Link copied to clipboard
abstract fun <R> getColumnOrNull(column: ColumnSelector<A, R>): DataColumn<R>?
abstract fun getColumnOrNull(index: Int): DataColumn<*>?
abstract fun getColumnOrNull(name: String): DataColumn<*>?
abstract fun <R> getColumnOrNull(column: KProperty<R>): DataColumn<R>?
abstract fun getColumnOrNull(path: ColumnPath): DataColumn<*>?
abstract fun <R> getColumnOrNull(column: ColumnReference<R>): DataColumn<R>?
Link copied to clipboard
Link copied to clipboard
open infix fun String.into(newName: String): ColumnReference<*>
open infix fun String.into(nameOf: KProperty<*>): ColumnReference<*>
open infix fun String.into(nameOf: ColumnReference<*>): ColumnReference<*>
open infix fun <C> KProperty<C>.into(newName: String): ColumnReference<C>
open infix fun <C> KProperty<C>.into(nameOf: KProperty<*>): ColumnReference<C>
open infix fun <C> KProperty<C>.into(nameOf: ColumnReference<*>): ColumnReference<C>
open infix fun <C> ColumnReference<C>.into(newName: String): ColumnReference<C>
open infix fun <C> ColumnReference<C>.into(nameOf: KProperty<*>): ColumnReference<C>
open infix fun <C> ColumnReference<C>.into(nameOf: ColumnReference<*>): ColumnReference<C>
open infix fun <C> SingleColumn<C>.into(newName: String): SingleColumn<C>

Renaming a column in the ColumnsSelectionDsl is done by calling the infix functions named or into. They behave exactly the same, so it's up to contextual preference which one to use. Any combination of Access APIs can be used to specify the column to rename and which name should be used instead.

Link copied to clipboard
@JvmName(name = "stringInvokeTyped")
open operator fun <C> String.invoke(): DataColumn<C>

Retrieves the value of the column with this name from the DataFrame. This can be both typed and untyped. This is a shorthand for get("myColumnName") and can be written as "myColumnName"<MyColumnType>() instead.

@JvmName(name = "stringInvokeUntyped")
open operator fun String.invoke(): DataColumn<*>

Retrieves the value of the column with this name from the DataFrame. This can be both typed and untyped. This is a shorthand for get("myColumnName") and can be written as "myColumnName"() instead.

open operator fun <T> KProperty<T>.invoke(): DataColumn<T>
open operator fun <T> KProperty<DataFrame<T>>.invoke(): FrameColumn<T>
open operator fun <T> KProperty<DataRow<T>>.invoke(): ColumnGroup<T>

Retrieves the value of this KProperty Accessor from the DataFrame.

open operator fun <C> ColumnPath.invoke(): DataColumn<C>

Retrieves the value of this ColumnPath from the DataFrame. This is a shorthand for getColumn(myColumnPath) and is most often used in combination with operator fun String.get(column: String), for instance:

open operator fun <C> ColumnReference<C>.invoke(): DataColumn<C>
open operator fun <T> ColumnReference<DataFrame<T>>.invoke(): FrameColumn<T>
open operator fun <T> ColumnReference<DataRow<T>>.invoke(): ColumnGroup<T>

Retrieves the value of this ColumnReference or -Accessor from the DataFrame.

open operator fun <C> ColumnsSelector<A, C>.invoke(): ColumnsResolver<C>

Invokes the given ColumnsSelector using this ColumnsSelectionDsl.

open operator fun <R> String.invoke(selector: ColumnsSelector<*, R>): ColumnSet<R>
open operator fun <C, R> KProperty<C>.invoke(selector: ColumnsSelector<C, R>): ColumnSet<R>
open operator fun <R> ColumnPath.invoke(selector: ColumnsSelector<*, R>): ColumnSet<R>
open operator fun <C, R> SingleColumn<DataRow<C>>.invoke(selector: ColumnsSelector<C, R>): ColumnSet<R>

Perform a selection of columns using the Columns Selection DSL on any ColumnGroup. This is more powerful than the cols filter, because now all operations of the DSL are at your disposal.

Link copied to clipboard
open fun ColumnsSelectionDsl<*>.last(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*>

Returns the last column from this that adheres to the optional given condition. If no column adheres to the given condition, NoSuchElementException is thrown.

open fun <C> ColumnSet<C>.last(condition: (ColumnWithPath<C>) -> Boolean = { true }): SingleColumn<C>

Returns the last column from this that adheres to the optional given condition. If no column adheres to the given condition, NoSuchElementException is thrown.

Link copied to clipboard
open fun String.lastCol(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*>

Returns the last column from this that adheres to the optional given condition. If no column adheres to the given condition, NoSuchElementException is thrown.

open fun KProperty<*>.lastCol(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*>

Returns the last column from this that adheres to the optional given condition. If no column adheres to the given condition, NoSuchElementException is thrown.

open fun ColumnPath.lastCol(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*>

Returns the last column from this that adheres to the optional given condition. If no column adheres to the given condition, NoSuchElementException is thrown.

open fun SingleColumn<DataRow<*>>.lastCol(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*>

Returns the last column from this that adheres to the optional given condition. If no column adheres to the given condition, NoSuchElementException is thrown.

Link copied to clipboard
inline fun <T, reified R> ColumnsContainer<T>.mapToColumn(name: String, infer: Infer = Infer.Nulls, noinline body: AddExpression<T, R>): DataColumn<R>

Returns a new DataColumn with the given name and the values that body computes from the rows of this ColumnsContainer.

inline fun <T, reified R> ColumnsContainer<T>.mapToColumn(column: KProperty<R>, infer: Infer = Infer.Nulls, noinline body: AddExpression<T, R>): DataColumn<R>
inline fun <T, reified R> ColumnsContainer<T>.mapToColumn(column: ColumnReference<R>, infer: Infer = Infer.Nulls, noinline body: AddExpression<T, R>): DataColumn<R>
@PublishedApi
internal fun <T, R> ColumnsContainer<T>.mapToColumn(name: String, type: KType, infer: Infer = Infer.Nulls, body: AddExpression<T, R>): DataColumn<R>
fun <T, R> ColumnsContainer<T>.mapToColumn(column: KProperty<R>, type: KType, infer: Infer = Infer.Nulls, body: AddExpression<T, R>): DataColumn<R>
fun <T, R> ColumnsContainer<T>.mapToColumn(column: ColumnReference<R>, type: KType, infer: Infer = Infer.Nulls, body: AddExpression<T, R>): DataColumn<R>
Link copied to clipboard
open infix fun String.match(other: String): ColumnMatch<Any?>
open infix fun <C> String.match(other: ColumnReference<C>): ColumnMatch<C>
open infix fun <C> ColumnReference<C>.match(other: String): ColumnMatch<C>
open infix fun <C> ColumnReference<C>.match(other: ColumnReference<C>): ColumnMatch<C>

Matches columns from the left and right DataFrames for joining.

open infix fun <C> KProperty<C>.match(other: KProperty<C>): ColumnMatch<C>
open infix fun <C> KProperty<C>.match(other: ColumnReference<C>): ColumnMatch<C>
open infix fun <C> ColumnReference<C>.match(other: KProperty<C>): ColumnMatch<C>
Link copied to clipboard
open fun ColumnsSelectionDsl<*>.nameContains(regex: Regex): ColumnSet<*>

Returns a ColumnSet containing all columns from this having regex in their name.

open fun <C> ColumnSet<C>.nameContains(regex: Regex): ColumnSet<C>

Returns a ColumnSet containing all columns from this having regex in their name.

open fun ColumnsSelectionDsl<*>.nameContains(text: CharSequence, ignoreCase: Boolean = false): ColumnSet<*>

Returns a ColumnSet containing all columns from this having text in their name.

open fun <C> ColumnSet<C>.nameContains(text: CharSequence, ignoreCase: Boolean = false): ColumnSet<C>

Returns a ColumnSet containing all columns from this having text in their name.

Link copied to clipboard
open infix fun String.named(newName: String): ColumnReference<*>
open infix fun String.named(nameOf: KProperty<*>): ColumnReference<*>
open infix fun String.named(nameOf: ColumnReference<*>): ColumnReference<*>
open infix fun <C> KProperty<C>.named(newName: String): ColumnReference<C>
open infix fun <C> KProperty<C>.named(nameOf: KProperty<*>): ColumnReference<C>
open infix fun <C> KProperty<C>.named(nameOf: ColumnReference<*>): ColumnReference<C>
open infix fun <C> ColumnReference<C>.named(newName: String): ColumnReference<C>
open infix fun <C> ColumnReference<C>.named(nameOf: KProperty<*>): ColumnReference<C>
open infix fun <C> ColumnReference<C>.named(nameOf: ColumnReference<*>): ColumnReference<C>
open infix fun <C> SingleColumn<C>.named(newName: String): SingleColumn<C>

Renaming a column in the ColumnsSelectionDsl is done by calling the infix functions named or into. They behave exactly the same, so it's up to contextual preference which one to use. Any combination of Access APIs can be used to specify the column to rename and which name should be used instead.

Link copied to clipboard
open fun ColumnsSelectionDsl<*>.nameEndsWith(suffix: CharSequence, ignoreCase: Boolean = false): ColumnSet<*>

Returns a ColumnSet containing all columns from this ending with suffix in their name.

open fun <C> ColumnSet<C>.nameEndsWith(suffix: CharSequence, ignoreCase: Boolean = false): ColumnSet<C>

Returns a ColumnSet containing all columns from this ending with suffix in their name.

Link copied to clipboard
open fun ColumnsSelectionDsl<*>.nameStartsWith(prefix: CharSequence, ignoreCase: Boolean = false): ColumnSet<*>

Returns a ColumnSet containing all columns from this starting with prefix in their name.

open fun <C> ColumnSet<C>.nameStartsWith(prefix: CharSequence, ignoreCase: Boolean = false): ColumnSet<C>

Returns a ColumnSet containing all columns from this starting with prefix in their name.

Link copied to clipboard
@PublishedApi
internal fun <T, R> ColumnsContainer<T>.newColumn(type: KType, name: String = "", infer: Infer = Infer.Nulls, expression: AddExpression<T, R>): DataColumn<R>
Link copied to clipboard
Link copied to clipboard
open fun none(): ColumnsResolver<*>

Creates an empty ColumnsResolver / ColumnSet, essentially selecting no columns at all.

Link copied to clipboard
open operator fun String.rangeTo(endInclusive: String): ColumnSet<*>
open operator fun String.rangeTo(endInclusive: KProperty<*>): ColumnSet<*>
open operator fun String.rangeTo(endInclusive: ColumnReference<*>): ColumnSet<*>

Creates a ColumnSet containing all columns from this up to (and including) endInclusive.

open operator fun KProperty<*>.rangeTo(endInclusive: String): ColumnSet<*>
open operator fun KProperty<*>.rangeTo(endInclusive: KProperty<*>): ColumnSet<*>
open operator fun KProperty<*>.rangeTo(endInclusive: ColumnReference<*>): ColumnSet<*>

Creates a ColumnSet containing all columns from this up to (and including) endInclusive.

open operator fun ColumnReference<*>.rangeTo(endInclusive: String): ColumnSet<*>
open operator fun ColumnReference<*>.rangeTo(endInclusive: KProperty<*>): ColumnSet<*>
open operator fun ColumnReference<*>.rangeTo(endInclusive: ColumnReference<*>): ColumnSet<*>

Creates a ColumnSet containing all columns from this up to (and including) endInclusive.

Link copied to clipboard
open fun <R> String.select(selector: ColumnsSelector<*, R>): ColumnSet<R>
open fun <C, R> KProperty<C>.select(selector: ColumnsSelector<C, R>): ColumnSet<R>
open fun <R> ColumnPath.select(selector: ColumnsSelector<*, R>): ColumnSet<R>
open fun <C, R> SingleColumn<DataRow<C>>.select(selector: ColumnsSelector<C, R>): ColumnSet<R>

Perform a selection of columns using the Columns Selection DSL on any ColumnGroup. This is more powerful than the cols filter, because now all operations of the DSL are at your disposal.

Link copied to clipboard
open fun <C> ColumnSet<C>.simplify(): ColumnSet<C>

Given a this ColumnSet, simplify simplifies the structure by removing columns that are already present in column groups, returning only these groups plus columns not belonging in any of the groups.

Link copied to clipboard
open fun ColumnsSelectionDsl<*>.single(): SingleColumn<*>
open fun ColumnsSelectionDsl<*>.single(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*>

Returns the single column from this. If there is no column, NoSuchElementException is thrown. If there are multiple columns, IllegalArgumentException is thrown.

open fun <C> ColumnSet<C>.single(): SingleColumn<C>
open fun <C> ColumnSet<C>.single(condition: (ColumnWithPath<C>) -> Boolean = { true }): SingleColumn<C>

Returns the single column from this. If there is no column, NoSuchElementException is thrown. If there are multiple columns, IllegalArgumentException is thrown.

Link copied to clipboard
open fun String.singleCol(): SingleColumn<*>
open fun String.singleCol(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*>

Returns the single column from this. If there is no column, NoSuchElementException is thrown. If there are multiple columns, IllegalArgumentException is thrown.

open fun SingleColumn<DataRow<*>>.singleCol(): SingleColumn<*>
open fun SingleColumn<DataRow<*>>.singleCol(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*>

Returns the single column from this. If there is no column, NoSuchElementException is thrown. If there are multiple columns, IllegalArgumentException is thrown.

open fun KProperty<*>.singleCol(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*>

Returns the single column from this. If there is no column, NoSuchElementException is thrown. If there are multiple columns, IllegalArgumentException is thrown.

open fun ColumnPath.singleCol(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*>

Returns the single column from this. If there is no column, NoSuchElementException is thrown. If there are multiple columns, IllegalArgumentException is thrown.

Link copied to clipboard
open fun ColumnsSelectionDsl<*>.take(n: Int): ColumnSet<*>
open fun <C> ColumnSet<C>.take(n: Int): ColumnSet<C>

This collects the first n columns from this into a ColumnSet.

Link copied to clipboard
open fun String.takeCols(n: Int): ColumnSet<*>
open fun KProperty<*>.takeCols(n: Int): ColumnSet<*>
open fun ColumnPath.takeCols(n: Int): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.takeCols(n: Int): ColumnSet<*>

This collects the first n columns from this into a ColumnSet.

Link copied to clipboard
open fun String.takeColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>
open fun KProperty<*>.takeColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>
open fun ColumnPath.takeColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.takeColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>

This operation takes the first columns from this while they adhere to the predicate, stops as soon as it encounters one that does not, and collects the taken columns into a ColumnSet.

Link copied to clipboard
open fun ColumnsSelectionDsl<*>.takeLast(n: Int = 1): ColumnSet<*>
open fun <C> ColumnSet<C>.takeLast(n: Int = 1): ColumnSet<C>

This collects the last n columns from this into a ColumnSet.

Link copied to clipboard
open fun String.takeLastCols(n: Int): ColumnSet<*>
open fun KProperty<*>.takeLastCols(n: Int): ColumnSet<*>
open fun ColumnPath.takeLastCols(n: Int): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.takeLastCols(n: Int): ColumnSet<*>

This collects the last n columns from this into a ColumnSet.

Link copied to clipboard
open fun String.takeLastColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>
open fun KProperty<*>.takeLastColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>
open fun ColumnPath.takeLastColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>
open fun SingleColumn<DataRow<*>>.takeLastColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>

This operation takes the last columns from this while they adhere to the predicate, stops as soon as it encounters one that does not, and collects the taken columns into a ColumnSet.

Link copied to clipboard
open fun ColumnsSelectionDsl<*>.takeLastWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>
open fun <C> ColumnSet<C>.takeLastWhile(predicate: (ColumnWithPath<C>) -> Boolean): ColumnSet<C>

This operation takes the last columns from this while they adhere to the predicate, stops as soon as it encounters one that does not, and collects the taken columns into a ColumnSet.

Link copied to clipboard
open fun ColumnsSelectionDsl<*>.takeWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*>
open fun <C> ColumnSet<C>.takeWhile(predicate: (ColumnWithPath<C>) -> Boolean): ColumnSet<C>

This operation takes the first columns from this while they adhere to the predicate, stops as soon as it encounters one that does not, and collects the taken columns into a ColumnSet.

Link copied to clipboard
@JvmName(name = "valueColUnTyped")
open fun valueCol(name: String): ColumnAccessor<*>
open fun <C> valueCol(name: String): ColumnAccessor<C>
open fun <C> valueCol(property: KProperty<C>): SingleColumn<C>
open fun <C> valueCol(valueCol: ColumnAccessor<C>): ColumnAccessor<C>
@JvmName(name = "valueColUnTyped")
open fun valueCol(path: ColumnPath): ColumnAccessor<*>
open fun <C> valueCol(path: ColumnPath): ColumnAccessor<C>
@JvmName(name = "valueColUnTyped")
open fun String.valueCol(index: Int): SingleColumn<*>
open fun <C> String.valueCol(index: Int): SingleColumn<C>
@JvmName(name = "valueColUnTyped")
open fun String.valueCol(name: String): ColumnAccessor<*>
open fun <C> String.valueCol(name: String): ColumnAccessor<C>
open fun <C> String.valueCol(property: KProperty<C>): ColumnAccessor<C>
open fun <C> String.valueCol(valueCol: ColumnAccessor<C>): ColumnAccessor<C>
@JvmName(name = "valueColUnTyped")
open fun String.valueCol(path: ColumnPath): ColumnAccessor<*>
open fun <C> String.valueCol(path: ColumnPath): ColumnAccessor<C>
@JvmName(name = "valueColUnTyped")
open fun KProperty<*>.valueCol(index: Int): SingleColumn<*>
open fun <C> KProperty<*>.valueCol(index: Int): SingleColumn<C>
@JvmName(name = "valueColUnTyped")
open fun KProperty<*>.valueCol(name: String): ColumnAccessor<*>
open fun <C> KProperty<*>.valueCol(name: String): ColumnAccessor<C>
open fun <C> KProperty<*>.valueCol(property: KProperty<C>): ColumnAccessor<C>
open fun <C> KProperty<*>.valueCol(valueCol: ColumnAccessor<C>): ColumnAccessor<C>
@JvmName(name = "valueColUnTyped")
open fun KProperty<*>.valueCol(path: ColumnPath): ColumnAccessor<*>
open fun <C> KProperty<*>.valueCol(path: ColumnPath): ColumnAccessor<C>
@JvmName(name = "valueColUnTyped")
open fun ColumnsSelectionDsl<*>.valueCol(index: Int): SingleColumn<*>
open fun <C> ColumnsSelectionDsl<*>.valueCol(index: Int): SingleColumn<C>
@JvmName(name = "valueColUnTyped")
open fun ColumnAccessor<DataRow<*>>.valueCol(name: String): ColumnAccessor<*>
open fun <C> ColumnAccessor<DataRow<*>>.valueCol(name: String): ColumnAccessor<C>
open fun <C> ColumnAccessor<DataRow<*>>.valueCol(property: KProperty<C>): ColumnAccessor<C>
open fun <C> ColumnAccessor<DataRow<*>>.valueCol(valueCol: ColumnAccessor<C>): ColumnAccessor<C>
@JvmName(name = "valueColUnTyped")
open fun ColumnAccessor<DataRow<*>>.valueCol(path: ColumnPath): ColumnAccessor<*>
open fun <C> ColumnAccessor<DataRow<*>>.valueCol(path: ColumnPath): ColumnAccessor<C>
@JvmName(name = "valueColUnTyped")
open fun ColumnPath.valueCol(index: Int): SingleColumn<*>
open fun <C> ColumnPath.valueCol(index: Int): SingleColumn<C>
@JvmName(name = "valueColUnTyped")
open fun ColumnPath.valueCol(name: String): ColumnAccessor<*>
open fun <C> ColumnPath.valueCol(name: String): ColumnAccessor<C>
open fun <C> ColumnPath.valueCol(property: KProperty<C>): ColumnAccessor<C>
open fun <C> ColumnPath.valueCol(valueCol: ColumnAccessor<C>): ColumnAccessor<C>
@JvmName(name = "valueColUnTyped")
open fun ColumnPath.valueCol(path: ColumnPath): ColumnAccessor<*>
open fun <C> ColumnPath.valueCol(path: ColumnPath): ColumnAccessor<C>
open fun <C> ColumnSet<C>.valueCol(index: Int): SingleColumn<C>
@JvmName(name = "valueColUnTyped")
open fun SingleColumn<DataRow<*>>.valueCol(index: Int): SingleColumn<*>
open fun <C> SingleColumn<DataRow<*>>.valueCol(index: Int): SingleColumn<C>
@JvmName(name = "valueColUnTyped")
open fun SingleColumn<DataRow<*>>.valueCol(name: String): SingleColumn<*>
open fun <C> SingleColumn<DataRow<*>>.valueCol(name: String): SingleColumn<C>
open fun <C> SingleColumn<DataRow<*>>.valueCol(property: KProperty<C>): SingleColumn<C>
open fun <C> SingleColumn<DataRow<*>>.valueCol(valueCol: ColumnAccessor<C>): SingleColumn<C>
@JvmName(name = "valueColUnTyped")
open fun SingleColumn<DataRow<*>>.valueCol(path: ColumnPath): SingleColumn<*>
open fun <C> SingleColumn<DataRow<*>>.valueCol(path: ColumnPath): SingleColumn<C>

Creates a ColumnAccessor (or SingleColumn) for a value column with the given argument which can be either an index (Int) or a reference to a column (String, ColumnPath, KProperty, or ColumnAccessor; any Access APIs).

Link copied to clipboard
open fun String.valueCols(filter: Predicate<ValueColumn<*>> = { true }): ColumnSet<*>

Creates a subset of columns from this that are ValueColumns.

open fun KProperty<*>.valueCols(filter: Predicate<ValueColumn<*>> = { true }): ColumnSet<*>

Creates a subset of columns from this that are ValueColumns.

open fun ColumnsSelectionDsl<*>.valueCols(filter: Predicate<ValueColumn<*>> = { true }): ColumnSet<*>

Creates a subset of columns from this that are ValueColumns.

open fun ColumnPath.valueCols(filter: Predicate<ValueColumn<*>> = { true }): ColumnSet<*>

Creates a subset of columns from this that are ValueColumns.

open fun ColumnSet<*>.valueCols(filter: Predicate<ValueColumn<*>> = { true }): ColumnSet<*>

Creates a subset of columns from this that are ValueColumns.

open fun SingleColumn<DataRow<*>>.valueCols(filter: Predicate<ValueColumn<*>> = { true }): ColumnSet<*>

Creates a subset of columns from this that are ValueColumns.

Link copied to clipboard
open fun ColumnsSelectionDsl<*>.withoutNulls(): ColumnSet<Any>

Returns a new ColumnSet that contains only columns in this that do not have null values.

open fun <C> ColumnSet<C?>.withoutNulls(): ColumnSet<C & Any>

Returns a new ColumnSet that contains only columns in this that do not have null values.

Generated by Dokka
© 2021–2026 JetBrains s.r.o. and contributors. Licensed under Apache 2.0. | Documentation | GitHub | Slack Community | X | YouTube