common statements

Signed-off-by: George Lemon <georgelemon@protonmail.com>

Author: georgelemon

src/ozark/model.nim

@@ -238,21 +238,19 @@ proc parseObjectField(tableName: string, field, fieldIdent: NimNode) =
 
   for p in pragmas:
     colDefNode.add(newNode(nkIdent, pragmaToConstraint(p)))
-
   if defaultSql.isSome:
     colDefNode.add(newNode(nkIdent, "DEFAULT " & defaultSql.get))
-
   SqlSchemas[tableName][$fieldName] = colDefNode
 
-
 macro newModel*(id, fields: untyped) =
   ## Macro for defining a new model at compile time.
   ## This macro will create a Nim object that represents
   ## the model and also register it in the StaticSchemas table.
   result = newNimNode(nnkStmtList)
   let tableName = getTableName($id)
   if StaticSchemas.hasKey(tableName):
-    raise newException(ValueError, "Model with id '" & $id & "' already exists.")
+    result = StaticSchemas[tableName]
+    return # Model already defined, skip redefinition (allows for multiple imports without conflicts)
   var modelFields = newNimNode(nnkRecList)
   # var modelSchema = newTable[string, SqlNode]()
   SqlSchemas[tableName] = newTable[string, SqlNode]()

src/ozark/private/stubs/execSql.nim

@@ -1,3 +1,3 @@
 block:
-  let sqlPrepared = prepare(dbcon, "ozark_instant_$3", SqlQuery("$1"), $4)
+  let sqlPrepared = ensurePrepared(dbcon, "ozark_instant_$3", SqlQuery("$1"), $4)
   dbcon.exec(sqlPrepared$2)

src/ozark/private/stubs/iteratorGetRow.nim

@@ -1,5 +1,5 @@
 block:
-  let sqlPrepared = prepare(dbcon, "ozark_instant_$7", SqlQuery("$1"), $6)
+  let sqlPrepared = ensurePrepared(dbcon, "ozark_instant_$7", SqlQuery("$1"), $6)
   var
     row = getRow(dbcon, sqlPrepared$5)
     isEmpty = true

src/ozark/private/stubs/iteratorInstantRows.nim

@@ -5,7 +5,7 @@ block:
     cols: DBColumns = @[]
     colKeys: seq[string]
   let colNames = [$3]
-  let sqlPrepared = prepare(dbcon, "ozark_instant_$7", SqlQuery("$1"), $6)
+  let sqlPrepared = ensurePrepared(dbcon, "ozark_instant_$7", SqlQuery("$1"), $6)
   for row in instantRows(dbcon, cols, sqlPrepared $5):
     isEmpty = isEmpty and row.len == 0
     if isEmpty: continue # skip empty rows

src/ozark/private/stubs/tryInsertID.nim

@@ -1,5 +1,3 @@
 block:
-  let sqlPrepared =
-    prepare(dbcon, "ozark_insert_$3",
-      SqlQuery("$1 RETURNING id"), $4)
+  let sqlPrepared = ensurePrepared(dbcon, "ozark_insert_$3", SqlQuery("$1 RETURNING id"), $4)
   tryInsertID(dbcon, sqlPrepared, $2)

src/ozark/query.nim

@@ -21,6 +21,8 @@ export SqlQuery, mapIt
 type
   OzarkModelDefect* = object of CatchableError
 
+const preparedQueryStatements = CacheTable"preparedQueryStatements"
+
 randomize() # initialize random seed for generating unique statement names in `tryInsertID`
 
 template table*(models: ptr ModelsTable, name): untyped = 
@@ -472,10 +474,17 @@ macro getAll*(sql: untyped): untyped =
   ## Finalize and get all results of the SQL statement.
   ## This macro produce the final SQL string and wraps it in a runtime call
   ## to execute it and return all rows via `instantRows`
-  if sql.kind != nnkBlockExpr or sql[1][^1][0].strVal notin ["ozarkWhereResult", "ozarkRawSQLResult", "ozarkLimitResult"]:
+  if sql.kind != nnkBlockExpr or sql[1][^1][0].strVal notin [
+        "ozarkWhereResult", "ozarkRawSQLResult",
+        "ozarkLimitResult", "ozarkOrderByResult",
+        "ozarkSelectResult"
+    ]:
     error("The argument to `getAll` must be the result of a `where` macro.")
-  let v = sql[1][^1][2]    # extract the additional arguments (e.g. for WHERE IN) from the macro arguments for later use in code generation
-  sql.parseSqlQuery("instantRows", @[v])
+  if sql[1][^1][0].strVal == "ozarkSelectResult":
+    result = sql.parseSqlQuery("instantRows")
+  else:
+    let v = sql[1][^1][2]    # extract the additional arguments (e.g. for WHERE IN) from the macro arguments for later use in code generation
+    result = sql.parseSqlQuery("instantRows", @[v])
 
 macro get*(sql: untyped): untyped =
   ## Finalize SQL statement. This macro produces the final SQL
@@ -546,6 +555,15 @@ macro rawSQL*(models: ptr ModelsTable, sql: static string, values: varargs[untyp
   except SqlParseError as e:
     raise newException(OzarkModelDefect, "SQL Parsing Error: " & e.msg)
 
+type PreparedKey = tuple[conn: pointer, name: string]
+var preparedRtCache {.threadvar.}: Table[PreparedKey, SqlPrepared]
+
+proc ensurePrepared*(db: DbConn, name: string, sql: SqlQuery, nParams: int): SqlPrepared =
+  let key: PreparedKey = (cast[pointer](db), name)
+  if key notin preparedRtCache:
+    preparedRtCache[key] = prepare(db, name, sql, nParams)
+  result = preparedRtCache[key]
+
 macro exec*(sql: untyped) =
   ## Finalize and execute an SQL statement that doesn't
   ## return results (e.g. INSERT, UPDATE, DELETE).
@@ -561,7 +579,7 @@ macro exec*(sql: untyped) =
   try:
     let sqlNode = parseSQL($sql[1])
     case sqlNode.sons[0].kind
-    of nkInsert:
+    of nkInsert, nkDelete:
       let randId = genSym(nskVar, "id")
       let stub = staticRead("private" / "stubs" / "execSql.nim")
       result = macros.parseStmt(stub % [
@@ -575,6 +593,20 @@ macro exec*(sql: untyped) =
               randId.repr,
               $(sql[2][1]).len
         ])
+    of nkUpdate:
+      let randId = genSym(nskVar, "id")
+      let stub = staticRead("private" / "stubs" / "execSql.nim")
+      result = macros.parseStmt(stub % [
+              $sql[1],
+              (
+                if sql[2][1][1].len > 0: 
+                  ", " & 
+                  $sql[2][1][1].mapIt(it.repr).join(",")
+                else: ""
+              ),
+              randId.repr,
+              $(sql[2][1][1]).len # bracket len
+        ])
     of nkCreateTable, nkCreateTableIfNotExists:
       let randId = genSym(nskVar, "id")
       let stub = staticRead("private" / "stubs" / "execSql.nim")
@@ -593,8 +625,6 @@ macro exec*(sql: untyped) =
               randId.repr,
               "0"
         ])
-    of nkDelete:
-      discard # todo
     else: discard 
   except SqlParseError as e:
     raise newException(OzarkModelDefect, "SQL Parsing Error: " & e.msg)