core/org.jetbrains.kotlinx.dataframe.api/ColGroupColumnsSelectionDsl/colGroup

colGroup

@JvmName(name = "colGroupUnTyped")
open fun colGroup(name: String): ColumnAccessor<DataRow<*>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ colGroup("columnGroupName") }

df.select{ colGroup<String>("columnGroupName") }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

name

The name of the value column.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

open fun <C> colGroup(name: String): ColumnAccessor<DataRow<C>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ colGroup("columnGroupName") }

df.select{ colGroup<String>("columnGroupName") }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

name

The name of the value column.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

@JvmName(name = "colGroupUnTyped")
open fun SingleColumn<DataRow<*>>.colGroup(name: String): SingleColumn<DataRow<*>>
@JvmName(name = "colGroupUnTyped")
open fun ColumnAccessor<DataRow<*>>.colGroup(name: String): ColumnAccessor<DataRow<*>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ myColumnGroup.colGroup("columnGroupName") }

df.select{ myColumnGroup.colGroup<String>("columnGroupName") }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

name

The name of the value column.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

open fun <C> SingleColumn<DataRow<*>>.colGroup(name: String): SingleColumn<DataRow<C>>
open fun <C> ColumnAccessor<DataRow<*>>.colGroup(name: String): ColumnAccessor<DataRow<C>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ myColumnGroup.colGroup("columnGroupName") }

df.select{ myColumnGroup.colGroup<String>("columnGroupName") }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

name

The name of the value column.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

@JvmName(name = "colGroupUnTyped")
open fun String.colGroup(name: String): ColumnAccessor<DataRow<*>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ "myColumnGroup".colGroup("columnGroupName") }

df.select{ "myColumnGroup".colGroup<String>("columnGroupName") }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

name

The name of the value column.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

open fun <C> String.colGroup(name: String): ColumnAccessor<DataRow<C>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ "myColumnGroup".colGroup("columnGroupName") }

df.select{ "myColumnGroup".colGroup<String>("columnGroupName") }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

name

The name of the value column.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

@JvmName(name = "colGroupUnTyped")
open fun ColumnPath.colGroup(name: String): ColumnAccessor<DataRow<*>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ "pathTo"["myColumnGroup"].colGroup("columnGroupName") }

df.select{ "pathTo"["myColumnGroup"].colGroup<String>("columnGroupName") }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

name

The name of the value column.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

open fun <C> ColumnPath.colGroup(name: String): ColumnAccessor<DataRow<C>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ "pathTo"["myColumnGroup"].colGroup("columnGroupName") }

df.select{ "pathTo"["myColumnGroup"].colGroup<String>("columnGroupName") }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

name

The name of the value column.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

@JvmName(name = "colGroupUnTyped")
open fun colGroup(path: ColumnPath): ColumnAccessor<DataRow<*>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ colGroup("pathTo"["columnGroupName"] ) }

df.select{ colGroup<String>("pathTo"["columnGroupName"] ) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

path

The path to the value column.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

open fun <C> colGroup(path: ColumnPath): ColumnAccessor<DataRow<C>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ colGroup("pathTo"["columnGroupName"] ) }

df.select{ colGroup<String>("pathTo"["columnGroupName"] ) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

path

The path to the value column.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

@JvmName(name = "colGroupUnTyped")
open fun SingleColumn<DataRow<*>>.colGroup(path: ColumnPath): SingleColumn<DataRow<*>>
@JvmName(name = "colGroupUnTyped")
open fun ColumnAccessor<DataRow<*>>.colGroup(path: ColumnPath): ColumnAccessor<DataRow<*>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ myColumnGroup.colGroup("pathTo"["columnGroupName"] ) }

df.select{ myColumnGroup.colGroup<String>("pathTo"["columnGroupName"] ) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

path

The path to the value column.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

open fun <C> SingleColumn<DataRow<*>>.colGroup(path: ColumnPath): SingleColumn<DataRow<C>>
open fun <C> ColumnAccessor<DataRow<*>>.colGroup(path: ColumnPath): ColumnAccessor<DataRow<C>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ myColumnGroup.colGroup("pathTo"["columnGroupName"] ) }

df.select{ myColumnGroup.colGroup<String>("pathTo"["columnGroupName"] ) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

path

The path to the value column.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

@JvmName(name = "colGroupUnTyped")
open fun String.colGroup(path: ColumnPath): ColumnAccessor<DataRow<*>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ "myColumnGroup".colGroup("pathTo"["columnGroupName"] ) }

