• Home
• org.jetbrains.kotlinx
• dataframe-core
• 0.12.0
• source code
• pivot.kt

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.jetbrains.kotlinx.dataframe.api.pivot.kt Maven / Gradle / Ivy

package org.jetbrains.kotlinx.dataframe.api

import org.jetbrains.kotlinx.dataframe.AnyColumnReference
import org.jetbrains.kotlinx.dataframe.ColumnsSelector
import org.jetbrains.kotlinx.dataframe.DataFrame
import org.jetbrains.kotlinx.dataframe.DataRow
import org.jetbrains.kotlinx.dataframe.Selector
import org.jetbrains.kotlinx.dataframe.aggregation.Aggregatable
import org.jetbrains.kotlinx.dataframe.aggregation.AggregateBody
import org.jetbrains.kotlinx.dataframe.aggregation.AggregateGroupedDsl
import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
import org.jetbrains.kotlinx.dataframe.impl.aggregation.PivotGroupByImpl
import org.jetbrains.kotlinx.dataframe.impl.aggregation.PivotImpl
import org.jetbrains.kotlinx.dataframe.impl.aggregation.PivotInAggregateImpl
import org.jetbrains.kotlinx.dataframe.impl.api.PivotChainColumnSet
import kotlin.reflect.KProperty

public interface PivotDsl : ColumnsSelectionDsl {

    public infix fun  ColumnSet.then(other: ColumnSet): ColumnSet = PivotChainColumnSet(this, other)

    public infix fun  String.then(other: ColumnSet): ColumnSet = toColumnOf() then other

    public infix fun  ColumnSet.then(other: String): ColumnSet = this then other.toColumnOf()

    public infix fun String.then(other: String): ColumnSet = toColumnAccessor() then other.toColumnAccessor()

    public infix fun  KProperty.then(other: ColumnSet): ColumnSet = toColumnAccessor() then other

    public infix fun  ColumnSet.then(other: KProperty): ColumnSet = this then other.toColumnAccessor()

    public infix fun  KProperty.then(other: KProperty): ColumnSet =
        toColumnAccessor() then other.toColumnAccessor()

    public infix fun  KProperty.then(other: String): ColumnSet = toColumnAccessor() then other.toColumnOf()

    public infix fun  String.then(other: KProperty): ColumnSet = toColumnOf() then other.toColumnAccessor()
}

// region DataFrame

// region pivot

public fun  DataFrame.pivot(inward: Boolean? = null, columns: PivotColumnsSelector): Pivot =
    PivotImpl(this, columns, inward)

public fun  DataFrame.pivot(vararg columns: String, inward: Boolean? = null): Pivot =
    pivot(inward) { columns.toColumnSet() }

public fun  DataFrame.pivot(vararg columns: AnyColumnReference, inward: Boolean? = null): Pivot =
    pivot(inward) { columns.toColumnSet() }

public fun  DataFrame.pivot(vararg columns: KProperty<*>, inward: Boolean? = null): Pivot =
    pivot(inward) { columns.toColumnSet() }

// endregion

// region pivotMatches

public fun  DataFrame.pivotMatches(inward: Boolean = true, columns: ColumnsSelector): DataFrame =
    pivot(inward, columns).groupByOther().matches()

public fun  DataFrame.pivotMatches(vararg columns: String, inward: Boolean = true): DataFrame =
    pivotMatches(inward) { columns.toColumnSet() }

