groupBy {}.aggregate { keys }

[Jolanrensen]

Provides access to the keys of the groupBy {} operation in the aggregate {} step. Very useful when you're grouping by an expr {} column and want to use the value of a key column to influence how the aggregation happens.
For instance:

df.groupBy { expr { … } named "keyName" }
  .aggregate {
      keys["keyName"] into "valueName"
   }

keys will be provided as an AnyRow, since most it will just contain the key columns from df, a tiny subset. Giving it the same type as df would result in many breaking accessors on keys.

[koperagen]

Hm, it has to be lambda here? Can be a DataRow, not sure. And what about default parameter: can it somehow actually throw an exception?

[Jolanrensen]

The lambda could be replaced by by a nullable AnyRow perhaps.
And yes, it will throw an exception when you use dataFrame.aggregate { keys }, since for some reason, the same AggregateGroupedDsl is used there. There's also an option to get here via pivot, so for those cases I make it throw a helpful exception.

[koperagen]

Hmm, i'd say we need to make type of lambda in Groupby.aggregate more specific then? So only for that case we provide keys as a DSL property. Also, if it makes sense, we can make aggregate an extension function and hide existing member one (but this could be a different story)

[koperagen]

Oh yes, i remember now. aggregate probably should be an extension function on GroupBy

public interface GroupBy<out T, out G> : Grouped<G> {

    public val groups: FrameColumn<G>

    public val keys: DataFrame<T>

then keys can become DataRow<T>

Because now aggregate on GroupBy is resolved to this member and it simply doesn't know anything about keys

public interface Grouped<out T> : Aggregatable<T> {

    public fun <R> aggregate(body: AggregateGroupedBody<T, R>): DataFrame<T>
}