df.select{ "myColumnGroup".colGroup<String>("pathTo"["columnGroupName"] ) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

path

The path to the value column.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

open fun <C> String.colGroup(path: ColumnPath): ColumnAccessor<DataRow<C>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ "myColumnGroup".colGroup("pathTo"["columnGroupName"] ) }

df.select{ "myColumnGroup".colGroup<String>("pathTo"["columnGroupName"] ) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

path

The path to the value column.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

@JvmName(name = "colGroupUnTyped")
open fun ColumnPath.colGroup(path: ColumnPath): ColumnAccessor<DataRow<*>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ "pathTo"["myColumnGroup"].colGroup("pathTo"["columnGroupName"] ) }

df.select{ "pathTo"["myColumnGroup"].colGroup<String>("pathTo"["columnGroupName"] ) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

path

The path to the value column.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

open fun <C> ColumnPath.colGroup(path: ColumnPath): ColumnAccessor<DataRow<C>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ "pathTo"["myColumnGroup"].colGroup("pathTo"["columnGroupName"] ) }

df.select{ "pathTo"["myColumnGroup"].colGroup<String>("pathTo"["columnGroupName"] ) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

path

The path to the value column.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

@JvmName(name = "ColumnSetDataRowColGroupIndex")
open fun <C> ColumnSet<DataRow<C>>.colGroup(index: Int): SingleColumn<DataRow<C>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ colsOf<Int>().colGroup(0) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

index

The index of the value column.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

if the index is out of bounds.

open fun ColumnSet<*>.colGroup(index: Int): SingleColumn<DataRow<*>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ colsOf<Int>().colGroup(0) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

index

The index of the value column.

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

if the index is out of bounds.

@JvmName(name = "colGroupUnTyped")
open fun ColumnsSelectionDsl<*>.colGroup(index: Int): SingleColumn<DataRow<*>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ colGroup(0) }

df.select{ colGroup<String>(0) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

index

The index of the value column.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

if the index is out of bounds.

open fun <C> ColumnsSelectionDsl<*>.colGroup(index: Int): SingleColumn<DataRow<C>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ colGroup(0) }

df.select{ colGroup<String>(0) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

index

The index of the value column.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

if the index is out of bounds.

@JvmName(name = "colGroupUnTyped")
open fun SingleColumn<DataRow<*>>.colGroup(index: Int): SingleColumn<DataRow<*>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ myColumnGroup.colGroup(0) }

df.select{ myColumnGroup.colGroup<String>(0) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

index

The index of the value column.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

if the index is out of bounds.

open fun <C> SingleColumn<DataRow<*>>.colGroup(index: Int): SingleColumn<DataRow<C>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ myColumnGroup.colGroup(0) }

df.select{ myColumnGroup.colGroup<String>(0) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

index

The index of the value column.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

if the index is out of bounds.

@JvmName(name = "colGroupUnTyped")
open fun String.colGroup(index: Int): SingleColumn<DataRow<*>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ "myColumnGroup".colGroup(0) }

df.select{ "myColumnGroup".colGroup<String>(0) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

index

The index of the value column.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

if the index is out of bounds.

open fun <C> String.colGroup(index: Int): SingleColumn<DataRow<C>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ "myColumnGroup".colGroup(0) }

df.select{ "myColumnGroup".colGroup<String>(0) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

index

The index of the value column.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

if the index is out of bounds.

@JvmName(name = "colGroupUnTyped")
open fun ColumnPath.colGroup(index: Int): SingleColumn<DataRow<*>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ "pathTo"["myColumnGroup"].colGroup(0) }

df.select{ "pathTo"["myColumnGroup"].colGroup<String>(0) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

index

The index of the value column.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

if the index is out of bounds.

open fun <C> ColumnPath.colGroup(index: Int): SingleColumn<DataRow<C>>

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ "pathTo"["myColumnGroup"].colGroup(0) }