public fun  DataFrame.pivotMatches(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame =
    pivotMatches(inward) { columns.toColumnSet() }

public fun  DataFrame.pivotMatches(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame =
    pivotMatches(inward) { columns.toColumnSet() }

// endregion

// region pivotCounts

public fun  DataFrame.pivotCounts(inward: Boolean = true, columns: ColumnsSelector): DataFrame =
    pivot(inward, columns).groupByOther().count()

public fun  DataFrame.pivotCounts(vararg columns: String, inward: Boolean = true): DataFrame =
    pivotCounts(inward) { columns.toColumnSet() }

public fun  DataFrame.pivotCounts(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame =
    pivotCounts(inward) { columns.toColumnSet() }

public fun  DataFrame.pivotCounts(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame =
    pivotCounts(inward) { columns.toColumnSet() }

// endregion

// endregion

// region GroupBy

// region pivot

public fun  GroupBy<*, G>.pivot(inward: Boolean = true, columns: ColumnsSelector): PivotGroupBy =
    PivotGroupByImpl(this, columns, inward)

public fun  GroupBy<*, G>.pivot(vararg columns: AnyColumnReference, inward: Boolean = true): PivotGroupBy =
    pivot(inward) { columns.toColumnSet() }

public fun  GroupBy<*, G>.pivot(vararg columns: String, inward: Boolean = true): PivotGroupBy =
    pivot(inward) { columns.toColumnSet() }

public fun  GroupBy<*, G>.pivot(vararg columns: KProperty<*>, inward: Boolean = true): PivotGroupBy =
    pivot(inward) { columns.toColumnSet() }

// endregion

// region pivotMatches

public fun  GroupBy<*, G>.pivotMatches(inward: Boolean = true, columns: ColumnsSelector): DataFrame =
    pivot(inward, columns).matches()

public fun  GroupBy<*, G>.pivotMatches(vararg columns: String, inward: Boolean = true): DataFrame =
    pivotMatches(inward) { columns.toColumnSet() }

public fun  GroupBy<*, G>.pivotMatches(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame =
    pivotMatches(inward) { columns.toColumnSet() }

public fun  GroupBy<*, G>.pivotMatches(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame =
    pivotMatches(inward) { columns.toColumnSet() }

// endregion

// region pivotCounts

public fun  GroupBy<*, G>.pivotCounts(inward: Boolean = true, columns: ColumnsSelector): DataFrame =
    pivot(inward, columns).count()

public fun  GroupBy<*, G>.pivotCounts(vararg columns: String, inward: Boolean = true): DataFrame =
    pivotCounts(inward) { columns.toColumnSet() }

public fun  GroupBy<*, G>.pivotCounts(vararg columns: AnyColumnReference, inward: Boolean = true): DataFrame =
    pivotCounts(inward) { columns.toColumnSet() }

public fun  GroupBy<*, G>.pivotCounts(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame =
    pivotCounts(inward) { columns.toColumnSet() }

// endregion

// endregion

// region GroupBy.aggregate

// region pivot

public fun  AggregateGroupedDsl.pivot(inward: Boolean = true, columns: ColumnsSelector): PivotGroupBy =
    PivotInAggregateImpl(this, columns, inward)

public fun  AggregateGroupedDsl.pivot(vararg columns: String, inward: Boolean = true): PivotGroupBy =
    pivot(inward) { columns.toColumnSet() }

public fun  AggregateGroupedDsl.pivot(
    vararg columns: AnyColumnReference,
    inward: Boolean = true,
): PivotGroupBy = pivot(inward) { columns.toColumnSet() }

public fun  AggregateGroupedDsl.pivot(vararg columns: KProperty<*>, inward: Boolean = true): PivotGroupBy =
    pivot(inward) { columns.toColumnSet() }

// endregion

// region pivotMatches

public fun  AggregateGroupedDsl.pivotMatches(
    inward: Boolean = true,
    columns: ColumnsSelector,
): DataFrame = pivot(inward, columns).matches()

public fun  AggregateGroupedDsl.pivotMatches(vararg columns: String, inward: Boolean = true): DataFrame =
    pivotMatches(inward) { columns.toColumnSet() }

public fun  AggregateGroupedDsl.pivotMatches(
    vararg columns: AnyColumnReference,
    inward: Boolean = true,
): DataFrame = pivotMatches(inward) { columns.toColumnSet() }

public fun  AggregateGroupedDsl.pivotMatches(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame =
    pivotMatches(inward) { columns.toColumnSet() }

// endregion

// region pivotCounts

public fun  AggregateGroupedDsl.pivotCounts(
    inward: Boolean = true,
    columns: ColumnsSelector,
): DataFrame = pivot(inward, columns).matches()

public fun  AggregateGroupedDsl.pivotCounts(vararg columns: String, inward: Boolean = true): DataFrame =
    pivotCounts(inward) { columns.toColumnSet() }

public fun  AggregateGroupedDsl.pivotCounts(
    vararg columns: AnyColumnReference,
    inward: Boolean = true,
): DataFrame = pivotCounts(inward) { columns.toColumnSet() }

public fun  AggregateGroupedDsl.pivotCounts(vararg columns: KProperty<*>, inward: Boolean = true): DataFrame =
    pivotCounts(inward) { columns.toColumnSet() }

// endregion

// endregion

public interface Pivot : Aggregatable

public typealias PivotColumnsSelector = Selector, ColumnSet>

public data class ReducedPivot(
    @PublishedApi internal val pivot: Pivot,
    @PublishedApi internal val reducer: Selector, DataRow?>,
)

internal fun  Pivot.reduce(reducer: Selector, DataRow?>) = ReducedPivot(this, reducer)

@PublishedApi
internal inline fun  Pivot.delegate(crossinline body: PivotGroupBy.() -> DataFrame): DataRow =
    body(groupBy { none() })[0]

public interface PivotGroupBy : Aggregatable {

    public fun  aggregate(separate: Boolean = false, body: AggregateBody): DataFrame

    public fun default(value: Any?): PivotGroupBy
}

public data class ReducedPivotGroupBy(
    @PublishedApi internal val pivot: PivotGroupBy,
    @PublishedApi internal val reducer: Selector, DataRow?>,
)

@PublishedApi
internal fun  PivotGroupBy.reduce(reducer: Selector, DataRow?>): ReducedPivotGroupBy =
    ReducedPivotGroupBy(this, reducer)