jdb/fiber-orm-nim
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
fiber-orm-nim/src/fiber_orm.nim

328 lines
11 KiB
Nim
Raw Normal View History

Initial stab at better documentation.
2022-09-02 23:25:52 -05:00
# Fiber ORM
#
# Copyright 2019 Jonathan Bernard <jonathan@jdbernard.com>
## Lightweight ORM supporting the `Postgres`_ and `SQLite`_ databases in Nim.
## It supports a simple, opinionated model mapper to generate SQL queries based
## on Nim objects. It also includes a simple connection pooling implementation.
##
## .. _Postgres: https://nim-lang.org/docs/db_postgres.html
## .. _SQLite: https://nim-lang.org/docs/db_sqlite.html
##
## Basic Usage
## ===========
##
## Object-Relational Modeling
## ==========================
##
## Model Class
## -----------
##
## Table Name
## ``````````
##
## Column Names
## ````````````
##
## ID Field
## ````````
##
## Supported Data Types
## --------------------
##
## Database Object
## ===============
Use a connection provider rather than long-lived connections. The previous implementation expected to work with a context object that contained a field `conn` that represented a valid database connection. However, this required the caller to manage the connection's lifecycle (close, renew, etc.). Now we expect to receive a context object that provides a `withConn` procedure or template that accepts a statement block and provides a `conn` variable to that code block. For example: createRecord(db: DbContext): Record = # withConn must be defined for DbContext db.withConn: # conn must be injected into the statement block context conn.exec(sql("INSERT INTO...")) In addition, this change provides a connection pooling mechanism (`DbConnPool`) as a default implementation for this hypothetical DbContext. There is also a new function `initPool` that will create an DbConnPool instance. Callers of this library can modify their DbContext objects to extend DbConnPool or simply be a type alias of DbConnPool.
2022-02-07 10:48:10 -06:00
import std/db_postgres, std/macros, std/options, std/sequtils, std/strutils
import namespaced_logging, uuids
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
Use a connection provider rather than long-lived connections. The previous implementation expected to work with a context object that contained a field `conn` that represented a valid database connection. However, this required the caller to manage the connection's lifecycle (close, renew, etc.). Now we expect to receive a context object that provides a `withConn` procedure or template that accepts a statement block and provides a `conn` variable to that code block. For example: createRecord(db: DbContext): Record = # withConn must be defined for DbContext db.withConn: # conn must be injected into the statement block context conn.exec(sql("INSERT INTO...")) In addition, this change provides a connection pooling mechanism (`DbConnPool`) as a default implementation for this hypothetical DbContext. There is also a new function `initPool` that will create an DbConnPool instance. Callers of this library can modify their DbContext objects to extend DbConnPool or simply be a type alias of DbConnPool.
2022-02-07 10:48:10 -06:00
from std/unicode import capitalize
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
Use a connection provider rather than long-lived connections. The previous implementation expected to work with a context object that contained a field `conn` that represented a valid database connection. However, this required the caller to manage the connection's lifecycle (close, renew, etc.). Now we expect to receive a context object that provides a `withConn` procedure or template that accepts a statement block and provides a `conn` variable to that code block. For example: createRecord(db: DbContext): Record = # withConn must be defined for DbContext db.withConn: # conn must be injected into the statement block context conn.exec(sql("INSERT INTO...")) In addition, this change provides a connection pooling mechanism (`DbConnPool`) as a default implementation for this hypothetical DbContext. There is also a new function `initPool` that will create an DbConnPool instance. Callers of this library can modify their DbContext objects to extend DbConnPool or simply be a type alias of DbConnPool.
2022-02-07 10:48:10 -06:00
import ./fiber_orm/pool
Rename module from 'fiber_orm_nim' to 'fiber_orm'.
2019-12-25 18:51:00 -06:00
import ./fiber_orm/util
Use a connection provider rather than long-lived connections. The previous implementation expected to work with a context object that contained a field `conn` that represented a valid database connection. However, this required the caller to manage the connection's lifecycle (close, renew, etc.). Now we expect to receive a context object that provides a `withConn` procedure or template that accepts a statement block and provides a `conn` variable to that code block. For example: createRecord(db: DbContext): Record = # withConn must be defined for DbContext db.withConn: # conn must be injected into the statement block context conn.exec(sql("INSERT INTO...")) In addition, this change provides a connection pooling mechanism (`DbConnPool`) as a default implementation for this hypothetical DbContext. There is also a new function `initPool` that will create an DbConnPool instance. Callers of this library can modify their DbContext objects to extend DbConnPool or simply be a type alias of DbConnPool.
2022-02-07 10:48:10 -06:00
Expose a number of useful utility methods and macros.
2021-08-02 05:54:56 -05:00
export
Use a connection provider rather than long-lived connections. The previous implementation expected to work with a context object that contained a field `conn` that represented a valid database connection. However, this required the caller to manage the connection's lifecycle (close, renew, etc.). Now we expect to receive a context object that provides a `withConn` procedure or template that accepts a statement block and provides a `conn` variable to that code block. For example: createRecord(db: DbContext): Record = # withConn must be defined for DbContext db.withConn: # conn must be injected into the statement block context conn.exec(sql("INSERT INTO...")) In addition, this change provides a connection pooling mechanism (`DbConnPool`) as a default implementation for this hypothetical DbContext. There is also a new function `initPool` that will create an DbConnPool instance. Callers of this library can modify their DbContext objects to extend DbConnPool or simply be a type alias of DbConnPool.
2022-02-07 10:48:10 -06:00
pool,
Expose a number of useful utility methods and macros.
2021-08-02 05:54:56 -05:00
util.columnNamesForModel,
util.dbFormat,
util.dbNameToIdent,
util.identNameToDb,
util.modelName,
util.rowToModel,
util.tableName
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
Initial stab at better documentation.
2022-09-02 23:25:52 -05:00
type NotFoundError* = object of CatchableError ##\
## Error type raised when no record matches a given ID
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
Make the logging namespace GC-safe.
2022-01-22 20:20:02 -06:00
var logNs {.threadvar.}: LoggingNamespace
template log(): untyped =
Use a connection provider rather than long-lived connections. The previous implementation expected to work with a context object that contained a field `conn` that represented a valid database connection. However, this required the caller to manage the connection's lifecycle (close, renew, etc.). Now we expect to receive a context object that provides a `withConn` procedure or template that accepts a statement block and provides a `conn` variable to that code block. For example: createRecord(db: DbContext): Record = # withConn must be defined for DbContext db.withConn: # conn must be injected into the statement block context conn.exec(sql("INSERT INTO...")) In addition, this change provides a connection pooling mechanism (`DbConnPool`) as a default implementation for this hypothetical DbContext. There is also a new function `initPool` that will create an DbConnPool instance. Callers of this library can modify their DbContext objects to extend DbConnPool or simply be a type alias of DbConnPool.
2022-02-07 10:48:10 -06:00
if logNs.isNil: logNs = initLoggingNamespace(name = "fiber_orm", level = lvlNotice)
Make the logging namespace GC-safe.
2022-01-22 20:20:02 -06:00
logNs
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
proc newMutateClauses(): MutateClauses =
return MutateClauses(
columns: @[],
placeholders: @[],
values: @[])
proc createRecord*[T](db: DbConn, rec: T): T =
Initial stab at better documentation.
2022-09-02 23:25:52 -05:00
## Create a new record. `rec` is expected to be a `model class`_. The `id
## field`_ is only set if it is `non-empty`_
##
## Returns the newly created record.
##
## .. _model class: #objectminusrelational-modeling-model-class
## .. _id field: #model-class-id-field
## .. _non-empty:
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
var mc = newMutateClauses()
populateMutateClauses(rec, true, mc)
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
let sqlStmt =
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
"INSERT INTO " & tableName(rec) &
" (" & mc.columns.join(",") & ") " &
" VALUES (" & mc.placeholders.join(",") & ") " &
Make column ordering explicit in `createRecord` return. The Nim [Row][nim-row] implementation only supports positional identification of columns. In other words, there is nothing to tell us which column is in which position. Because of this, we always create SQL statements which explicitly name the columns we wish to receive so that we know the order of columns and can rebuild models appropriately. `createRule` wasn't doing this but naively using `RETURNING *`. This still works as long as the field ordering in the Nim model class match the default column ordering returned by the database, but confuses columns otherwise. This fixes that by specifying explicitly the column ordering as we do in other places. [nim-row]: https://nim-lang.org/docs/db_postgres.html#Row
2022-03-11 12:34:19 -06:00
" RETURNING " & columnNamesForModel(rec).join(",")
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
Make the logging namespace GC-safe.
2022-01-22 20:20:02 -06:00
log().debug "createRecord: [" & sqlStmt & "]"
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
let newRow = db.getRow(sql(sqlStmt), mc.values)
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
result = rowToModel(T, newRow)
Update to support Nim 1.4.x+
2021-04-02 13:58:08 -05:00
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
proc updateRecord*[T](db: DbConn, rec: T): bool =
Initial stab at better documentation.
2022-09-02 23:25:52 -05:00
## Update a record by id. `rec` is expected to be a `model class`_.
##
## .. _model class: #objectminusrelational-modeling-model-class
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
var mc = newMutateClauses()
populateMutateClauses(rec, false, mc)
Update to support Nim 1.4.x+
2021-04-02 13:58:08 -05:00
let setClause = zip(mc.columns, mc.placeholders).mapIt(it[0] & " = " & it[1]).join(",")
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
let sqlStmt =
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
"UPDATE " & tableName(rec) &
" SET " & setClause &
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
" WHERE id = ? "
Make the logging namespace GC-safe.
2022-01-22 20:20:02 -06:00
log().debug "updateRecord: [" & sqlStmt & "] id: " & $rec.id
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
let numRowsUpdated = db.execAffectedRows(sql(sqlStmt), mc.values.concat(@[$rec.id]))
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
return numRowsUpdated > 0;
template deleteRecord*(db: DbConn, modelType: type, id: typed): untyped =
Initial stab at better documentation.
2022-09-02 23:25:52 -05:00
## Delete a record by id.
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
let sqlStmt = "DELETE FROM " & tableName(modelType) & " WHERE id = ?"
Make the logging namespace GC-safe.
2022-01-22 20:20:02 -06:00
log().debug "deleteRecord: [" & sqlStmt & "] id: " & $id
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
db.tryExec(sql(sqlStmt), $id)
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
proc deleteRecord*[T](db: DbConn, rec: T): bool =
Initial stab at better documentation.
2022-09-02 23:25:52 -05:00
## Delete a record by `id`_.
##
## .. _id: #model-class-id-field
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
let sqlStmt = "DELETE FROM " & tableName(rec) & " WHERE id = ?"
Make the logging namespace GC-safe.
2022-01-22 20:20:02 -06:00
log().debug "deleteRecord: [" & sqlStmt & "] id: " & $rec.id
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
return db.tryExec(sql(sqlStmt), $rec.id)
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
template getRecord*(db: DbConn, modelType: type, id: typed): untyped =
Initial stab at better documentation.
2022-09-02 23:25:52 -05:00
## Fetch a record by id.
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
let sqlStmt =
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
"SELECT " & columnNamesForModel(modelType).join(",") &
" FROM " & tableName(modelType) &
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
" WHERE id = ?"
Make the logging namespace GC-safe.
2022-01-22 20:20:02 -06:00
log().debug "getRecord: [" & sqlStmt & "] id: " & $id
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
let row = db.getRow(sql(sqlStmt), @[$id])
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
Make record not found error messages more descriptive.
2020-01-02 18:42:48 -06:00
if allIt(row, it.len == 0):
raise newException(NotFoundError, "no " & modelName(modelType) & " record for id " & $id)
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
rowToModel(modelType, row)
template findRecordsWhere*(db: DbConn, modelType: type, whereClause: string, values: varargs[string, dbFormat]): untyped =
Initial stab at better documentation.
2022-09-02 23:25:52 -05:00
## Find all records matching a given `WHERE` clause. The number of elements in
## the `values` array must match the number of placeholders (`?`) in the
## provided `WHERE` clause.
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
let sqlStmt =
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
"SELECT " & columnNamesForModel(modelType).join(",") &
" FROM " & tableName(modelType) &
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
" WHERE " & whereClause
Make the logging namespace GC-safe.
2022-01-22 20:20:02 -06:00
log().debug "findRecordsWhere: [" & sqlStmt & "] values: (" & values.join(", ") & ")"
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
db.getAllRows(sql(sqlStmt), values).mapIt(rowToModel(modelType, it))
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
template getAllRecords*(db: DbConn, modelType: type): untyped =
Initial stab at better documentation.
2022-09-02 23:25:52 -05:00
## Fetch all records of the given type.
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
let sqlStmt =
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
"SELECT " & columnNamesForModel(modelType).join(",") &
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
" FROM " & tableName(modelType)
Make the logging namespace GC-safe.
2022-01-22 20:20:02 -06:00
log().debug "getAllRecords: [" & sqlStmt & "]"
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
db.getAllRows(sql(sqlStmt)).mapIt(rowToModel(modelType, it))
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
template findRecordsBy*(db: DbConn, modelType: type, lookups: seq[tuple[field: string, value: string]]): untyped =
Initial stab at better documentation.
2022-09-02 23:25:52 -05:00
## Find all records matching the provided lookup values.
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
let sqlStmt =
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
"SELECT " & columnNamesForModel(modelType).join(",") &
" FROM " & tableName(modelType) &
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
" WHERE " & lookups.mapIt(it.field & " = ?").join(" AND ")
let values = lookups.mapIt(it.value)
Make the logging namespace GC-safe.
2022-01-22 20:20:02 -06:00
log().debug "findRecordsBy: [" & sqlStmt & "] values (" & values.join(", ") & ")"
Add logging statments (behind namespaced logger).
2022-01-13 14:45:16 -06:00
db.getAllRows(sql(sqlStmt), values).mapIt(rowToModel(modelType, it))
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
Make the DB type object generic (not PmApiDb).
2020-01-02 18:44:44 -06:00
macro generateProcsForModels*(dbType: type, modelTypes: openarray[type]): untyped =
Initial stab at better documentation.
2022-09-02 23:25:52 -05:00
## Generate all standard access procedures for the given model types. For a
## `model class`_ named `SampleRecord`, this will generate the following
## procedures:
##
## .. code-block:: Nim
## proc getSampleRecord*(db: dbType): SampleRecord;
## proc getAllSampleRecords*(db: dbType): SampleRecord;
## proc createSampleRecord*(db: dbType, rec: SampleRecord): SampleRecord;
## proc deleteSampleRecord*(db: dbType, rec: SampleRecord): bool;
## proc deleteSampleRecord*(db: dbType, id: idType): bool;
## proc updateSampleRecord*(db: dbType, rec: SampleRecord): bool;
##
## proc findSampleRecordsWhere*(
## db: dbType, whereClause: string, values: varargs[string]): SampleRecord;
##
## `dbType` is expected to be some type that has a defined `withConn`_
## procedure.
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
result = newStmtList()
for t in modelTypes:
let modelName = $(t.getType[1])
let getName = ident("get" & modelName)
let getAllName = ident("getAll" & modelName & "s")
let findWhereName = ident("find" & modelName & "sWhere")
let createName = ident("create" & modelName)
let updateName = ident("update" & modelName)
let deleteName = ident("delete" & modelName)
let idType = typeOfColumn(t, "id")
result.add quote do:
Use a connection provider rather than long-lived connections. The previous implementation expected to work with a context object that contained a field `conn` that represented a valid database connection. However, this required the caller to manage the connection's lifecycle (close, renew, etc.). Now we expect to receive a context object that provides a `withConn` procedure or template that accepts a statement block and provides a `conn` variable to that code block. For example: createRecord(db: DbContext): Record = # withConn must be defined for DbContext db.withConn: # conn must be injected into the statement block context conn.exec(sql("INSERT INTO...")) In addition, this change provides a connection pooling mechanism (`DbConnPool`) as a default implementation for this hypothetical DbContext. There is also a new function `initPool` that will create an DbConnPool instance. Callers of this library can modify their DbContext objects to extend DbConnPool or simply be a type alias of DbConnPool.
2022-02-07 10:48:10 -06:00
proc `getName`*(db: `dbType`, id: `idType`): `t` =
db.withConn: result = getRecord(conn, `t`, id)
proc `getAllName`*(db: `dbType`): seq[`t`] =
db.withConn: result = getAllRecords(conn, `t`)
Make the DB type object generic (not PmApiDb).
2020-01-02 18:44:44 -06:00
proc `findWhereName`*(db: `dbType`, whereClause: string, values: varargs[string, dbFormat]): seq[`t`] =
Use a connection provider rather than long-lived connections. The previous implementation expected to work with a context object that contained a field `conn` that represented a valid database connection. However, this required the caller to manage the connection's lifecycle (close, renew, etc.). Now we expect to receive a context object that provides a `withConn` procedure or template that accepts a statement block and provides a `conn` variable to that code block. For example: createRecord(db: DbContext): Record = # withConn must be defined for DbContext db.withConn: # conn must be injected into the statement block context conn.exec(sql("INSERT INTO...")) In addition, this change provides a connection pooling mechanism (`DbConnPool`) as a default implementation for this hypothetical DbContext. There is also a new function `initPool` that will create an DbConnPool instance. Callers of this library can modify their DbContext objects to extend DbConnPool or simply be a type alias of DbConnPool.
2022-02-07 10:48:10 -06:00
db.withConn:
result = findRecordsWhere(conn, `t`, whereClause, values)
proc `createName`*(db: `dbType`, rec: `t`): `t` =
db.withConn: result = createRecord(conn, rec)
proc `updateName`*(db: `dbType`, rec: `t`): bool =
db.withConn: result = updateRecord(conn, rec)
proc `deleteName`*(db: `dbType`, rec: `t`): bool =
db.withConn: result = deleteRecord(conn, rec)
proc `deleteName`*(db: `dbType`, id: `idType`): bool =
db.withConn: result = deleteRecord(conn, `t`, id)
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
Make the DB type object generic (not PmApiDb).
2020-01-02 18:44:44 -06:00
macro generateLookup*(dbType: type, modelType: type, fields: seq[string]): untyped =
Initial stab at better documentation.
2022-09-02 23:25:52 -05:00
## Create a lookup procedure for a given set of field names. For example,
##
## .. code-block:: Nim
## generateLookup(SampleDB, SampleRecord, ["name", "location"])
##
## will generate the following procedure:
##
## .. code-block:: Nim
## proc findSampleRecordsByNameAndLocation*(db: SampleDB,
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
let fieldNames = fields[1].mapIt($it)
Use the more intelligent pluralization method we built when generating `findXsByField` lookup functions.
2020-01-02 18:46:03 -06:00
let procName = ident("find" & pluralize($modelType.getType[1]) & "By" & fieldNames.mapIt(it.capitalize).join("And"))
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
# Create proc skeleton
result = quote do:
Make the DB type object generic (not PmApiDb).
2020-01-02 18:44:44 -06:00
proc `procName`*(db: `dbType`): seq[`modelType`] =
Use a connection provider rather than long-lived connections. The previous implementation expected to work with a context object that contained a field `conn` that represented a valid database connection. However, this required the caller to manage the connection's lifecycle (close, renew, etc.). Now we expect to receive a context object that provides a `withConn` procedure or template that accepts a statement block and provides a `conn` variable to that code block. For example: createRecord(db: DbContext): Record = # withConn must be defined for DbContext db.withConn: # conn must be injected into the statement block context conn.exec(sql("INSERT INTO...")) In addition, this change provides a connection pooling mechanism (`DbConnPool`) as a default implementation for this hypothetical DbContext. There is also a new function `initPool` that will create an DbConnPool instance. Callers of this library can modify their DbContext objects to extend DbConnPool or simply be a type alias of DbConnPool.
2022-02-07 10:48:10 -06:00
db.withConn: result = findRecordsBy(conn, `modelType`)
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
var callParams = quote do: @[]
# Add dynamic parameters for the proc definition and inner proc call
for n in fieldNames:
let paramTuple = newNimNode(nnkPar)
paramTuple.add(newColonExpr(ident("field"), newLit(identNameToDb(n))))
paramTuple.add(newColonExpr(ident("value"), ident(n)))
Use a connection provider rather than long-lived connections. The previous implementation expected to work with a context object that contained a field `conn` that represented a valid database connection. However, this required the caller to manage the connection's lifecycle (close, renew, etc.). Now we expect to receive a context object that provides a `withConn` procedure or template that accepts a statement block and provides a `conn` variable to that code block. For example: createRecord(db: DbContext): Record = # withConn must be defined for DbContext db.withConn: # conn must be injected into the statement block context conn.exec(sql("INSERT INTO...")) In addition, this change provides a connection pooling mechanism (`DbConnPool`) as a default implementation for this hypothetical DbContext. There is also a new function `initPool` that will create an DbConnPool instance. Callers of this library can modify their DbContext objects to extend DbConnPool or simply be a type alias of DbConnPool.
2022-02-07 10:48:10 -06:00
# Add the parameter to the outer call (the generated proc)
# result[3] is ProcDef -> [3]: FormalParams
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
result[3].add(newIdentDefs(ident(n), ident("string")))
Use a connection provider rather than long-lived connections. The previous implementation expected to work with a context object that contained a field `conn` that represented a valid database connection. However, this required the caller to manage the connection's lifecycle (close, renew, etc.). Now we expect to receive a context object that provides a `withConn` procedure or template that accepts a statement block and provides a `conn` variable to that code block. For example: createRecord(db: DbContext): Record = # withConn must be defined for DbContext db.withConn: # conn must be injected into the statement block context conn.exec(sql("INSERT INTO...")) In addition, this change provides a connection pooling mechanism (`DbConnPool`) as a default implementation for this hypothetical DbContext. There is also a new function `initPool` that will create an DbConnPool instance. Callers of this library can modify their DbContext objects to extend DbConnPool or simply be a type alias of DbConnPool.
2022-02-07 10:48:10 -06:00
# Build up the AST for the inner procedure call
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
callParams[1].add(paramTuple)
Use a connection provider rather than long-lived connections. The previous implementation expected to work with a context object that contained a field `conn` that represented a valid database connection. However, this required the caller to manage the connection's lifecycle (close, renew, etc.). Now we expect to receive a context object that provides a `withConn` procedure or template that accepts a statement block and provides a `conn` variable to that code block. For example: createRecord(db: DbContext): Record = # withConn must be defined for DbContext db.withConn: # conn must be injected into the statement block context conn.exec(sql("INSERT INTO...")) In addition, this change provides a connection pooling mechanism (`DbConnPool`) as a default implementation for this hypothetical DbContext. There is also a new function `initPool` that will create an DbConnPool instance. Callers of this library can modify their DbContext objects to extend DbConnPool or simply be a type alias of DbConnPool.
2022-02-07 10:48:10 -06:00
# Add the call params to the inner procedure call
# result[6][0][1][0][1] is
# ProcDef -> [6]: StmtList (body) -> [0]: Call ->
# [1]: StmtList (withConn body) -> [0]: Asgn (result =) ->
# [1]: Call (inner findRecords invocation)
result[6][0][1][0][1].add(callParams)
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
Make the DB type object generic (not PmApiDb).
2020-01-02 18:44:44 -06:00
macro generateProcsForFieldLookups*(dbType: type, modelsAndFields: openarray[tuple[t: type, fields: seq[string]]]): untyped =
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
result = newStmtList()
for i in modelsAndFields:
var modelType = i[1][0]
let fieldNames = i[1][1][1].mapIt($it)
let procName = ident("find" & $modelType & "sBy" & fieldNames.mapIt(it.capitalize).join("And"))
# Create proc skeleton
let procDefAST = quote do:
Make the DB type object generic (not PmApiDb).
2020-01-02 18:44:44 -06:00
proc `procName`*(db: `dbType`): seq[`modelType`] =
Use a connection provider rather than long-lived connections. The previous implementation expected to work with a context object that contained a field `conn` that represented a valid database connection. However, this required the caller to manage the connection's lifecycle (close, renew, etc.). Now we expect to receive a context object that provides a `withConn` procedure or template that accepts a statement block and provides a `conn` variable to that code block. For example: createRecord(db: DbContext): Record = # withConn must be defined for DbContext db.withConn: # conn must be injected into the statement block context conn.exec(sql("INSERT INTO...")) In addition, this change provides a connection pooling mechanism (`DbConnPool`) as a default implementation for this hypothetical DbContext. There is also a new function `initPool` that will create an DbConnPool instance. Callers of this library can modify their DbContext objects to extend DbConnPool or simply be a type alias of DbConnPool.
2022-02-07 10:48:10 -06:00
db.withConn: result = findRecordsBy(conn, `modelType`)
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
var callParams = quote do: @[]
# Add dynamic parameters for the proc definition and inner proc call
for n in fieldNames:
let paramTuple = newNimNode(nnkPar)
Fix name mapping in field lookups generation.
2021-07-02 20:16:49 -05:00
paramTuple.add(newColonExpr(ident("field"), newLit(identNameToDb(n))))
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
paramTuple.add(newColonExpr(ident("value"), ident(n)))
procDefAST[3].add(newIdentDefs(ident(n), ident("string")))
callParams[1].add(paramTuple)
Use a connection provider rather than long-lived connections. The previous implementation expected to work with a context object that contained a field `conn` that represented a valid database connection. However, this required the caller to manage the connection's lifecycle (close, renew, etc.). Now we expect to receive a context object that provides a `withConn` procedure or template that accepts a statement block and provides a `conn` variable to that code block. For example: createRecord(db: DbContext): Record = # withConn must be defined for DbContext db.withConn: # conn must be injected into the statement block context conn.exec(sql("INSERT INTO...")) In addition, this change provides a connection pooling mechanism (`DbConnPool`) as a default implementation for this hypothetical DbContext. There is also a new function `initPool` that will create an DbConnPool instance. Callers of this library can modify their DbContext objects to extend DbConnPool or simply be a type alias of DbConnPool.
2022-02-07 10:48:10 -06:00
procDefAST[6][0][1][0][1].add(callParams)
Initial commit of Nim Fiber ORM Initial code based on common db module developed as part of the Personal Measure project.
2019-12-25 18:07:23 -06:00
result.add procDefAST
Use a connection provider rather than long-lived connections. The previous implementation expected to work with a context object that contained a field `conn` that represented a valid database connection. However, this required the caller to manage the connection's lifecycle (close, renew, etc.). Now we expect to receive a context object that provides a `withConn` procedure or template that accepts a statement block and provides a `conn` variable to that code block. For example: createRecord(db: DbContext): Record = # withConn must be defined for DbContext db.withConn: # conn must be injected into the statement block context conn.exec(sql("INSERT INTO...")) In addition, this change provides a connection pooling mechanism (`DbConnPool`) as a default implementation for this hypothetical DbContext. There is also a new function `initPool` that will create an DbConnPool instance. Callers of this library can modify their DbContext objects to extend DbConnPool or simply be a type alias of DbConnPool.
2022-02-07 10:48:10 -06:00
proc initPool*(
connect: proc(): DbConn,
poolSize = 10,
hardCap = false,
healthCheckQuery = "SELECT 'true' AS alive"): DbConnPool =
Initial stab at better documentation.
2022-09-02 23:25:52 -05:00
## Initialize a new DbConnPool.
##
## * `connect` must be a factory which creates a new `DbConn`
## * `poolSize` sets the desired capacity of the connection pool.
## * `hardCap` defaults to `false`.
##
## When `false`, the pool can grow beyond the configured capacity, but will
## release connections down to the its capacity (no less than `poolSize`).
##
## When `true` the pool will not create more than its configured capacity.
## It a connection is requested, none are free, and the pool is at
## capacity, this will result in an Error being raised.
## * `healthCheckQuery` should be a simple and fast SQL query that the pool
## can use to test the liveliness of pooled connections.
Use a connection provider rather than long-lived connections. The previous implementation expected to work with a context object that contained a field `conn` that represented a valid database connection. However, this required the caller to manage the connection's lifecycle (close, renew, etc.). Now we expect to receive a context object that provides a `withConn` procedure or template that accepts a statement block and provides a `conn` variable to that code block. For example: createRecord(db: DbContext): Record = # withConn must be defined for DbContext db.withConn: # conn must be injected into the statement block context conn.exec(sql("INSERT INTO...")) In addition, this change provides a connection pooling mechanism (`DbConnPool`) as a default implementation for this hypothetical DbContext. There is also a new function `initPool` that will create an DbConnPool instance. Callers of this library can modify their DbContext objects to extend DbConnPool or simply be a type alias of DbConnPool.
2022-02-07 10:48:10 -06:00
initDbConnPool(DbConnPoolConfig(
connect: connect,
poolSize: poolSize,
hardCap: hardCap,
healthCheckQuery: healthCheckQuery))
template inTransaction*(db: DbConnPool, body: untyped) =
pool.withConn(db):
conn.exec(sql"BEGIN TRANSACTION")
try:
body
conn.exec(sql"COMMIT")
except:
conn.exec(sql"ROLLBACK")
raise getCurrentException()
Reference in New Issue Copy Permalink