Fix bugs about null values and String elements

qiaoyuang · qiaoyuang · commit 5fbf0147f423 · 2024-04-23T14:39:47.000+08:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -2,6 +2,13 @@
 
 - Date format: YYYY-MM-dd
 
+## v1.3.1 / 2024-04-xx
+
+### sqllin-dsl
+
+* Fix a crash when a data class doesn't contain any `String` element.
+* Fix the [issue#81](https://github.com/ctripcorp/SQLlin/issues/81) about insert and query null values
+
 ## v1.3.0 / 2024-04-21
 
 ### All
diff --git a/sqllin-driver/src/androidMain/kotlin/com/ctrip/sqllin/driver/AndroidCursor.kt b/sqllin-driver/src/androidMain/kotlin/com/ctrip/sqllin/driver/AndroidCursor.kt
@@ -25,10 +25,33 @@ import android.database.Cursor
 
 internal class AndroidCursor(private val cursor: Cursor) : CommonCursor {
 
-    override fun getInt(columnIndex: Int): Int = cursor.getInt(columnIndex)
-    override fun getLong(columnIndex: Int): Long = cursor.getLong(columnIndex)
-    override fun getFloat(columnIndex: Int): Float = cursor.getFloat(columnIndex)
-    override fun getDouble(columnIndex: Int): Double = cursor.getDouble(columnIndex)
+    override fun getInt(columnIndex: Int): Int? = try {
+        cursor.getInt(columnIndex)
+    } catch (e: Exception) {
+        e.printStackTrace()
+        null
+    }
+
+    override fun getLong(columnIndex: Int): Long? = try {
+        cursor.getLong(columnIndex)
+    } catch (e: Exception) {
+        e.printStackTrace()
+        null
+    }
+
+    override fun getFloat(columnIndex: Int): Float? = try {
+        cursor.getFloat(columnIndex)
+    } catch (e: Exception) {
+        e.printStackTrace()
+        null
+    }
+
+    override fun getDouble(columnIndex: Int): Double? = try {
+        cursor.getDouble(columnIndex)
+    } catch (e: Exception) {
+        e.printStackTrace()
+        null
+    }
 
     override fun getString(columnIndex: Int): String? = try {
         cursor.getString(columnIndex)
diff --git a/sqllin-driver/src/commonMain/kotlin/com/ctrip/sqllin/driver/CommonCursor.kt b/sqllin-driver/src/commonMain/kotlin/com/ctrip/sqllin/driver/CommonCursor.kt
@@ -24,10 +24,10 @@ package com.ctrip.sqllin.driver
 @OptIn(ExperimentalStdlibApi::class)
 public interface CommonCursor : AutoCloseable {
 
-    public fun getInt(columnIndex: Int): Int
-    public fun getLong(columnIndex: Int): Long
-    public fun getFloat(columnIndex: Int): Float
-    public fun getDouble(columnIndex: Int): Double
+    public fun getInt(columnIndex: Int): Int?
+    public fun getLong(columnIndex: Int): Long?
+    public fun getFloat(columnIndex: Int): Float?
+    public fun getDouble(columnIndex: Int): Double?
     public fun getString(columnIndex: Int): String?
     public fun getByteArray(columnIndex: Int): ByteArray?
 
diff --git a/sqllin-driver/src/commonMain/kotlin/com/ctrip/sqllin/driver/Extension.kt b/sqllin-driver/src/commonMain/kotlin/com/ctrip/sqllin/driver/Extension.kt
@@ -93,7 +93,7 @@ internal fun DatabaseConnection.migrateIfNeeded(
 ) = withTransaction {
     val initialVersion = withQuery("PRAGMA user_version;") {
         it.next()
-        it.getInt(0)
+        it.getInt(0) ?: 0
     }
     if (initialVersion == 0) {
         create(this)
diff --git a/sqllin-driver/src/jvmMain/kotlin/com/ctrip/sqllin/driver/JdbcCursor.kt b/sqllin-driver/src/jvmMain/kotlin/com/ctrip/sqllin/driver/JdbcCursor.kt
@@ -24,13 +24,17 @@ import java.sql.ResultSet
  */
 internal class JdbcCursor(private val resultSet: ResultSet) : CommonCursor {
 
-    override fun getInt(columnIndex: Int): Int = resultSet.getInt(columnIndex + 1)
+    override fun getInt(columnIndex: Int): Int? =
+        resultSet.getInt(columnIndex + 1).takeUnless { resultSet.wasNull() }
 
-    override fun getLong(columnIndex: Int): Long = resultSet.getLong(columnIndex + 1)
+    override fun getLong(columnIndex: Int): Long? =
+        resultSet.getLong(columnIndex + 1).takeUnless { resultSet.wasNull() }
 
-    override fun getFloat(columnIndex: Int): Float = resultSet.getFloat(columnIndex + 1)
+    override fun getFloat(columnIndex: Int): Float? =
+        resultSet.getFloat(columnIndex + 1).takeUnless { resultSet.wasNull() }
 
-    override fun getDouble(columnIndex: Int): Double = resultSet.getDouble(columnIndex + 1)
+    override fun getDouble(columnIndex: Int): Double? =
+        resultSet.getDouble(columnIndex + 1).takeUnless { resultSet.wasNull() }
 
     override fun getString(columnIndex: Int): String? = resultSet.getString(columnIndex + 1)
 
diff --git a/sqllin-driver/src/nativeMain/kotlin/com/ctrip/sqllin/driver/ConcurrentStatement.kt b/sqllin-driver/src/nativeMain/kotlin/com/ctrip/sqllin/driver/ConcurrentStatement.kt
@@ -30,19 +30,19 @@ internal class ConcurrentStatement(
     private val accessLock: Lock,
 ) : SQLiteStatement {
 
-    override fun columnGetLong(columnIndex: Int): Long = accessLock.withLock {
+    override fun columnGetLong(columnIndex: Int): Long? = accessLock.withLock {
         delegateStatement.columnGetLong(columnIndex)
     }
 
-    override fun columnGetDouble(columnIndex: Int): Double = accessLock.withLock {
+    override fun columnGetDouble(columnIndex: Int): Double? = accessLock.withLock {
         delegateStatement.columnGetDouble(columnIndex)
     }
 
-    override fun columnGetString(columnIndex: Int): String = accessLock.withLock {
+    override fun columnGetString(columnIndex: Int): String? = accessLock.withLock {
         delegateStatement.columnGetString(columnIndex)
     }
 
-    override fun columnGetBlob(columnIndex: Int): ByteArray = accessLock.withLock {
+    override fun columnGetBlob(columnIndex: Int): ByteArray? = accessLock.withLock {
         delegateStatement.columnGetBlob(columnIndex)
     }
 
diff --git a/sqllin-driver/src/nativeMain/kotlin/com/ctrip/sqllin/driver/NativeCursor.kt b/sqllin-driver/src/nativeMain/kotlin/com/ctrip/sqllin/driver/NativeCursor.kt
@@ -25,17 +25,17 @@ internal class NativeCursor(
     private val statement: SQLiteStatement
 ) : CommonCursor {
 
-    override fun getInt(columnIndex: Int): Int = getLong(columnIndex).toInt()
+    override fun getInt(columnIndex: Int): Int? = getLong(columnIndex)?.toInt()
 
-    override fun getLong(columnIndex: Int): Long = statement.columnGetLong(columnIndex)
+    override fun getLong(columnIndex: Int): Long? = statement.columnGetLong(columnIndex)
 
-    override fun getFloat(columnIndex: Int): Float = getDouble(columnIndex).toFloat()
+    override fun getFloat(columnIndex: Int): Float? = getDouble(columnIndex)?.toFloat()
 
-    override fun getDouble(columnIndex: Int): Double = statement.columnGetDouble(columnIndex)
+    override fun getDouble(columnIndex: Int): Double? = statement.columnGetDouble(columnIndex)
 
-    override fun getString(columnIndex: Int): String = statement.columnGetString(columnIndex)
+    override fun getString(columnIndex: Int): String? = statement.columnGetString(columnIndex)
 
-    override fun getByteArray(columnIndex: Int): ByteArray = statement.columnGetBlob(columnIndex)
+    override fun getByteArray(columnIndex: Int): ByteArray? = statement.columnGetBlob(columnIndex)
 
     override fun getColumnIndex(columnName: String): Int = columnNames[columnName] ?: throw IllegalArgumentException("Col for $columnName not found")
 
diff --git a/sqllin-driver/src/nativeMain/kotlin/com/ctrip/sqllin/driver/SQLiteStatement.kt b/sqllin-driver/src/nativeMain/kotlin/com/ctrip/sqllin/driver/SQLiteStatement.kt
@@ -23,13 +23,13 @@ package com.ctrip.sqllin.driver
 
 internal interface SQLiteStatement {
 
-    fun columnGetLong(columnIndex: Int): Long
+    fun columnGetLong(columnIndex: Int): Long?
 
-    fun columnGetDouble(columnIndex: Int): Double
+    fun columnGetDouble(columnIndex: Int): Double?
 
-    fun columnGetString(columnIndex: Int): String
+    fun columnGetString(columnIndex: Int): String?
 
-    fun columnGetBlob(columnIndex: Int): ByteArray
+    fun columnGetBlob(columnIndex: Int): ByteArray?
 
     fun columnCount(): Int
 
diff --git a/sqllin-driver/src/nativeMain/kotlin/com/ctrip/sqllin/driver/cinterop/NativeStatement.kt b/sqllin-driver/src/nativeMain/kotlin/com/ctrip/sqllin/driver/cinterop/NativeStatement.kt
@@ -66,28 +66,31 @@ internal class NativeStatement(
 ) : SQLiteStatement {
 
     // Cursor methods
-    fun isNull(index: Int): Boolean =
+    private fun isNull(index: Int): Boolean =
         sqlite3_column_type(cStatementPointer, index) == SQLITE_NULL
 
-    override fun columnGetLong(columnIndex: Int): Long =
-        sqlite3_column_int64(cStatementPointer, columnIndex)
+    override fun columnGetLong(columnIndex: Int): Long? =
+        if (isNull(columnIndex)) null else sqlite3_column_int64(cStatementPointer, columnIndex)
 
-    override fun columnGetDouble(columnIndex: Int): Double =
-        sqlite3_column_double(cStatementPointer, columnIndex)
+    override fun columnGetDouble(columnIndex: Int): Double? =
+        if (isNull(columnIndex)) null else sqlite3_column_double(cStatementPointer, columnIndex)
 
-    override fun columnGetString(columnIndex: Int): String =
-        sqlite3_column_text(cStatementPointer, columnIndex)
-            ?.reinterpret<ByteVar>()
-            ?.let { bytesToString(it) }
-            ?: ""
+    override fun columnGetString(columnIndex: Int): String? =
+        if (isNull(columnIndex))
+            null
+        else
+            sqlite3_column_text(cStatementPointer, columnIndex)
+                ?.reinterpret<ByteVar>()
+                ?.let { bytesToString(it) }
 
-    override fun columnGetBlob(columnIndex: Int): ByteArray {
+    override fun columnGetBlob(columnIndex: Int): ByteArray? {
+        if (isNull(columnIndex))
+            return null
         val blobSize = sqlite3_column_bytes(cStatementPointer, columnIndex)
         return if (blobSize == 0)
-            byteArrayOf()
+            null
         else
             sqlite3_column_blob(cStatementPointer, columnIndex)?.readBytes(blobSize)
-                ?: throw sqliteException("Byte array size/type issue col $columnIndex")
     }
 
     override fun columnCount(): Int = sqlite3_column_count(cStatementPointer)
diff --git a/sqllin-dsl/src/commonMain/kotlin/com/ctrip/sqllin/dsl/sql/compiler/AbstractValuesEncoder.kt b/sqllin-dsl/src/commonMain/kotlin/com/ctrip/sqllin/dsl/sql/compiler/AbstractValuesEncoder.kt
@@ -17,6 +17,7 @@
 package com.ctrip.sqllin.dsl.sql.compiler
 
 import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.SerializationStrategy
 import kotlinx.serialization.descriptors.SerialDescriptor
 import kotlinx.serialization.encoding.AbstractEncoder
 import kotlinx.serialization.modules.EmptySerializersModule
@@ -44,8 +45,7 @@ internal abstract class AbstractValuesEncoder : AbstractEncoder() {
         get() = sqlStrBuilder.toString()
 
     override fun encodeElement(descriptor: SerialDescriptor, index: Int): Boolean {
-        if (index == 0)
-            elementsCount = descriptor.elementsCount
+        elementsCount = descriptor.elementsCount
         elementsIndex = index
         return true
     }
@@ -83,5 +83,19 @@ internal abstract class AbstractValuesEncoder : AbstractEncoder() {
         sqlStrBuilder.append(value).appendTail()
     }
 
+    override fun <T : Any> encodeNullableSerializableElement(
+        descriptor: SerialDescriptor,
+        index: Int,
+        serializer: SerializationStrategy<T>,
+        value: T?
+    ) {
+        if (value == null) {
+            elementsCount = descriptor.elementsCount
+            elementsIndex = index
+            sqlStrBuilder.append("NULL").appendTail()
+        } else
+            super.encodeNullableSerializableElement(descriptor, index, serializer, value)
+    }
+
     override fun encodeEnum(enumDescriptor: SerialDescriptor, index: Int) = encodeInt(index)
 }
diff --git a/sqllin-dsl/src/commonMain/kotlin/com/ctrip/sqllin/dsl/sql/compiler/QueryDecoder.kt b/sqllin-dsl/src/commonMain/kotlin/com/ctrip/sqllin/dsl/sql/compiler/QueryDecoder.kt
@@ -37,6 +37,7 @@ internal class QueryDecoder(
 
     private var elementIndex = 0
     private var elementName = ""
+    private var elementNotNullMark = true
 
     override val serializersModule: SerializersModule = EmptySerializersModule()
 
@@ -45,6 +46,7 @@ internal class QueryDecoder(
             CompositeDecoder.DECODE_DONE
         else {
             elementName = descriptor.getElementName(elementIndex)
+            elementNotNullMark = !descriptor.getElementDescriptor(elementIndex).isNullable
             val resultIndex = elementIndex++
             if (cursorColumnIndex >= 0)
                 resultIndex
@@ -57,22 +59,25 @@ internal class QueryDecoder(
     private inline val cursorColumnIndex
         get() = cursor.getColumnIndex(elementName)
 
+    private inline val sqlNullException
+        get() = IllegalStateException("The value in database is null, please declare your property be nullable")
+
     private inline fun <T> deserialize(block: (Int) -> T): T = cursorColumnIndex.let {
         if (it >= 0) block(it) else throw SerializationException("The Cursor doesn't have this column")
     }
 
-    override fun decodeBoolean(): Boolean = deserialize { cursor.getInt(it) > 0 }
-    override fun decodeByte(): Byte = deserialize { cursor.getInt(it).toByte() }
-    override fun decodeShort(): Short = deserialize { cursor.getInt(it).toShort() }
-    override fun decodeInt(): Int = deserialize { cursor.getInt(it) }
-    override fun decodeLong(): Long = deserialize { cursor.getLong(it) }
-    override fun decodeChar(): Char = deserialize { cursor.getString(it)?.first() ?: '\u0000' }
-    override fun decodeString(): String = deserialize { cursor.getString(it) ?: "" }
-    override fun decodeFloat(): Float = deserialize { cursor.getFloat(it) }
-    override fun decodeDouble(): Double = deserialize { cursor.getDouble(it) }
-    override fun decodeEnum(enumDescriptor: SerialDescriptor): Int = deserialize { cursor.getInt(it) }
+    override fun decodeBoolean(): Boolean = deserialize { (cursor.getInt(it) ?: throw sqlNullException) > 0 }
+    override fun decodeByte(): Byte = deserialize { cursor.getInt(it)?.toByte() ?: throw sqlNullException }
+    override fun decodeShort(): Short = deserialize { cursor.getInt(it)?.toShort() ?: throw sqlNullException }
+    override fun decodeInt(): Int = deserialize { cursor.getInt(it) ?: throw sqlNullException }
+    override fun decodeLong(): Long = deserialize { cursor.getLong(it) ?: throw sqlNullException }
+    override fun decodeChar(): Char = deserialize { cursor.getString(it)?.first() ?: throw sqlNullException }
+    override fun decodeString(): String = deserialize { cursor.getString(it) ?: throw sqlNullException }
+    override fun decodeFloat(): Float = deserialize { cursor.getFloat(it) ?: throw sqlNullException }
+    override fun decodeDouble(): Double = deserialize { cursor.getDouble(it) ?: throw sqlNullException }
+    override fun decodeEnum(enumDescriptor: SerialDescriptor): Int = deserialize { cursor.getInt(it) ?: throw sqlNullException }
 
-    override fun decodeNotNullMark(): Boolean = cursorColumnIndex >= 0
+    override fun decodeNotNullMark(): Boolean = elementNotNullMark
 
     // override fun decodeCollectionSize(descriptor: SerialDescriptor): Int {}
 }
diff --git a/sqllin-dsl/src/commonMain/kotlin/com/ctrip/sqllin/dsl/sql/operation/Insert.kt b/sqllin-dsl/src/commonMain/kotlin/com/ctrip/sqllin/dsl/sql/operation/Insert.kt
@@ -40,6 +40,6 @@ internal object Insert : Operation {
             append(' ')
             append(encodeEntities2InsertValues(table.kSerializer(), entities, parameters))
         }
-        return InsertStatement(sql, connection, parameters)
+        return InsertStatement(sql, connection, parameters.takeIf { it.isNotEmpty() })
     }
 }
diff --git a/sqllin-dsl/src/commonMain/kotlin/com/ctrip/sqllin/dsl/sql/statement/OtherStatement.kt b/sqllin-dsl/src/commonMain/kotlin/com/ctrip/sqllin/dsl/sql/statement/OtherStatement.kt
@@ -43,7 +43,7 @@ public class UpdateDeleteStatement internal constructor(
 public class InsertStatement internal constructor(
     sqlStr: String,
     private val connection: DatabaseConnection,
-    override val parameters: MutableList<String>,
+    override val parameters: MutableList<String>?,
 ) : SingleStatement(sqlStr) {
     public override fun execute(): Unit = connection.executeInsert(sqlStr, params)
 }
diff --git a/sqllin-dsl/src/commonTest/kotlin/com/ctrip/sqllin/dsl/CommonBasicTest.kt b/sqllin-dsl/src/commonTest/kotlin/com/ctrip/sqllin/dsl/CommonBasicTest.kt
@@ -24,7 +24,6 @@ import com.ctrip.sqllin.dsl.sql.clause.OrderByWay.ASC
 import com.ctrip.sqllin.dsl.sql.clause.OrderByWay.DESC
 import com.ctrip.sqllin.dsl.sql.statement.SelectStatement
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import kotlin.test.assertEquals

Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ internal fun DatabaseConnection.migrateIfNeeded(`
`93`	`93`	`) = withTransaction {`
`94`	`94`	`val initialVersion = withQuery("PRAGMA user_version;") {`
`95`	`95`	`it.next()`
`96`		`- it.getInt(0)`
	`96`	`+ it.getInt(0) ?: 0`
`97`	`97`	`}`
`98`	`98`	`if (initialVersion == 0) {`
`99`	`99`	`create(this)`
Original file line number	Diff line number	Diff line change
`@@ -30,19 +30,19 @@ internal class ConcurrentStatement(`
`30`	`30`	`private val accessLock: Lock,`
`31`	`31`	`) : SQLiteStatement {`
`32`	`32`
`33`		`- override fun columnGetLong(columnIndex: Int): Long = accessLock.withLock {`
	`33`	`+ override fun columnGetLong(columnIndex: Int): Long? = accessLock.withLock {`
`34`	`34`	`delegateStatement.columnGetLong(columnIndex)`
`35`	`35`	`}`
`36`	`36`
`37`		`- override fun columnGetDouble(columnIndex: Int): Double = accessLock.withLock {`
	`37`	`+ override fun columnGetDouble(columnIndex: Int): Double? = accessLock.withLock {`
`38`	`38`	`delegateStatement.columnGetDouble(columnIndex)`
`39`	`39`	`}`
`40`	`40`
`41`		`- override fun columnGetString(columnIndex: Int): String = accessLock.withLock {`
	`41`	`+ override fun columnGetString(columnIndex: Int): String? = accessLock.withLock {`
`42`	`42`	`delegateStatement.columnGetString(columnIndex)`
`43`	`43`	`}`
`44`	`44`
`45`		`- override fun columnGetBlob(columnIndex: Int): ByteArray = accessLock.withLock {`
	`45`	`+ override fun columnGetBlob(columnIndex: Int): ByteArray? = accessLock.withLock {`
`46`	`46`	`delegateStatement.columnGetBlob(columnIndex)`
`47`	`47`	`}`
`48`	`48`