Connection pool

.gitignore

@@ -30,6 +30,7 @@ tests/sqlite/tfkpragma_selfref
 tests/sqlite/tfkpragmanotint
 tests/sqlite/tfkpragmanotmodel
 tests/sqlite/tnull
+tests/sqlite/tpool
 tests/sqlite/trelated
 tests/sqlite/trepeatfks
 tests/sqlite/trawselect
@@ -56,6 +57,7 @@ tests/postgres/tfkpragma_selfref
 tests/postgres/tfkpragmanotint
 tests/postgres/tfkpragmanotmodel
 tests/postgres/tnull
+tests/postgres/tpool
 tests/postgres/trelated
 tests/postgres/trepeatfks
 tests/postgres/trawselect

src/norm.nim

@@ -1,3 +1,4 @@
 {.warning[UnusedImport]: off.}
 
-import norm/[model, pragmas, sqlite, postgres]
+import norm/[model, pragmas, sqlite, postgres, pool]
+

src/norm/pool.nim

@@ -0,0 +1,106 @@
+import std/locks
+
+import sqlite, postgres
+
+
+type 
+  Conn = sqlite.DbConn | postgres.DbConn
+  Pool*[T: Conn] = ref object 
+    defaultSize: Natural
+    conns: seq[T]
+    poolExhaustedPolicy: PoolExhaustedPolicy
+    lock: Lock
+  PoolExhaustedError* = object of CatchableError
+  PoolExhaustedPolicy* = enum
+    pepRaise
+    pepExtend
+
+
+func newPool*[T: Conn](defaultSize: Positive, poolExhaustedPolicy = pepRaise): Pool[T] =
+  ##[ Create a connection pool of the given size.
+
+  ``poolExhaustedPolicy`` defines how the pool reacts when a connection is requested but the pool has no connection available:
+
+    - ``pepRaise`` (default) means throw ``PoolExhaustedError``
+    - ``pepExtend`` means throw “add another connection to the pool.”
+  ]##
+
+  result = Pool[T](defaultSize: defaultSize, conns: newSeq[T](defaultSize), poolExhaustedPolicy: poolExhaustedPolicy)
+
+  initLock(result.lock)
+
+  for conn in result.conns.mitems:
+    conn =
+      when T is sqlite.DbConn:
+        sqlite.getDb()
+      elif T is postgres.DbConn:
+        postgres.getDb()
+
+func defaultSize*(pool: Pool): Natural =
+  pool.defaultSize
+
+func size*(pool: Pool): Natural =
+  len(pool.conns)
+
+func pop*[T: Conn](pool: var Pool[T]): T =
+  ##[ Take a connection from the pool.
+
+  If you're calling this manually, don't forget to `add <#add,Pool,DbConn>`_ it back!
+  ]##
+
+  withLock(pool.lock):
+    if pool.size > 0:
+      result = pool.conns.pop()
+    else:
+      case pool.poolExhaustedPolicy
+      of pepRaise:
+        raise newException(PoolExhaustedError, "Pool exhausted")
+      of pepExtend:
+        result =
+          when T is sqlite.DbConn:
+            sqlite.getDb()
+          elif T is postgres.DbConn:
+            postgres.getDb()
+
+func add*[T: Conn](pool: var Pool, dbConn: T) =
+  ##[ Add a connection to the pool.
+
+  Use to return a borrowed connection to the pool.
+  ]##
+
+  withLock(pool.lock):
+    pool.conns.add(dbConn)
+
+func reset*(pool: var Pool) =
+  ## Reset pool size to ``defaultSize`` by closing and removing extra connections.
+
+  withLock(pool.lock):
+    while pool.size > pool.defaultSize:
+      var conn = pool.conns.pop()
+      close conn
+
+func close*(pool: var Pool) =
+  ## Close the pool by closing and removing all its connetions.
+
+  withLock(pool.lock):
+    for conn in pool.conns.mitems:
+      close conn
+
+    pool.conns.setLen(0)
+
+template withDb*(pool: var Pool, body: untyped): untyped =
+  ##[ Wrapper for DB operations.
+
+  Takes a ``DbConn`` from a pool as ``db`` variable,
+  runs your code in a ``try`` block, and returns connection to the pool afterward.
+  ]##
+
+  block:
+    let db {.inject.} = pool.pop()
+
+    try:
+      body
+
+    finally:
+      pool.add(db)
+

