Merge pull request zaleslaw#5 from zaleslaw/Beta-3

Upgrade to the Beta-3

Author: zaleslaw

build.gradle.kts

@@ -1,8 +1,9 @@
 import java.util.*
 
 plugins {
-    kotlin("jvm") version "2.0.0"
-    id("org.jetbrains.kotlinx.dataframe") version "1.0.0-Beta2"
+    kotlin("jvm") version "2.2.20"
+    kotlin("plugin.dataframe") version "2.2.20"
+    id("org.jetbrains.kotlinx.dataframe") version "1.0.0-Beta3"
 }
 
 group = "org.jetbrains.kotlinx.dataframe.examples"
@@ -13,7 +14,7 @@ repositories {
 }
 
 dependencies {
-    implementation ("org.jetbrains.kotlinx:dataframe:1.0.0-Beta2")
+    implementation ("org.jetbrains.kotlinx:dataframe:1.0.0-Beta3")
     implementation ("org.jetbrains.kotlinx:kandy-lets-plot:0.8.1-dev-67")
     implementation ("org.jetbrains.kotlinx:kandy-api:0.8.1-dev-67")
     implementation ("org.mariadb.jdbc:mariadb-java-client:3.5.4")
@@ -22,41 +23,9 @@ dependencies {
     testImplementation(kotlin("test"))
 }
 
-val props = Properties()
-file("local.properties").inputStream().use { props.load(it) }
-
-dataframes {
-    schema {
-        data = "jdbc:mariadb://localhost:3307/imdb"
-        name = "org.jetbrains.kotlinx.dataframe.examples.jdbc.Actors"
-        jdbcOptions {
-            user = props.getProperty("db.user")
-            password = props.getProperty("db.password")
-            tableName = "actors"
-        }
-    }
-    schema {
-        data = "jdbc:mariadb://localhost:3307/imdb"
-        name = "org.jetbrains.kotlinx.dataframe.examples.jdbc.TarantinoFilms"
-        jdbcOptions {
-            user = System.getenv("DB_USER") ?: props.getProperty("db.user")
-            password = System.getenv("DB_PASSWORD") ?: props.getProperty("db.password")
-            sqlQuery = """
-                SELECT name, year, rank,
-                GROUP_CONCAT (genre) as "genres"
-                FROM movies JOIN movies_directors ON movie_id = movies.id
-                JOIN directors ON directors.id=director_id LEFT JOIN movies_genres ON movies.id = movies_genres.movie_id
-                WHERE directors.first_name = "Quentin" AND directors.last_name = "Tarantino"
-                GROUP BY name, year, rank
-                ORDER BY year
-                """
-        }
-    }
-}
-
 tasks.test {
     useJUnitPlatform()
 }
 kotlin {
-    jvmToolchain(11)
+    jvmToolchain(17)
 }

gradle.properties

@@ -1 +1,4 @@
 kotlin.code.style=official
+ksp.useKSP2=false
+kotlin.dataframe.add.ksp=false
+kotlin.incremental=false

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,5 @@
-
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.0.0-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

local.properties

@@ -1,2 +1,3 @@
 db.user=root
-db.password=pass
+db.password=pass
+db.url=jdbc:mariadb://localhost:3307/imdb

notebooks/imdb.ipynb

@@ -2,29 +2,38 @@ package org.jetbrains.kotlinx.dataframe.examples.jdbc
 
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.add
 import org.jetbrains.kotlinx.dataframe.api.describe
 import org.jetbrains.kotlinx.dataframe.api.select
 import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.filter
 import org.jetbrains.kotlinx.dataframe.api.sortByDesc
 import org.jetbrains.kotlinx.dataframe.api.print
 import org.jetbrains.kotlinx.dataframe.api.take
+import org.jetbrains.kotlinx.dataframe.api.generateInterfaces
 import org.jetbrains.kotlinx.dataframe.io.readSqlTable
 import org.jetbrains.kotlinx.dataframe.io.DbConnectionConfig
 
 @DataSchema
 interface Movies {
     val id: Int
     val name: String
-    val year: Int
     val rank: Float?
+    val year: Int
 }
 
 fun main() {
     // define the database configuration
     val dbConfig = DbConnectionConfig(URL, USER_NAME, PASSWORD)
 
     // read the table
-    val movies = DataFrame.readSqlTable(dbConfig, TABLE_NAME_MOVIES, 10000).cast<Movies>(verify=true)
+    val df = DataFrame.readSqlTable(dbConfig, TABLE_NAME_MOVIES, 10000)
+
+    // generate Kotlin data classes or interfaces for the table schema
+    // added as [Movies] interface above main() function
+    df.generateInterfaces("Movies").print()
+
+    val movies = df.cast<Movies>(verify = true)
 
     // print the dataframe
     movies.print()
@@ -33,8 +42,19 @@ fun main() {
     movies.describe().print()
 
     // print names of top-10 rated films
-    movies.sortByDesc { rank }
+    movies
+        .sortByDesc { rank }
         .take(10)
         .select { name }
         .print()
+
+    // add columns to the dataframe on-the-fly
+    movies
+        .sortByDesc { rank }
+        .select { name and year }
+        .add("oldFilm") { year < 1973 }
+        .add("containsReward") { name.contains("Reward") }
+        .filter { oldFilm and containsReward }
+        .take(10)
+        .print()
 }

…tlin/Example_1_Define_schema_manually.kt src/main/kotlin/Example_1_Add_Column.ktsrc/main/kotlin/Example_1_Define_schema_manually.kt renamed to src/main/kotlin/Example_1_Add_Column.kt src/main/kotlin/Example_1_Define_schema_manually.kt renamed to src/main/kotlin/Example_1_Add_Column.kt

@@ -1,52 +1,67 @@
-@file:ImportDataSchema(
-    "Directors",
-    URL,
-    jdbcOptions = JdbcOptions(USER_NAME, PASSWORD, tableName = TABLE_NAME_DIRECTORS)
-)
-
-@file:ImportDataSchema(
-    "NewActors",
-    URL,
-    jdbcOptions = JdbcOptions(USER_NAME, PASSWORD, sqlQuery = ACTORS_IN_LATEST_MOVIES)
-)
-
 package org.jetbrains.kotlinx.dataframe.examples.jdbc
 
 import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.annotations.ImportDataSchema
-import org.jetbrains.kotlinx.dataframe.annotations.JdbcOptions
+import org.jetbrains.kotlinx.dataframe.annotations.ColumnName
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
 import org.jetbrains.kotlinx.dataframe.api.cast
 import org.jetbrains.kotlinx.dataframe.api.filter
 import org.jetbrains.kotlinx.dataframe.api.print
 import org.jetbrains.kotlinx.dataframe.api.groupBy
 import org.jetbrains.kotlinx.dataframe.api.count
+import org.jetbrains.kotlinx.dataframe.api.generateInterfaces
 import org.jetbrains.kotlinx.dataframe.io.readSqlQuery
 import org.jetbrains.kotlinx.dataframe.io.readSqlTable
 import org.jetbrains.kotlinx.dataframe.api.take
 import org.jetbrains.kotlinx.dataframe.io.DbConnectionConfig
 
+@DataSchema
+interface Directors {
+    @ColumnName("first_name")
+    val firstName: String
+    val id: Int
+    @ColumnName("last_name")
+    val lastName: String
+}
+
+@DataSchema
+interface Actors {
+    @ColumnName("first_name")
+    val firstName: String
+    @ColumnName("last_name")
+    val lastName: String
+    val name: String
+    val role: String
+    val year: Int
+}
+
 fun main() {
     // Part 1: Reading the table `directors`
 
     // define the database configuration
     val dbConfig = DbConnectionConfig(URL, USER_NAME, PASSWORD)
 
     // read the table
-    val directors = DataFrame.readSqlTable(dbConfig, TABLE_NAME_DIRECTORS, 1000).cast<Directors>()
+    val df1 = DataFrame.readSqlTable(dbConfig, TABLE_NAME_DIRECTORS, 1000)
+    df1.generateInterfaces("Directors").print()
+
+    val directors = df1.cast<Directors>()
 
     // manipulate and print
-    directors.filter { firstName != null && firstName!!.contains("A") }
+    directors.filter { firstName.contains("A") }
         .take(10)
         .print()
 
     // Part 2: Handle the table results of an SQL query
 
     // read the data
-    val newActors = DataFrame.readSqlQuery(dbConfig, ACTORS_IN_LATEST_MOVIES).cast<NewActors>()
-    newActors.print()
+    val df2 = DataFrame.readSqlQuery(dbConfig, ACTORS_IN_LATEST_MOVIES)
+    df2.generateInterfaces("Actors").print()
+
+    val actors = df2.cast<Actors>()
+    actors.print()
 
     // build a report of different roles' popularity
-    newActors.groupBy { role }
+    actors.groupBy { role }
         .count()
         .print()
 }

…in/Example_2_Import_schema_annotation.kt …lin/Example_2_Import_SQL_Query_Result.ktsrc/main/kotlin/Example_2_Import_schema_annotation.kt renamed to src/main/kotlin/Example_2_Import_SQL_Query_Result.kt src/main/kotlin/Example_2_Import_schema_annotation.kt renamed to src/main/kotlin/Example_2_Import_SQL_Query_Result.kt

@@ -3,9 +3,11 @@ package org.jetbrains.kotlinx.dataframe.examples.jdbc
 import java.sql.DriverManager
 import java.util.Properties
 import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
 import org.jetbrains.kotlinx.dataframe.api.cast
 import org.jetbrains.kotlinx.dataframe.api.describe
 import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.generateInterfaces
 import org.jetbrains.kotlinx.dataframe.api.print
 import org.jetbrains.kotlinx.dataframe.io.db.MySql
 import org.jetbrains.kotlinx.dataframe.io.getSchemaForResultSet
@@ -16,22 +18,14 @@ import org.jetbrains.kotlinx.dataframe.io.readResultSet
 import org.jetbrains.kotlinx.dataframe.io.readSqlQuery
 import org.jetbrains.kotlinx.dataframe.io.readSqlTable
 
-/**
- * For this example, the schema importing was configured in Gradle in the
- * ```kotlin
- * dataframes {
- *     schema {
- *       ...
- *   }
- * }
- * ```
- * section.
- *
- * Open the `build.gradle.kts` to see or edit.
- *
- * NOTE: The idea of this example is to cover more available functionality
- * and demonstrate different ways to establish connection to the database.
- */
+@DataSchema
+interface TarantinoFilms {
+    val genres: String?
+    val name: String
+    val rank: Float?
+    val year: Int
+}
+
 fun main() {
     val props = Properties()
     props.setProperty("user", USER_NAME)
@@ -42,12 +36,10 @@ fun main() {
     DriverManager.getConnection(URL, props).use { connection ->
         // read the data from the SQL table
         val actors = DataFrame.readSqlTable(connection, TABLE_NAME_ACTORS, 100).cast<Actors>()
-
-        // TODO: .cast<Actors>(verify=true)
         actors.print()
 
         // filter and print the data
-        actors.filter { firstName!=null && firstName!!.contains("J") }.print()
+        actors.filter { firstName.contains("J") }.print()
 
         // extract the schema of the SQL table
         val actorSchema = DataFrame.getSchemaForSqlTable(connection, TABLE_NAME_ACTORS)
@@ -58,12 +50,15 @@ fun main() {
     println("---------------------------- Part 2: SQL Query ------------------------------------")
     DriverManager.getConnection(URL, props).use { connection ->
         // read the data from as a result of an executed SQL query
-        val tarantinoFilms = DataFrame.readSqlQuery(connection, TARANTINO_FILMS_SQL_QUERY, 100).cast<TarantinoFilms>()
-        //TODO: .cast<TarantinoFilms>(verify=true)
+        val tarantinoFilmsUntyped = DataFrame.readSqlQuery(connection, TARANTINO_FILMS_SQL_QUERY, 100)
+        tarantinoFilmsUntyped.generateInterfaces("TarantinoFilms").print()
+
+        val tarantinoFilms = tarantinoFilmsUntyped.cast<TarantinoFilms>()
+
         tarantinoFilms.print()
 
         // transform and print the data
-        tarantinoFilms.filter { year != null && year!! > 2000 }.print()
+        tarantinoFilms.filter { year > 2000 }.print()
 
         // extract the schema of the SQL table
         val tarantinoFilmsSchema = DataFrame.getSchemaForSqlQuery(connection, TARANTINO_FILMS_SQL_QUERY)
@@ -77,10 +72,10 @@ fun main() {
             st.executeQuery(TARANTINO_FILMS_SQL_QUERY).use { rs ->
                 // read the data from as a result of an executed SQL query
                 val tarantinoFilms = DataFrame.readResultSet(rs, dbType = MySql, 100).cast<TarantinoFilms>()
-                // TODO: .cast<TarantinoFilms>(verify=true)
+
                 tarantinoFilms.print()
                 // transform and print the data
-                tarantinoFilms.filter { year!= null && year!! > 2000 }.print()
+                tarantinoFilms.filter { year > 2000 }.print()
 
                 // extract the schema of the SQL table
                 val tarantinoFilmsSchema = DataFrame.getSchemaForResultSet(rs, dbType = MySql)

…in/Example_3_Import_schema_via_Gradle.kt …in/kotlin/Example_3_API_Demonstration.ktsrc/main/kotlin/Example_3_Import_schema_via_Gradle.kt renamed to src/main/kotlin/Example_3_API_Demonstration.kt src/main/kotlin/Example_3_Import_schema_via_Gradle.kt renamed to src/main/kotlin/Example_3_API_Demonstration.kt

@@ -25,7 +25,7 @@ fun main() {
             .renameToCamelCase()
             .cast<Orders>(verify = true)
 
-        df.filter { it.price > 800 }.print()
+       // df.filter { it.price > 800 }.print()
 
         removeTable(con)
     }