Update version to 1.4.2

Author: qiaoyuang

CHANGELOG.md

@@ -1,12 +1,25 @@
 # SQLlin Change Log
 
 - Date format: YYYY-MM-dd
-- 
-## v1.4.2 / 2025-xx-xx
+
+## v1.4.2 / 2025-04-23
+
+### All
+
+* Update `Kotlin`'s version to `2.1.20`
+
+### sqllin-dsl
+
+* Update `kotlinx.coroutines`'s version to `1.10.2`
+* Update `kotlinx.serialization`'s version to `1.8.1`
 
 ### sqllin-driver
 
-* Update the `sqlite-jdbc`'s version to `3.49.0.0`
+* Update the `sqlite-jdbc`'s version to `3.49.1.0`
+
+### sqllin-processor
+
+* Update `KSP`'s version to `2.1.20-1.0.32`
 
 ## v1.4.1 / 2025-02-04
 

gradle.properties

@@ -1,4 +1,4 @@
-VERSION=1.4.1
+VERSION=1.4.2
 GROUP=com.ctrip.kotlin
 
 #Maven Publish Information

gradle/libs.versions.toml

@@ -1,14 +1,14 @@
 [versions]
 
-kotlin = "2.1.10"
-agp = "8.7.3"
-ksp = "2.1.10-1.0.29"
-serialization = "1.8.0"
-coroutines = "1.10.1"
+kotlin = "2.1.20"
+agp = "8.9.2"
+ksp = "2.1.20-1.0.32"
+serialization = "1.8.1"
+coroutines = "1.10.2"
 androidx-annotation = "1.9.1"
 androidx-test = "1.6.1"
 androidx-test-runner = "1.6.2"
-sqlite-jdbc = "3.49.0.0"
+sqlite-jdbc = "3.49.1.0"
 
 [libraries]
 

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 #Tue Mar 08 15:11:46 CST 2022
 distributionBase=GRADLE_USER_HOME
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.12.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
 distributionPath=wrapper/dists
 zipStorePath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME

sqllin-dsl/doc/concurrency-safety-cn.md

@@ -1,15 +1,15 @@
 # 并发安全
 
 在 `1.2.2` 版本之前， _sqllin-dsl_ 无法保证并发安全。如果你想在不同的线程中共享同一个 `Database`
-对象，这可能会导致不可预测的结果。所以最佳的方式是：当你想要操作你的数据库时，创建一个 `Database`
-对象，当你结束的你的操作时，立即关闭它。
+实例，这可能会导致不可预测的结果。所以最佳的方式是：当你想要操作数据库时，创建一个 `Database`
+实例，而当你结束操作时立即关闭它。
 
-但是这非常不方便，我们总是必须频繁地创建数据库连接并关闭它，这是一种对资源的浪费。举例来说，
+但是这非常不方便，我们总是必须频繁地创建数据库连接并关闭，是一种对资源的浪费。举例来说，
 如果我们正在开发一款 Android app，并且在单个页面中（Activity/Fragment），我们希望我们可以持有一个
-`Database` 对象，当我们想要在后台线程（或协程）中操作数据库时，直接使用它，并在某些生命周期函数内关闭它
+`Database` 实例，当我们想要在后台线程（或协程）中操作数据库时直接使用它，并在某些生命周期函数内将它关闭
 （`onDestroy`、`onStop` 等等）。
 
-这种情况下，当我们在不同线程（或协程）中共享 `Database` 对象时，我们应该确保并发安全。所以，从 `1.2.2`
+这种情况下，当我们在不同线程（或协程）中共享 `Database` 实例时，我们应该确保并发安全。所以，从 `1.2.2`
 版本开始，我们可以使用新 API `Database#suspendedScope` 来代替旧的 `database {}` 用法。比如说，如果我们有如下旧代码：
 
 ```kotlin
@@ -26,7 +26,7 @@ fun sample() {
     }
 }
 ```