src/norm/postgres.nim

@@ -1,4 +1,3 @@
-
 import std/[os, logging, strutils, sequtils, options, sugar, strformat, tables]
 
 when (NimMajor, NimMinor) <= (1, 6):
@@ -38,7 +37,7 @@ const
 
 # Sugar to get DB config from environment variables
 
-proc getDb*(): DbConn =
+proc getDb*: DbConn =
   ## Create a ``DbConn`` from ``DB_HOST``, ``DB_USER``, ``DB_PASS``, and ``DB_NAME`` environment variables.
 
   open(getEnv(dbHostEnv), getEnv(dbUserEnv), getEnv(dbPassEnv), getEnv(dbNameEnv))

src/norm/private/postgres/rowutils.nim

@@ -21,20 +21,20 @@ func isEmptyColumn*(row: Row, index: int): bool =
 
 ## This does the actual heavy lifting for parsing
 proc fromRowPos[T: ref object](obj: var T, row: Row, pos: var Natural, skip: static bool = false) =
-  ##[ Convert ``ndb.sqlite.Row`` instance into `ref object`_ instance, from a given position.
+  ##[ Convert ``ndb.sqlite.Row`` instance into `Model`_ instance, from a given position.
 
-  This is a helper proc to convert to `ref object`_ instances that have fields of the same type.
+  This is a helper proc to convert to `Model`_ instances that have fields of the same type.
   ]##
 
   for fld, dummyVal in T()[].fieldPairs:
     when isRefObject(typeof(dummyVal)):                 ## If we're dealing with a ``ref object`` field
-      if dot(obj, fld).toOptional().isSome:             ## and it's either a ``some ref object`` or ``ref object``
+      if dot(obj, fld).toOptional().isSome:             ## and it's either a ``some Model`` or ``Model``
         var subMod = dot(obj, fld).toOptional().get()   ## then we try to populate it with the next ``row`` values.
 
-        if row.isEmptyColumn(pos):                      ## If we have a ``NULL`` at this point, we return an empty ``ref object``:
-          when typeof(dummyVal) is Option:              ## ``val`` is guaranteed to be either ``ref object`` or an ``Option[ref object]`` at this point,
+        if row.isEmptyColumn(pos):                      ## If we have a ``NULL`` at this point, we return an empty ``Model``:
+          when typeof(dummyVal) is Option:              ## ``val`` is guaranteed to be either ``Model`` or an ``Option[Model]`` at this point,
             when isRefObject(dummyVal):
-              dot(obj, fld) = none typeof(subMod)       ## and the fact that we got a ``NULL`` tells us it's an ``Option[ref object]``,
+              dot(obj, fld) = none typeof(subMod)       ## and the fact that we got a ``NULL`` tells us it's an ``Option[Model]``,
 
           inc pos
           subMod.fromRowPos(row, pos, skip = true)      ## Then we skip all the ``row`` values that should've gone into this submodel.
