improve transaction support

Author: codehz

src/easy_sqlite3/macros.nim

@@ -209,35 +209,57 @@ proc db_begin() {.importdb: "BEGIN".}
 proc db_commit() {.importdb: "COMMIT".}
 proc db_rollback() {.importdb: "ROLLBACK".}
 
-type Transaction*[Origin: ptr Database | ref Database] = object
-  origin: Origin
-  done: bool
-
-proc `=destroy`*[Origin: ptr Database | ref Database](tran: var Transaction[Origin]) =
-  assert tran.origin != nil
-  if not tran.done:
-    tran.origin[].db_rollback()
-
-proc `=copy`*[Origin: ptr Database | ref Database](tran: var Transaction[Origin], rhs: Transaction[Origin]) {.error.}
-
-proc initTransaction*(db: var Database): Transaction[ptr Database] =
-  db.db_begin()
-  result.origin = addr db
-  result.done = false
-
-proc initTransaction*(db: ref Database): Transaction[ref Database] =
-  db[].db_begin()
-  result.origin = db
-  result.done = false
-
-proc commit*[Origin: ptr Database | ref Database](tran: var Transaction[Origin]) =
-  assert tran.origin != nil
-  assert !tran.done
-  tran.done = true
-  tran.origin[].db_commit()
-
-proc rollback*[Origin: ptr Database | ref Database](tran: var Transaction[Origin]) =
-  assert tran.origin != nil
-  assert !tran.done
-  tran.done = true
-  tran.origin[].db_rollback()
+# type Transaction* = object
+#   origin: ptr Database
+
+# proc `=destroy`*(tran: var Transaction) =
+#   if tran.origin != nil:
+#     tran.origin[].db_rollback()
+
+# proc `=copy`*(tran: var Transaction, rhs: Transaction) {.error: "You should not copy transaction".}
+
+# proc initTransaction*(db: var Database): Transaction =
+#   db.db_begin()
+#   result.origin = addr db
+
+# proc commit*(tran: var Transaction) =
+#   if tran.origin != nil:
+#     tran.origin[].db_commit()
+#     wasMoved(tran)
+
+# proc rollback*(tran: var Transaction) =
+#   if tran.origin != nil:
+#     tran.origin[].db_rollback()
+#     wasMoved(tran)
+
+template transaction*(db: var Database, body: untyped): untyped =
+  db_begin db
+  block outer:
+    var cached_exception: ref Exception
+    block inner:
+      try:
+        template commit() {.inject, used.} =
+          try:
+            db_commit db
+            break outer
+          except:
+            cached_exception = getCurrentException()
+            break inner
+        template rollback() {.inject, used.} =
+          try:
+            db_rollback db
+            break outer
+          except:
+            cached_exception = getCurrentException()
+            break inner
+        body
+        try:
+          commit()
+        except:
+          cached_exception = getCurrentException()
+          break inner
+      except:
+        db_rollback db
+        raise getCurrentException()
+    if cached_exception != nil:
+      raise cached_exception

tests/test_basic.nim

@@ -6,7 +6,7 @@ import easy_sqlite3/[memfs, logfs]
 proc select_1(arg: int): tuple[value: int] {.importdb: "SELECT $arg".}
 
 proc create_table() {.importdb: """
-  CREATE TABLE mydata(name TEXT PRIMARY KEY NOT NULL, value INT NOT NULL);
+  CREATE TABLE mydata(name TEXT PRIMARY KEY NOT NULL, value INT NOT NULL) WITHOUT ROWID;
 """.}
 
 proc insert_data(name: string, value: int) {.importdb: """
@@ -17,6 +17,8 @@ iterator iterate_data(): tuple[name: string, value: int] {.importdb: """
   SELECT name, value FROM mydata;
 """.} = discard
 
+proc count_data(): tuple[count: int] {.importdb: "SELECT count(*) FROM mydata".}
+
 test "simple":
   var db = initDatabase(":memory:")
   check db.select_1(1) == (value: 1)
@@ -31,9 +33,11 @@ test "full":
   var db = initDatabase("test")
   db.exec "PRAGMA journal_mode=DELETE"
   db.create_table()
-  for name, value in dataset:
-    db.insert_data name, value
+  db.transaction:
+    for name, value in dataset:
+      db.insert_data name, value
   db.exec "VACUUM"
   for name, value in db.iterate_data():
     check name in dataset
-    check dataset[name] == value
+    check dataset[name] == value
+  check db.count_data() == (count: dataset.len)

tests/test_thread.nim

@@ -5,9 +5,21 @@ import easy_sqlite3/memfs
 
 const useMemFs = true
 
-when not useMemFs:
+when useMemFs:
+  template retry(body: untyped) = body
+else:
   enableSharedCache()
   var failedCount = 0
+  template retry(body: untyped) =
+    var failed = 0
+    while true:
+      try:
+        body
+        break
+      except:
+        failed.inc
+    if failed > 0:
+      failedCount.atomicInc(failed)
 
 proc create_table() {.importdb: """
   CREATE TABLE store(key INTEGER PRIMARY KEY, value INT NOT NULL);
@@ -30,52 +42,46 @@ var gdb = connectDatabase()
 gdb.create_table()
 gdb.exec "VACUUM"
 
-const COUNT = 100000
+const COUNT = 1000000
+const GROUP = 100
 
 proc worker_fn() {.thread.} =
   echo "thread start"
   var tdb = connectDatabase()
   var r = initRand(42)
-  for _ in 0..<COUNT:
-    let val = r.rand(1048576)
-    # increase the chance of collision
-    if val < 1024:
-      sleep(1)
-    when useMemFs:
-      tdb.insert_data(val)
-    else:
-      var failed = 0
-      block retry:
-        while true:
-          try:
-            tdb.insert_data(val)
-            break retry
-          except:
-            failed.inc
-      if failed > 0:
-        failedCount.atomicInc(failed)
+  for _ in 0..<(COUNT div GROUP):
+    retry:
+      tdb.transaction:
+        for _ in 0..<GROUP:
+          let val = r.rand(1048576)
+          # increase the chance of collision
+          if val < 1024:
+            sleep(1)
+          tdb.insert_data(val)
 
 var worker: Thread[void]
 createThread(worker, worker_fn)
 
 let init = cpuTime()
 var prev = init
 while true:
-  let c = gdb.count_items().count
+  var c: int
+  retry:
+    c = gdb.count_items().count
   let curr = cpuTime()
   let diff = curr - prev - 0.2
   if diff > 0:
     when useMemFs:
-      echo fmt"{curr - init:>6.1f}s: {c:<6}"
+      echo fmt"{curr - init:>6.1f}s: {c:>7}"
     else:
-      echo fmt"{curr - init:>6.1f}s: {c:<6} failures: {failedCount}"
+      echo fmt"{curr - init:>6.1f}s: {c:>7} failures: {failedCount}"
     prev = curr - diff
   if c == COUNT:
     break
 
 when useMemFs:
-  echo fmt"time: {cpuTime() - init:>9.5f}s"
+  echo fmt"time: {cpuTime() - init:>9.4f}s"
 else:
-  echo fmt"time: {cpuTime() - init:>9.5f}s failures: {failedCount}"
+  echo fmt"time: {cpuTime() - init:>9.4f}s failures: {failedCount}"
 
 worker.joinThread()