Automated commit of generated code

Author: github-actions[bot]

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/and.kt

@@ -9,7 +9,7 @@ import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
 import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
 import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
-import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnsList
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnListImpl
 import kotlin.reflect.KProperty
 
 // region ColumnsSelectionDsl
@@ -211,7 +211,7 @@ public interface AndColumnsSelectionDsl {
      *   and right side of the [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator.
      */
     @Interpretable("And0")
-    public infix fun <C> ColumnsResolver<C>.and(other: ColumnsResolver<C>): ColumnSet<C> = ColumnsList(this, other)
+    public infix fun <C> ColumnsResolver<C>.and(other: ColumnsResolver<C>): ColumnSet<C> = ColumnListImpl(this, other)
 
     /** ## And Operator
      * The [and][org.jetbrains.kotlinx.dataframe.api.AndColumnsSelectionDsl.and] operator allows you to combine selections of columns or simply select multiple columns at once.

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt

@@ -10,8 +10,12 @@ import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
 import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
 import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
 import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.DataFrameReceiver
+import org.jetbrains.kotlinx.dataframe.impl.api.extractJoinColumns
 import org.jetbrains.kotlinx.dataframe.impl.api.joinImpl
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnListImpl
 import kotlin.reflect.KProperty
 
 @Refine
@@ -28,6 +32,8 @@ public fun <A, B> DataFrame<A>.join(
     type: JoinType = JoinType.Inner,
 ): DataFrame<A> = join(other, type) { columns.toColumnSet() }
 
+@Refine
+@Interpretable("InnerJoin")
 public fun <A, B> DataFrame<A>.innerJoin(
     other: DataFrame<B>,
     selector: JoinColumnsSelector<A, B>? = null,
@@ -36,6 +42,8 @@ public fun <A, B> DataFrame<A>.innerJoin(
 public fun <A, B> DataFrame<A>.innerJoin(other: DataFrame<B>, vararg columns: String): DataFrame<A> =
     innerJoin(other) { columns.toColumnSet() }
 
+@Refine
+@Interpretable("LeftJoin")
 public fun <A, B> DataFrame<A>.leftJoin(
     other: DataFrame<B>,
     selector: JoinColumnsSelector<A, B>? = null,
@@ -44,6 +52,8 @@ public fun <A, B> DataFrame<A>.leftJoin(
 public fun <A, B> DataFrame<A>.leftJoin(other: DataFrame<B>, vararg columns: String): DataFrame<A> =
     leftJoin(other) { columns.toColumnSet() }
 
+@Refine
+@Interpretable("RightJoin")
 public fun <A, B> DataFrame<A>.rightJoin(
     other: DataFrame<B>,
     selector: JoinColumnsSelector<A, B>? = null,
@@ -52,6 +62,8 @@ public fun <A, B> DataFrame<A>.rightJoin(
 public fun <A, B> DataFrame<A>.rightJoin(other: DataFrame<B>, vararg columns: String): DataFrame<A> =
     rightJoin(other) { columns.toColumnSet() }
 
+@Refine
+@Interpretable("FullJoin")
 public fun <A, B> DataFrame<A>.fullJoin(
     other: DataFrame<B>,
     selector: JoinColumnsSelector<A, B>? = null,
@@ -60,6 +72,8 @@ public fun <A, B> DataFrame<A>.fullJoin(
 public fun <A, B> DataFrame<A>.fullJoin(other: DataFrame<B>, vararg columns: String): DataFrame<A> =
     fullJoin(other) { columns.toColumnSet() }
 
+@Refine
+@Interpretable("FilterJoin")
 public fun <A, B> DataFrame<A>.filterJoin(
     other: DataFrame<B>,
     selector: JoinColumnsSelector<A, B>? = null,
@@ -68,6 +82,8 @@ public fun <A, B> DataFrame<A>.filterJoin(
 public fun <A, B> DataFrame<A>.filterJoin(other: DataFrame<B>, vararg columns: String): DataFrame<A> =
     filterJoin(other) { columns.toColumnSet() }
 
+@Refine
+@Interpretable("ExcludeJoin")
 public fun <A, B> DataFrame<A>.excludeJoin(
     other: DataFrame<B>,
     selector: JoinColumnsSelector<A, B>? = null,
@@ -107,14 +123,44 @@ public interface JoinDsl<out A, out B> : ColumnsSelectionDsl<A> {
     @AccessApiOverload
     public infix fun <C> KProperty<C>.match(other: ColumnReference<C>): ColumnMatch<C> =
         ColumnMatch(toColumnAccessor(), other)
+
+    public companion object {
+        public fun <A, B> defaultJoinColumns(left: DataFrame<A>, right: DataFrame<B>): JoinColumnsSelector<A, B> =
+            {
+                left.columnNames().intersect(right.columnNames().toSet())
+                    .map { it.toColumnAccessor() }
+                    .let { ColumnListImpl(it) }
+            }
+
+        public fun <A, B> getColumns(
+            left: DataFrame<A>,
+            other: DataFrame<B>,
+            selector: JoinColumnsSelector<A, B>,
+        ): List<ColumnMatch<Any?>> {
+            val receiver = object : DataFrameReceiver<A>(left, UnresolvedColumnsPolicy.Fail), JoinDsl<A, B> {
+                override val right: DataFrame<B> = DataFrameReceiver(other, UnresolvedColumnsPolicy.Fail)
+            }
+            val columns = selector(receiver, left)
+            return columns.extractJoinColumns()
+        }
+    }
 }
 
-public class ColumnMatch<C>(public val left: ColumnReference<C>, public val right: ColumnReference<C>) : ColumnSet<C> {
+public interface ColumnMatch<C> : ColumnSet<C> {
+    public val left: ColumnReference<C>
+    public val right: ColumnReference<C>
+}
+
+internal class ColumnMatchImpl<C>(override val left: ColumnReference<C>, override val right: ColumnReference<C>) :
+    ColumnMatch<C> {
 
     override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>> =
         throw UnsupportedOperationException()
 }
 
+public fun <C> ColumnMatch(left: ColumnReference<C>, right: ColumnReference<C>): ColumnMatch<C> =
+    ColumnMatchImpl(left, right)
+
 public typealias JoinColumnsSelector<A, B> = JoinDsl<A, B>.(ColumnsContainer<A>) -> ColumnsResolver<*>
 
 public enum class JoinType {

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/joinWith.kt

@@ -3,6 +3,8 @@ package org.jetbrains.kotlinx.dataframe.api
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.Selector
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
 import org.jetbrains.kotlinx.dataframe.impl.api.joinWithImpl
 
 public interface JoinedDataRow<out A, out B> : DataRow<A> {
@@ -11,27 +13,41 @@ public interface JoinedDataRow<out A, out B> : DataRow<A> {
 
 public typealias JoinExpression<A, B> = Selector<JoinedDataRow<A, B>, Boolean>
 
+@Refine
+@Interpretable("JoinWith")
 public fun <A, B> DataFrame<A>.joinWith(
     right: DataFrame<B>,
     type: JoinType = JoinType.Inner,
     joinExpression: JoinExpression<A, B>,
 ): DataFrame<A> = joinWithImpl(right, type, addNewColumns = type.addNewColumns, joinExpression)
 
+@Refine
+@Interpretable("InnerJoinWith")
 public fun <A, B> DataFrame<A>.innerJoinWith(right: DataFrame<B>, joinExpression: JoinExpression<A, B>): DataFrame<A> =
     joinWith(right, JoinType.Inner, joinExpression)
 
+@Refine
+@Interpretable("LeftJoinWith")
 public fun <A, B> DataFrame<A>.leftJoinWith(right: DataFrame<B>, joinExpression: JoinExpression<A, B>): DataFrame<A> =
     joinWith(right, JoinType.Left, joinExpression)
 
+@Refine
+@Interpretable("RightJoinWith")
 public fun <A, B> DataFrame<A>.rightJoinWith(right: DataFrame<B>, joinExpression: JoinExpression<A, B>): DataFrame<A> =
     joinWith(right, JoinType.Right, joinExpression)
 
+@Refine
+@Interpretable("FullJoinWith")
 public fun <A, B> DataFrame<A>.fullJoinWith(right: DataFrame<B>, joinExpression: JoinExpression<A, B>): DataFrame<A> =
     joinWith(right, JoinType.Full, joinExpression)
 
+@Refine
+@Interpretable("FilterJoinWith")
 public fun <A, B> DataFrame<A>.filterJoinWith(right: DataFrame<B>, joinExpression: JoinExpression<A, B>): DataFrame<A> =
     joinWithImpl(right, JoinType.Inner, addNewColumns = false, joinExpression)
 
+@Refine
+@Interpretable("ExcludeJoinWith")
 public fun <A, B> DataFrame<A>.excludeJoinWith(
     right: DataFrame<B>,
     joinExpression: JoinExpression<A, B>,

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/none.kt

@@ -3,7 +3,7 @@ package org.jetbrains.kotlinx.dataframe.api
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
 import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
-import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnsList
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnListImpl
 
 // region ColumnsSelectionDsl
 
@@ -71,7 +71,7 @@ public interface NoneColumnsSelectionDsl {
      *
      * @return An empty [ColumnsResolver].
      */
-    public fun none(): ColumnsResolver<*> = ColumnsList<Any?>(emptyList())
+    public fun none(): ColumnsResolver<*> = ColumnListImpl<Any?>(emptyList())
 }
 
 // endregion

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/constructors.kt

@@ -2,14 +2,14 @@ package org.jetbrains.kotlinx.dataframe.columns
 
 import org.jetbrains.kotlinx.dataframe.api.toColumnAccessor
 import org.jetbrains.kotlinx.dataframe.impl.asList
-import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnsList
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnListImpl
 import kotlin.reflect.KProperty
 
 // region toColumnSet
 
 // region Array
 
-public fun Array<out ColumnsResolver<*>>.toColumnSet(): ColumnSet<Any?> = ColumnsList(asList())
+public fun Array<out ColumnsResolver<*>>.toColumnSet(): ColumnSet<Any?> = ColumnListImpl(asList())
 
 @JvmName("toColumnSetString")
 public fun Array<out String>.toColumnSet(): ColumnSet<Any?> = map { it.toColumnAccessor() }.toColumnSet()
@@ -20,15 +20,15 @@ public fun Array<out ColumnPath>.toColumnSet(): ColumnSet<Any?> = map { it.toCol
 public fun <C> Array<out KProperty<C>>.toColumnSet(): ColumnSet<C> = map { it.toColumnAccessor() }.toColumnSet()
 
 @JvmName("toColumnSetC")
-public fun <C> Array<out ColumnsResolver<C>>.toColumnSet(): ColumnSet<C> = ColumnsList(asList())
+public fun <C> Array<out ColumnsResolver<C>>.toColumnSet(): ColumnSet<C> = ColumnListImpl(asList())
 
 public fun <C> Array<out ColumnReference<C>>.toColumnSet(): ColumnSet<C> = asIterable().toColumnSet()
 
 // endregion
 
 // region Iterable
 
-public fun Iterable<ColumnsResolver<*>>.toColumnSet(): ColumnSet<Any?> = ColumnsList(asList())
+public fun Iterable<ColumnsResolver<*>>.toColumnSet(): ColumnSet<Any?> = ColumnListImpl(asList())
 
 @JvmName("toColumnSetString")
 public fun Iterable<String>.toColumnSet(): ColumnSet<Any?> = map { it.toColumnAccessor() }.toColumnSet()
@@ -40,10 +40,10 @@ public fun Iterable<ColumnPath>.toColumnSet(): ColumnSet<Any?> = map { it.toColu
 public fun <C> Iterable<KProperty<C>>.toColumnSet(): ColumnSet<C> = map { it.toColumnAccessor() }.toColumnSet()
 
 @JvmName("toColumnSetC")
-public fun <C> Iterable<ColumnsResolver<C>>.toColumnSet(): ColumnSet<C> = ColumnsList(toList())
+public fun <C> Iterable<ColumnsResolver<C>>.toColumnSet(): ColumnSet<C> = ColumnListImpl(toList())
 
 @JvmName("toColumnSetColumnReference")
-public fun <C> Iterable<ColumnReference<C>>.toColumnSet(): ColumnSet<C> = ColumnsList(toList())
+public fun <C> Iterable<ColumnReference<C>>.toColumnSet(): ColumnSet<C> = ColumnListImpl(toList())
 
 // endregion
 

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/join.kt

@@ -18,31 +18,23 @@ import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
 import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
-import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
-import org.jetbrains.kotlinx.dataframe.impl.DataFrameReceiver
+import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnListImpl
 import org.jetbrains.kotlinx.dataframe.impl.columns.ColumnsList
 import org.jetbrains.kotlinx.dataframe.indices
 import org.jetbrains.kotlinx.dataframe.kind
 import org.jetbrains.kotlinx.dataframe.nrow
 import org.jetbrains.kotlinx.dataframe.type
 import kotlin.reflect.full.withNullability
 
-internal fun <A, B> defaultJoinColumns(left: DataFrame<A>, right: DataFrame<B>): JoinColumnsSelector<A, B> =
-    {
-        left.columnNames().intersect(right.columnNames().toSet())
-            .map { it.toColumnAccessor() }
-            .let { ColumnsList(it) }
-    }
-
 internal fun <T> defaultJoinColumns(dataFrames: Iterable<DataFrame<T>>): JoinColumnsSelector<T, T> =
     {
         dataFrames.map { it.columnNames() }
             .fold<List<String>, Set<String>?>(null) { set, names ->
                 set?.intersect(names.toSet()) ?: names.toSet()
             }.orEmpty()
             .map { it.toColumnAccessor() }
-            .let { ColumnsList(it) }
+            .let { ColumnListImpl(it) }
     }
 
 internal fun <C> ColumnsResolver<C>.extractJoinColumns(): List<ColumnMatch<C>> =
@@ -53,24 +45,13 @@ internal fun <C> ColumnsResolver<C>.extractJoinColumns(): List<ColumnMatch<C>> =
         else -> throw Exception()
     }
 
-internal fun <A, B> DataFrame<A>.getColumns(
-    other: DataFrame<B>,
-    selector: JoinColumnsSelector<A, B>,
-): List<ColumnMatch<Any?>> {
-    val receiver = object : DataFrameReceiver<A>(this, UnresolvedColumnsPolicy.Fail), JoinDsl<A, B> {
-        override val right: DataFrame<B> = DataFrameReceiver(other, UnresolvedColumnsPolicy.Fail)
-    }
-    val columns = selector(receiver, this)
-    return columns.extractJoinColumns()
-}
-
 internal fun <A, B> DataFrame<A>.joinImpl(
     other: DataFrame<B>,
     joinType: JoinType = JoinType.Inner,
     addNewColumns: Boolean = true,
     selector: JoinColumnsSelector<A, B>?,
 ): DataFrame<A> {
-    val joinColumns = getColumns(other, selector ?: defaultJoinColumns(this, other))
+    val joinColumns = JoinDsl.getColumns(this, other, selector ?: JoinDsl.defaultJoinColumns<A, B>(this, other))
 
     val leftJoinColumns = getColumnsWithPaths { joinColumns.map { it.left }.toColumnSet() }
     val rightJoinColumns = other.getColumnsWithPaths { joinColumns.map { it.right }.toColumnSet() }

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/ColumnsList.kt

@@ -4,7 +4,13 @@ import org.jetbrains.kotlinx.dataframe.columns.ColumnResolutionContext
 import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
 import org.jetbrains.kotlinx.dataframe.columns.ColumnsResolver
 
-internal class ColumnsList<C>(val columns: List<ColumnsResolver<C>>) : ColumnSet<C> {
+public interface ColumnsList<C> : ColumnSet<C> {
+    public val columns: List<ColumnsResolver<C>>
+}
+
+internal class ColumnListImpl<C>(override val columns: List<ColumnsResolver<C>>) :
+    ColumnSet<C>,
+    ColumnsList<C> {
     constructor(vararg columns: ColumnsResolver<C>) : this(columns.toList())
 
     override fun resolve(context: ColumnResolutionContext) = columns.flatMap { it.resolve(context) }