df.select{ "pathTo"["myColumnGroup"].colGroup<String>(0) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

index

The index of the value column.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

if the index is out of bounds.

open fun <C> colGroup(colGroup: ColumnAccessor<DataRow<C>>): ColumnAccessor<DataRow<C>>

Deprecated

It's recommended to migrate to the String or Extension Properties Access API https://kotlin.github.io/dataframe/apilevels.html

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ colGroup(columnGroupA) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

col

The ColumnAccessor pointing to the column group.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

open fun <C> SingleColumn<DataRow<*>>.colGroup(colGroup: ColumnAccessor<DataRow<C>>): SingleColumn<DataRow<C>>
open fun <C> ColumnAccessor<DataRow<*>>.colGroup(colGroup: ColumnAccessor<DataRow<C>>): ColumnAccessor<DataRow<C>>

Deprecated

It's recommended to migrate to the String or Extension Properties Access API https://kotlin.github.io/dataframe/apilevels.html

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ myColumnGroup.colGroup(columnGroupA) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

col

The ColumnAccessor pointing to the column group.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

open fun <C> String.colGroup(colGroup: ColumnAccessor<DataRow<C>>): ColumnAccessor<DataRow<C>>

Deprecated

It's recommended to migrate to the String or Extension Properties Access API https://kotlin.github.io/dataframe/apilevels.html

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ "myColumnGroup".colGroup(columnGroupA) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

col

The ColumnAccessor pointing to the column group.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

open fun <C> KProperty<*>.colGroup(colGroup: ColumnAccessor<DataRow<C>>): ColumnAccessor<DataRow<C>>

Deprecated

It's recommended to migrate to the String or Extension Properties Access API https://kotlin.github.io/dataframe/apilevels.html

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ Type::myColumnGroup.colGroup(columnGroupA) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

col

The ColumnAccessor pointing to the column group.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

open fun <C> ColumnPath.colGroup(colGroup: ColumnAccessor<DataRow<C>>): ColumnAccessor<DataRow<C>>

Deprecated

It's recommended to migrate to the String or Extension Properties Access API https://kotlin.github.io/dataframe/apilevels.html

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ "pathTo"["myColumnGroup"].colGroup(columnGroupA) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

col

The ColumnAccessor pointing to the column group.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

@JvmName(name = "colGroupUnTyped")
open fun KProperty<*>.colGroup(name: String): ColumnAccessor<DataRow<*>>

Deprecated

It's recommended to migrate to the String or Extension Properties Access API https://kotlin.github.io/dataframe/apilevels.html

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ Type::myColumnGroup.colGroup("columnGroupName") }

df.select{ Type::myColumnGroup.colGroup<String>("columnGroupName") }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

name

The name of the value column.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

open fun <C> KProperty<*>.colGroup(name: String): ColumnAccessor<DataRow<C>>

Deprecated

It's recommended to migrate to the String or Extension Properties Access API https://kotlin.github.io/dataframe/apilevels.html

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ Type::myColumnGroup.colGroup("columnGroupName") }

df.select{ Type::myColumnGroup.colGroup<String>("columnGroupName") }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

name

The name of the value column.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

@JvmName(name = "colGroupUnTyped")
open fun KProperty<*>.colGroup(path: ColumnPath): ColumnAccessor<DataRow<*>>

Deprecated

It's recommended to migrate to the String or Extension Properties Access API https://kotlin.github.io/dataframe/apilevels.html

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ Type::myColumnGroup.colGroup("pathTo"["columnGroupName"] ) }

df.select{ Type::myColumnGroup.colGroup<String>("pathTo"["columnGroupName"] ) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

path

The path to the value column.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

open fun <C> KProperty<*>.colGroup(path: ColumnPath): ColumnAccessor<DataRow<C>>

Deprecated

It's recommended to migrate to the String or Extension Properties Access API https://kotlin.github.io/dataframe/apilevels.html

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ Type::myColumnGroup.colGroup("pathTo"["columnGroupName"] ) }

