feat: support boolean values encoded as text

status-go, owing to its use of a version of sqlcipher that uses a version of
sqlite previous to 3.23.0, sometimes inserts (“0”, 0, false, FALSE, “false”,
“FALSE”) or (“1”, 1, true, TRUE, “true”, “TRUE”) for boolean values in the
database. Here, we are able to properly decode text and integer encodings of
booleans in the database into Nim's `bool` type.

feat: add unit tests for sqlite boolean literals support

Author: Eric Mastro

sqlcipher.nimble

@@ -45,3 +45,4 @@ proc buildAndRunTest(name: string,
 
 task tests, "Run all tests":
   buildAndRunTest "db_smoke"
+  buildAndRunTest "sqlite_boolean_literals"

sqlcipher/tiny_sqlite.nim

@@ -1,4 +1,4 @@
-import std / [options, macros, typetraits], sequtils, unicode
+import std / [options, macros, typetraits], sequtils, unicode, strutils
 
 from sqlite_wrapper as sqlite import nil
 from stew/shims/macros as stew_macros import hasCustomPragmaFixed, getCustomPragmaFixed
@@ -179,7 +179,24 @@ proc toDbValues*(values: varargs[DbValue, toDbValue]): seq[DbValue] =
 
 proc fromDbValue*(value: DbValue, T: typedesc[Ordinal]): T =
     # Convert a DbValue to an ordinal.
-    value.intVal.T
+
+    ### START CUSTOM SUPPORT ###
+    # FOR STRING REPRESENTATIONS OF BOOLEANS.
+    # SQLITE VERSIONS <3.23.0 DID NOT AUTOMATICALLY TRANSLATE BOOLEAN
+    # LITERALS IN SQL SYNTAX TO 0/1. SEE https://sqlite.org/lang_expr.html
+    # (section 14) FOR MORE DETAIL.
+    when T is bool:
+        if (value.kind == sqliteText):
+            try:
+                result = value.strVal.toLower.parseBool
+            except ValueError as ve:
+                ve.msg = "Error parsing string value into boolean: " & ve.msg
+                raise ve
+        else:
+            result = value.intVal.T
+    else:
+        ### END CUSTOM SUPPORT ###
+        value.intVal.T
 
 proc fromDbValue*(value: DbValue, T: typedesc[SomeFloat]): float64 =
     ## Convert a DbValue to a float.

test/sqlite_boolean_literals.nim

@@ -0,0 +1,172 @@
+import # nim libs
+  options, os, unittest, strformat
+
+import # vendor libs
+  ../sqlcipher
+
+type
+  BoolTest* {.dbTableName("boolTest").} = object
+    testId* {.dbColumnName("testId").}: string
+    boolCol1* {.dbColumnName("boolCol1").}: bool
+    boolCol2* {.dbColumnName("boolCol2").}: bool
+    boolCol3* {.dbColumnName("boolCol3").}: Option[bool]
+  SqliteBool = bool | int | string | Option[bool]
+
+proc createBoolTable(db: DbConn) =
+  var boolTest: BoolTest
+  db.exec(fmt"""CREATE TABLE {boolTest.tableName} (
+      {boolTest.testId.columnName} VARCHAR NOT NULL PRIMARY KEY,
+      {boolTest.boolCol1.columnName} BOOLEAN,
+      {boolTest.boolCol2.columnName} BOOLEAN DEFAULT TRUE,
+      {boolTest.boolCol3.columnName} BOOLEAN
+    )""")
+
+proc getBoolRow(db: DbConn, testId: string): BoolTest =
+  var boolTest: BoolTest
+  let query = fmt"""SELECT * FROM {boolTest.tableName} WHERE {boolTest.testId.columnName} = ?"""
+  let resultOption = db.one(BoolTest, query, testId)
+  if resultOption.isNone:
+    raise newException(ValueError, fmt"Failed to get row with testId '{testId}'")
+  resultOption.get()
+
+proc insertBoolRowString(db: DbConn, testId: string, bool1: SqliteBool, bool2: SqliteBool, bool3: Option[SqliteBool]): BoolTest =
+  var boolTest: BoolTest
+  let bool3Param = if bool3.isNone: "null" else: fmt"'{bool3.get}'"
+  db.execScript(fmt"""INSERT INTO {boolTest.tableName} VALUES ('{testId}', '{bool1}', '{bool2}', {bool3Param});""")
+  db.getBoolRow(testId)
+
+proc insertBoolRowString(db: DbConn, testId: string, bool1: SqliteBool, bool3: Option[SqliteBool]): BoolTest =
+  var boolTest: BoolTest
+  let bool3Param = if bool3.isNone: "null" else: fmt"'{bool3.get}'"
+  db.execScript(fmt"""
+    INSERT INTO {boolTest.tableName} (
+      {boolTest.testId.columnName}, {boolTest.boolCol1.columnName}, {boolTest.boolCol3.columnName}
+    )
+    VALUES (
+      '{testId}', '{bool1}', {bool3Param}
+    );""")
+  db.getBoolRow(testId)
+
+proc insertBoolRowInt(db: DbConn, testId: string, bool1: SqliteBool, bool2: SqliteBool, bool3: Option[SqliteBool]): BoolTest =
+  var boolTest: BoolTest
+  let bool3Param = if bool3.isNone: "null" else: fmt"{bool3.get}"
+  db.execScript(fmt"""INSERT INTO {boolTest.tableName} VALUES ('{testId}', {bool1}, {bool2}, {bool3Param});""")
+  db.getBoolRow(testId)
+
+proc insertBoolRowInt(db: DbConn, testId: string, bool1: SqliteBool, bool3: Option[SqliteBool]): BoolTest =
+  var boolTest: BoolTest
+  let bool3Param = if bool3.isNone: "null" else: fmt"{bool3.get}"
+  db.execScript(fmt"""INSERT INTO {boolTest.tableName} ({boolTest.testId.columnName}, {boolTest.boolCol1.columnName}, {boolTest.boolCol3.columnName}) VALUES ('{testId}', {bool1}, {bool3Param});""")
+  db.getBoolRow(testId)
+
+proc insertBoolRowBool(db: DbConn, testId: string, bool1: SqliteBool, bool2: SqliteBool, bool3: Option[SqliteBool]): BoolTest =
+  var boolTest: BoolTest
+  db.exec(fmt"""INSERT INTO {boolTest.tableName} VALUES (?, ?, ?, ?);""", testId, bool1, bool2, bool3)
+  db.getBoolRow(testId)
+
+proc insertBoolRowBool(db: DbConn, testId: string, bool1: SqliteBool, bool3: Option[SqliteBool]): BoolTest =
+  var boolTest: BoolTest
+  db.exec(fmt"""INSERT INTO {boolTest.tableName} ({boolTest.testId.columnName}, {boolTest.boolCol1.columnName}, {boolTest.boolCol3.columnName}) VALUES (?, ?, ?);""", testId, bool1, bool3)
+  db.getBoolRow(testId)
+
+suite "sqlite_booleans":
+  let password = "qwerty"
+  let path = currentSourcePath.parentDir() & "/build/my.db"
+  removeFile(path)
+  let db = openDatabase(path)
+  db.key(password)
+  debugEcho "creating bool test table"
+  db.createBoolTable()
+  
+  test "using nim boolean types":
+    let falseFalseNone1 = db.insertBoolRowBool("falseFalseNone1", false, false, bool.none)
+    let falseTrueFalse1 = db.insertBoolRowBool("falseTrueFalse1", false, false.some)
+    let trueFalseNone1 = db.insertBoolRowBool("trueFalseNone1", true, false, bool.none)
+    let trueTrueTrue1 = db.insertBoolRowBool("trueTrueTrue1", true, true.some)
+
+    check:
+      falseFalseNone1 == BoolTest(testId: "falseFalseNone1", boolCol1: false, boolCol2: false, boolCol3: bool.none)
+      falseTrueFalse1 == BoolTest(testId: "falseTrueFalse1", boolCol1: false, boolCol2: true, boolCol3: false.some)
+      trueFalseNone1 == BoolTest(testId: "trueFalseNone1", boolCol1: true, boolCol2: false, boolCol3: bool.none)
+      trueTrueTrue1 == BoolTest(testId: "trueTrueTrue1", boolCol1: true, boolCol2: true, boolCol3: true.some)
+
+  test "using strings":
+    let falseFalseNone2 = db.insertBoolRowString("falseFalseNone2", "false", "false", string.none)
+    let falseTrueFalse2 = db.insertBoolRowString("falseTrueFalse2", "false", "false".some)
+    let trueFalseNone2 = db.insertBoolRowString("trueFalseNone2", "true", "false", string.none)
+    let trueTrueTrue2 = db.insertBoolRowString("trueTrueTrue2", "true", "true".some)
+    
+    check:
+      falseFalseNone2 == BoolTest(testId: "falseFalseNone2", boolCol1: false, boolCol2: false, boolCol3: bool.none)
+      falseTrueFalse2 == BoolTest(testId: "falseTrueFalse2", boolCol1: false, boolCol2: true, boolCol3: false.some)
+      trueFalseNone2 == BoolTest(testId: "trueFalseNone2", boolCol1: true, boolCol2: false, boolCol3: bool.none)
+      trueTrueTrue2 == BoolTest(testId: "trueTrueTrue2", boolCol1: true, boolCol2: true, boolCol3: true.some)
+      
+
+  test "using uppercase strings":
+    let falseFalseNone3 = db.insertBoolRowString("falseFalseNone3", "FALSE", "FALSE", string.none)
+    let falseTrueFalse3 = db.insertBoolRowString("falseTrueFalse3", "FALSE", "FALSE".some)
+    let trueFalseNone3 = db.insertBoolRowString("trueFalseNone3", "TRUE", "FALSE", string.none)
+    let trueTrueTrue3 = db.insertBoolRowString("trueTrueTrue3", "TRUE", "TRUE".some)
+
+    check:
+      falseFalseNone3 == BoolTest(testId: "falseFalseNone3", boolCol1: false, boolCol2: false, boolCol3: bool.none)
+      falseTrueFalse3 == BoolTest(testId: "falseTrueFalse3", boolCol1: false, boolCol2: true, boolCol3: false.some)
+      trueFalseNone3 == BoolTest(testId: "trueFalseNone3", boolCol1: true, boolCol2: false, boolCol3: bool.none)
+      trueTrueTrue3 == BoolTest(testId: "trueTrueTrue3", boolCol1: true, boolCol2: true, boolCol3: true.some)
+
+
+  test "using ints":
+    let falseFalseNone4 = db.insertBoolRowInt("falseFalseNone4", 0, 0, int.none)
+    let falseTrueFalse4 = db.insertBoolRowInt("falseTrueFalse4", 0, 0.some)
+    let trueFalseNone4 = db.insertBoolRowInt("trueFalseNone4", 1, 0, int.none)
+    let trueTrueTrue4 = db.insertBoolRowInt("trueTrueTrue4", 1, 1.some)
+
+    check:
+      falseFalseNone4 == BoolTest(testId: "falseFalseNone4", boolCol1: false, boolCol2: false, boolCol3: bool.none)
+      falseTrueFalse4 == BoolTest(testId: "falseTrueFalse4", boolCol1: false, boolCol2: true, boolCol3: false.some)
+      trueFalseNone4 == BoolTest(testId: "trueFalseNone4", boolCol1: true, boolCol2: false, boolCol3: bool.none)
+      trueTrueTrue4 == BoolTest(testId: "trueTrueTrue4", boolCol1: true, boolCol2: true, boolCol3: true.some)
+
+  test "using string ints":
+    let falseFalseNone5 = db.insertBoolRowString("falseFalseNone5", "0", "0", string.none)
+    let falseTrueFalse5 = db.insertBoolRowString("falseTrueFalse5", "0", "0".some)
+    let trueFalseNone5 = db.insertBoolRowString("trueFalseNone5", "1", "0", string.none)
+    let trueTrueTrue5 = db.insertBoolRowString("trueTrueTrue5", "1", "1".some)
+
+    check:
+      falseFalseNone5 == BoolTest(testId: "falseFalseNone5", boolCol1: false, boolCol2: false, boolCol3: bool.none)
+      falseTrueFalse5 == BoolTest(testId: "falseTrueFalse5", boolCol1: false, boolCol2: true, boolCol3: false.some)
+      trueFalseNone5 == BoolTest(testId: "trueFalseNone5", boolCol1: true, boolCol2: false, boolCol3: bool.none)
+      trueTrueTrue5 == BoolTest(testId: "trueTrueTrue5", boolCol1: true, boolCol2: true, boolCol3: true.some)
+
+  # Nim's standard lib strutils.parseBool supports yes/no and on/off, see
+  # https://nim-lang.org/docs/strutils.html#parseBool%2Cstring for more information.
+  # The following tests are just to illustrate support for these values, as well.
+
+  test "using yes/no":
+    let falseFalseNone6 = db.insertBoolRowString("falseFalseNone6", "no", "no", string.none)
+    let falseTrueFalse6 = db.insertBoolRowString("falseTrueFalse6", "no", "no".some)
+    let trueFalseNone6 = db.insertBoolRowString("trueFalseNone6", "yes", "no", string.none)
+    let trueTrueTrue6 = db.insertBoolRowString("trueTrueTrue6", "yes", "yes".some)
+
+    check:
+      falseFalseNone6 == BoolTest(testId: "falseFalseNone6", boolCol1: false, boolCol2: false, boolCol3: bool.none)
+      falseTrueFalse6 == BoolTest(testId: "falseTrueFalse6", boolCol1: false, boolCol2: true, boolCol3: false.some)
+      trueFalseNone6 == BoolTest(testId: "trueFalseNone6", boolCol1: true, boolCol2: false, boolCol3: bool.none)
+      trueTrueTrue6 == BoolTest(testId: "trueTrueTrue6", boolCol1: true, boolCol2: true, boolCol3: true.some)
+
+  test "using on/off":
+    let falseFalseNone7 = db.insertBoolRowString("falseFalseNone7", "off", "off", string.none)
+    let falseTrueFalse7 = db.insertBoolRowString("falseTrueFalse7", "off", "off".some)
+    let trueFalseNone7 = db.insertBoolRowString("trueFalseNone7", "on", "off", string.none)
+    let trueTrueTrue7 = db.insertBoolRowString("trueTrueTrue7", "on", "on".some)
+
+    check:
+      falseFalseNone7 == BoolTest(testId: "falseFalseNone7", boolCol1: false, boolCol2: false, boolCol3: bool.none)
+      falseTrueFalse7 == BoolTest(testId: "falseTrueFalse7", boolCol1: false, boolCol2: true, boolCol3: false.some)
+      trueFalseNone7 == BoolTest(testId: "trueFalseNone7", boolCol1: true, boolCol2: false, boolCol3: bool.none)
+      trueTrueTrue7 == BoolTest(testId: "trueTrueTrue7", boolCol1: true, boolCol2: true, boolCol3: true.some)
+
+  db.close()
+  removeFile(path)