clients/nim-allographer/src/allographer/query_builder/models/baradb/baradb_exec.nim src/barabadb/core/mvcc.nim src/barabadb/query/codegen.nim src/barabadb/query/lexer.nim src/barabadb/query/parser.nim src/barabadb/query/udf.nim tests/test_all.nim

clients/nim-allographer/src/allographer/query_builder/models/baradb/baradb_exec.nim

@@ -148,8 +148,8 @@ proc escapeSqlValue(val: JsonNode): string =
 proc formatSql*(sql: string, args: seq[JsonNode]): string =
   result = sql
   var placeholderCount = 0
-  for i in 0..<result.len:
-    if result[i] == '?':
+  for ch in result:
+    if ch == '?':
       placeholderCount += 1
   if placeholderCount != args.len:
     raise newException(DbError, "Placeholder count mismatch: expected " & $placeholderCount & " but got " & $args.len & " arguments")
@@ -438,6 +438,7 @@ proc exec(self: BaradbQuery, queryString: string) {.async.} =
   defer:
     if not self.isInTransaction:
       self.returnConn(connI).await
+    self.placeHolder = newJArray()
   if connI == errorConnectionNum:
     raisePoolTimeout(self)
 
@@ -475,6 +476,7 @@ proc insertId(self: BaradbQuery, queryString: string, key: string): Future[strin
   defer:
     if not self.isInTransaction:
       self.returnConn(connI).await
+    self.placeHolder = newJArray()
   if connI == errorConnectionNum:
     raisePoolTimeout(self)
 

src/barabadb/core/mvcc.nim

@@ -196,7 +196,7 @@ proc write*(tm: TxnManager, txn: Transaction, key: string, value: seq[byte]): bo
           if victimId in tm.activeTxns:
             tm.activeTxns[victimId].state = tsAborted
             tm.activeTxns.del(victimId)
-        tm.deadlockDetector.removeWait(uint64(txn.id), uint64(otherId))
+        # Keep the wait edge so subsequent transactions can detect cycles
         release(tm.lock)
         return false  # write-write conflict with uncommitted txn
 

src/barabadb/query/codegen.nim

@@ -1,5 +1,6 @@
 ## Codegen — compile IR plan to storage operations
 import std/strutils
+import ../core/types
 import ../query/ir
 
 type

src/barabadb/query/lexer.nim

@@ -547,11 +547,11 @@ proc readNumber(l: var Lexer, startLine, startCol: int): Token =
 proc readIdent(l: var Lexer, startLine, startCol: int): Token =
   var ident = ""
   while l.pos < l.input.len:
-    let r = l.peekRune()
+    var p = l.pos
+    var r: Rune
+    fastRuneAt(l.input, p, r, true)
     if isIdentPartRune(r):
-      var run: Rune
-      fastRuneAt(l.input, l.pos, run, true)
-      ident.add($run)
+      ident.add($r)
       inc l.col
       discard l.advanceRune()
     else:

src/barabadb/query/parser.nim

@@ -35,7 +35,7 @@ proc match(p: var Parser, kind: TokenKind): bool =
   return false
 
 # Token kinds that can also serve as identifiers in table/column name positions
-const identLikeKinds = {tkIdent, tkLabels, tkCount, tkSum, tkAvg, tkMin, tkMax, tkArrayAgg, tkStringAgg}
+const identLikeKinds = {tkIdent, tkLabels, tkCount, tkSum, tkAvg, tkMin, tkMax, tkArrayAgg, tkStringAgg, tkJsonFmt, tkArray, tkVector, tkGraph, tkDocument}
 
 proc expectIdent(p: var Parser): Token =
   ## Expect a token that can serve as an identifier (table name, column name, alias, etc.).
@@ -1154,16 +1154,21 @@ proc parseCreateTable(p: var Parser): Node =
     # Parse column definition
     let colName = p.expectIdent().value
     var colType = ""
-    if p.peek().kind == tkIdent:
-      colType = p.advance().value.toUpper()
-      if p.peek().kind == tkLParen:
-        discard p.advance()
-        let size = p.expect(tkIntLit).value
-        colType &= "(" & size & ")"
-        discard p.expect(tkRParen)
-    elif p.peek().kind == tkVector:
-      discard p.advance()
+    let typeKinds = {tkIdent, tkVector, tkJsonFmt, tkArray, tkDocument, tkGraph}
+    if p.peek().kind in typeKinds:
+      let typeTok = p.advance()
+      if typeTok.kind == tkVector:
         colType = "VECTOR"
+      elif typeTok.kind == tkJsonFmt:
+        colType = "JSON"
+      elif typeTok.kind == tkArray:
+        colType = "ARRAY"
+      elif typeTok.kind == tkDocument:
+        colType = "DOCUMENT"
+      elif typeTok.kind == tkGraph:
+        colType = "GRAPH"
+      else:
+        colType = typeTok.value.toUpper()
       if p.peek().kind == tkLParen:
         discard p.advance()
         let size = p.expect(tkIntLit).value

src/barabadb/query/udf.nim

@@ -191,7 +191,7 @@ proc registerStdlib*(reg: UDFRegistry) =
           let length = int(args[2].int64Val)
           let endIdx = min(start + length, s.len)
           return Value(kind: vkString, strVal: s[start ..< endIdx])
-        return Value(kind: vkString, strVal: s[start])
+        return Value(kind: vkString, strVal: s[start .. start])
       return Value(kind: vkNull))
 
   # Type conversion
@@ -240,11 +240,11 @@ proc registerStdlib*(reg: UDFRegistry) =
             else: discard
           elif (item.kind in {vkInt64, vkInt32, vkFloat64}) and
                (target.kind in {vkInt64, vkInt32, vkFloat64}):
-            let a = case item.kind of vkInt64: float64(item.int64Val)
-                    of vkInt32: float64(item.int32Val)
+            let a = if item.kind == vkInt64: float64(item.int64Val)
+                    elif item.kind == vkInt32: float64(item.int32Val)
                     else: item.float64Val
-            let b = case target.kind of vkInt64: float64(target.int64Val)
-                    of vkInt32: float64(target.int32Val)
+            let b = if target.kind == vkInt64: float64(target.int64Val)
+                    elif target.kind == vkInt32: float64(target.int32Val)
                     else: target.float64Val
             if a == b:
               return Value(kind: vkBool, boolVal: true)

tests/test_all.nim

@@ -1247,13 +1247,13 @@ suite "Sharding":
 
   test "Rebalance assigns nodes":
     var router = newShardRouter(ShardConfig(numShards: 3, replicas: 2, strategy: ssHash))
-    router.rebalance(@["node1", "node2", "node3"])
+    discard router.rebalance(@["node1", "node2", "node3"])
     for shard in router.shards:
       check shard.nodeIds.len == 2  # 2 replicas
 
   test "Replicas of key":
     var router = newShardRouter(ShardConfig(numShards: 2, replicas: 1, strategy: ssHash))
-    router.rebalance(@["n1", "n2"])
+    discard router.rebalance(@["n1", "n2"])
     let replicas = router.replicasOf("test_key")
     check replicas.len == 1
 
@@ -1989,7 +1989,7 @@ suite "Cluster Auto-Rebalance":
 
   test "Node fail re-assigns shards":
     var router = newShardRouter(ShardConfig(numShards: 4, replicas: 2))
-    router.rebalance(@["node1", "node2", "node3"])
+    discard router.rebalance(@["node1", "node2", "node3"])
     var cm = newClusterMembership(router)
     cm.nodes = @["node1", "node2", "node3"]
     cm.onNodeFail("node1")