df.select{ Type::myColumnGroup.colGroup<String>("pathTo"["columnGroupName"] ) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

path

The path to the value column.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

@JvmName(name = "colGroupDataRowKProperty")
open fun <C> colGroup(property: KProperty<DataRow<C>>): SingleColumn<DataRow<C>>
open fun <C> colGroup(property: KProperty<C>): SingleColumn<DataRow<C>>

Deprecated

It's recommended to migrate to the String or Extension Properties Access API https://kotlin.github.io/dataframe/apilevels.html

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ colGroup(Type::columnGroupA) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

property

The KProperty reference to the value column.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

@JvmName(name = "colGroupDataRowKProperty")
open fun <C> SingleColumn<DataRow<*>>.colGroup(property: KProperty<DataRow<C>>): SingleColumn<DataRow<C>>
open fun <C> SingleColumn<DataRow<*>>.colGroup(property: KProperty<C>): SingleColumn<DataRow<C>>
@JvmName(name = "colGroupDataRowKProperty")
open fun <C> ColumnAccessor<DataRow<*>>.colGroup(property: KProperty<DataRow<C>>): ColumnAccessor<DataRow<C>>
open fun <C> ColumnAccessor<DataRow<*>>.colGroup(property: KProperty<C>): ColumnAccessor<DataRow<C>>

Deprecated

It's recommended to migrate to the String or Extension Properties Access API https://kotlin.github.io/dataframe/apilevels.html

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ myColumnGroup.colGroup(Type::columnGroupA) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

property

The KProperty reference to the value column.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

@JvmName(name = "colGroupDataRowKProperty")
open fun <C> String.colGroup(property: KProperty<DataRow<C>>): ColumnAccessor<DataRow<C>>
open fun <C> String.colGroup(property: KProperty<C>): ColumnAccessor<DataRow<C>>

Deprecated

It's recommended to migrate to the String or Extension Properties Access API https://kotlin.github.io/dataframe/apilevels.html

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ "myColumnGroup".colGroup(Type::columnGroupA) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

property

The KProperty reference to the value column.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

@JvmName(name = "colGroupDataRowKProperty")
open fun <C> KProperty<*>.colGroup(property: KProperty<DataRow<C>>): ColumnAccessor<DataRow<C>>
open fun <C> KProperty<*>.colGroup(property: KProperty<C>): ColumnAccessor<DataRow<C>>

Deprecated

It's recommended to migrate to the String or Extension Properties Access API https://kotlin.github.io/dataframe/apilevels.html

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ Type::myColumnGroup.colGroup(Type::columnGroupA) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

property

The KProperty reference to the value column.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

@JvmName(name = "colGroupDataRowKProperty")
open fun <C> ColumnPath.colGroup(property: KProperty<DataRow<C>>): ColumnAccessor<DataRow<C>>
open fun <C> ColumnPath.colGroup(property: KProperty<C>): ColumnAccessor<DataRow<C>>

Deprecated

It's recommended to migrate to the String or Extension Properties Access API https://kotlin.github.io/dataframe/apilevels.html

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ "pathTo"["myColumnGroup"].colGroup(Type::columnGroupA) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

property

The KProperty reference to the value column.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

@JvmName(name = "colGroupUnTyped")
open fun KProperty<*>.colGroup(index: Int): SingleColumn<DataRow<*>>

Deprecated

It's recommended to migrate to the String or Extension Properties Access API https://kotlin.github.io/dataframe/apilevels.html

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ Type::myColumnGroup.colGroup(0) }

df.select{ Type::myColumnGroup.colGroup<String>(0) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

index

The index of the value column.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

if the index is out of bounds.

open fun <C> KProperty<*>.colGroup(index: Int): SingleColumn<DataRow<C>>

Deprecated

It's recommended to migrate to the String or Extension Properties Access API https://kotlin.github.io/dataframe/apilevels.html

Col Group

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

This is a DSL-shorthand for columnGroup and can be both typed and untyped (in case you're supplying a column name, -path, or index). In addition, extra runtime checks are in place to ensure that the column you specify is actually a column group. The function can also be called on ColumnGroups to create an accessor for a column group inside a ColumnGroup.

    

For more information: See colGroup on the documentation website.

Check out: Grammar

For example:

df.select{ colGroup<String>("colGroupA") }

df.select{ colGroup(SomeType::colGroupB) }

df.select{ myColumnGroup.colGroup(1) }

Examples for this overload:

df.select{ Type::myColumnGroup.colGroup(0) }

df.select{ Type::myColumnGroup.colGroup<String>(0) }

To create a ColumnAccessor for another kind of column, take a look at the functions col, valueCol, and frameCol.

Return

A ColumnAccessor for the column group with the given argument if possible, else a SingleColumn.

Parameters

index

The index of the value column.

Type Parameters

C

The type of the column group.

See also

Throws

if the column with the given argument does not exist.

if the column with the given argument is not a column group.

if the index is out of bounds.

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