@@ -43,7 +43,7 @@ proc fromRowPos[T: ref object](obj: var T, row: Row, pos: var Natural, skip: sta
           inc pos                                       ##
           subMod.fromRowPos(row, pos)                   ## we actually populate the submodel.
 
-      else:                                             ## If the field is a ``none ref object``,
+      else:                                             ## If the field is a ``none Model``,
         inc pos                                         ## don't bother trying to populate it at all.
 
     else:
@@ -56,9 +56,9 @@ proc fromRowPos[T: ref object](obj: var T, row: Row, pos: var Natural, skip: sta
 
 
 proc fromRow*[T: ref object](obj: var T, row: Row) =
-  ##[ Populate `ref object`_ instance from ``ndb.postgres.Row`` instance.
+  ##[ Populate `Model`_ instance from ``ndb.postgres.Row`` instance.
 
-  Nested `ref object`_ fields are populated from the same ``ndb.postgres.Row`` instance.
+  Nested `Model`_ fields are populated from the same ``ndb.postgres.Row`` instance.
   ]##
 
   var pos: Natural = 0

src/norm/private/sqlite/rowutils.nim

@@ -21,20 +21,20 @@ func isEmptyColumn*(row: Row, index: int): bool =
 
 ## This does the actual heavy lifting for parsing
 proc fromRowPos[T: ref object](obj: var T, row: Row, pos: var Natural, skip: static bool = false) =
-  ##[ Convert ``ndb.sqlite.Row`` instance into `ref object`_ instance, from a given position.
+  ##[ Convert ``ndb.sqlite.Row`` instance into `Model`_ instance, from a given position.
 
-  This is a helper proc to convert to `ref object`_ instances that have fields of the same type.
+  This is a helper proc to convert to `Model`_ instances that have fields of the same type.
   ]##
 
   for fld, dummyVal in T()[].fieldPairs:
     when isRefObject(typeof(dummyVal)):                 ## If we're dealing with a ``ref object`` field
       if dot(obj, fld).toOptional().isSome:             ## and it's either a ``some ref object`` or ``ref object``
         var subMod = dot(obj, fld).toOptional().get()   ## then we try to populate it with the next ``row`` values.
 
-        if row.isEmptyColumn(pos):                      ## If we have a ``NULL`` at this point, we return an empty ``ref object``:
-          when typeof(dummyVal) is Option:              ## ``val`` is guaranteed to be either ``ref object`` or an ``Option[ref object]`` at this point,
+        if row.isEmptyColumn(pos):                      ## If we have a ``NULL`` at this point, we return an empty ``Model``:
+          when typeof(dummyVal) is Option:              ## ``val`` is guaranteed to be either ``Model`` or an ``Option[Model]`` at this point,
             when isRefObject(dummyVal):
-              dot(obj, fld) = none typeof(subMod)       ## and the fact that we got a ``NULL`` tells us it's an ``Option[ref object]``,
+              dot(obj, fld) = none typeof(subMod)       ## and the fact that we got a ``NULL`` tells us it's an ``Option[Model]``,
 
           inc pos
           subMod.fromRowPos(row, pos, skip = true)      ## Then we skip all the ``row`` values that should've gone into this submodel.
@@ -43,7 +43,7 @@ proc fromRowPos[T: ref object](obj: var T, row: Row, pos: var Natural, skip: sta
           inc pos                                       ##
           subMod.fromRowPos(row, pos)                   ## we actually populate the submodel.
 
-      else:                                             ## If the field is a ``none ref object``,
+      else:                                             ## If the field is a ``none Model``,
         inc pos                                         ## don't bother trying to populate it at all.
 
     else:
@@ -55,9 +55,9 @@ proc fromRowPos[T: ref object](obj: var T, row: Row, pos: var Natural, skip: sta
         inc pos
 
 proc fromRow*[T: ref object](obj: var T, row: Row) =
-  ##[ Populate `ref object`_ instance from ``ndb.sqlite.Row`` instance.
+  ##[ Populate `Model`_ instance from ``ndb.sqlite.Row`` instance.
 
-  Nested `ref object`_ fields are populated from the same ``ndb.sqlite.Row`` instance.
+  Nested `Model`_ fields are populated from the same ``ndb.sqlite.Row`` instance.
   ]##
 
   var pos: Natural = 0

src/norm/sqlite.nim

@@ -32,7 +32,7 @@ const dbHostEnv* = "DB_HOST"
 
 # Sugar to get DB config from environment variables
 
-proc getDb*(): DbConn =
+proc getDb*: DbConn =
   ## Create a ``DbConn`` from ``DB_HOST`` environment variable.
 
   open(getEnv(dbHostEnv), "", "", "")