-我们使用新 API `Database#suspendedScope` 来代替旧的 `database {}` 后，将会是这样：
+我们使用新 API `Database#suspendedScope` 来代替旧 `database {}` 后，将会是这样：
 
 ```kotlin
 fun sample() {
@@ -42,8 +42,8 @@ fun sample() {
     }
 }
 ```
-`suspendedScope` 是一个挂起函数。在 `suspendedScope` 内部，所有的操作都是原子性的。这意味着：如果你共享了同一个
-`Database` 对象到不同的协程中，它可以保证后执行的 `suspendedScope` 会等待先执行的 `suspendedScope` 执行完成。
+`suspendedScope` 是一个挂起函数。在 `suspendedScope` 内部所有的操作都是原子性的。这意味着：如果你共享了同一个
+`Database` 实例到不同的协程中，它可以保证后执行的 `suspendedScope` 会等待先执行的 `suspendedScope` 执行完成。
 
 ## 接下来
 

sqllin-dsl/doc/concurrency-safety.md

@@ -1,19 +1,19 @@
 # Concurrency Safety
 
 Before the version `1.2.2`, _sqllin-dsl_ can't ensure the concurrency safety. If
-you want to share a `Database` object between different threads, that would lead to
+you want to share a `Database` instance between different threads, that would lead to
 unpredictable consequences. So, the best way is when you want to operate your
-database, create a `Database` object, and when you finish your operating, close it immediately.
+database, create a `Database` instance, and when you finish your operating, close it immediately.
 
 But, that's very inconvenient, we always have to create a database connection and
 close it frequently, this is a waste of resources. For example, if we are developing
 an Android app, and in a single page (Activity/Fragment), we hope we can keep a
-`Database` object, when we want to operate the database in background threads (or
+`Database` instance, when we want to operate the database in background threads (or
 coroutines), just use it, and, close it in certain lifecycle
 functions (`onDestroy`, `onStop`, etc.).
 
 At that time, we should make sure the concurrency safety that we share the `Database`
-object between different threads (or coroutines). So, start with the version `1.2.2`, we can
+instance between different threads (or coroutines). So, start with the version `1.2.2`, we can
 use the new API `Database#suspendedScope` to replace the usage of `database {}`. For
 example, if we have some old code:
 
@@ -49,7 +49,7 @@ fun sample() {
 ```
 
 The `suspendedScope` is a suspend function. Inside the `suspendedScope`, the all operations are
-atomic. That means: If you share the same `Database` object between two coroutines, it can ensure the
+atomic. That means: If you share the same `Database` instance between two coroutines, it can ensure the
 `suspendedScope` executing later will wait for the one executing earlier to finish.
 
 ## Next Step

sqllin-dsl/doc/getting-start-cn.md

@@ -14,7 +14,7 @@ plugins {
     id("com.google.devtools.ksp")
 }
 
-val sqllinVersion = "1.4.1"
+val sqllinVersion = "1.4.2"
 
 kotlin {
     // ......

sqllin-dsl/doc/getting-start.md

@@ -16,7 +16,7 @@ plugins {
     id("com.google.devtools.ksp")
 }
 
-val sqllinVersion = "1.4.1"
+val sqllinVersion = "1.4.2"
 
 kotlin {
     // ......
@@ -30,10 +30,10 @@ kotlin {
                 implementation("com.ctrip.kotlin:sqllin-driver:$sqllinVersion")
 
                 // The sqllin-dsl serialization and deserialization depends on kotlinx-serialization
-                implementation("org.jetbrains.kotlinx:kotlinx-serialization-core:1.8.0")
+                implementation("org.jetbrains.kotlinx:kotlinx-serialization-core:1.8.1")
 
                 // Since 1.2.2, sqllin-dsl depends on kotlinx.coroutines
-                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.1")
+                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2")
             }
         }
         // ......