Allow custom functions

.github/workflows/test.yml

@@ -0,0 +1,38 @@
+name: CI
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v1
+
+    - name: Cache choosenim
+      id: cache-choosenim
+      uses: actions/cache@v1
+      with:
+        path: ~/.choosenim
+        key: ${{ runner.os }}-choosenim-stable
+
+    - name: Cache nimble
+      id: cache-nimble
+      uses: actions/cache@v1
+      with:
+        path: ~/.nimble
+        key: ${{ runner.os }}-nimble-stable
+
+    - uses: jiro4989/setup-nim-action@v1.0.1
+#       with:
+#         nim-version: 'stable'
+
+    - uses: harmon758/postgresql-action@v1
+      with: 
+        postgresql version: '11'
+        postgresql user: 'test'
+        postgresql password: 'test'
+        postgresql db: 'test'
+
+    - name: Run test
+      run: nimble test --verbose

.gitignore

@@ -0,0 +1,4 @@
+tools/ormin_importer
+tests/create_postgres
+tests/tpostgres
+tests/tsqlite

ormin.nimble

@@ -14,3 +14,9 @@ bin = @["tools/ormin_importer"]
 
 skipDirs = @["examples"]
 installExt = @["nim"]
+
+task test, "Run nimble test":
+  exec "nim c -r tests/tpostgres"
+
+before test:
+  exec "nim c -r tests/create_postgres"

ormin/queries.nim

@@ -14,13 +14,13 @@ const
   nequals = "<>"
 
 type
-  Function = object
+  Function* = object
     name: string
     arity: int # -1 for 'varargs'
     typ: DbTypeKind # if dbUnknown, use type of the last argument
 
-const
-  functions = [
+var
+  functions {.compileTime.} = @[
     Function(name: "count", arity: 1, typ: dbInt),
     Function(name: "coalesce", arity: -1, typ: dbUnknown),
     Function(name: "min", arity: 1, typ: dbUnknown),

tests/config.nims

@@ -0,0 +1 @@
+switch("path", "$projectDir/../ormin")

tests/create_postgres.nim

@@ -0,0 +1,22 @@
+import strutils, sequtils, db_postgres
+include model_postgres
+
+let db = open("localhost", "test", "test", "test")
+
+# find all tables in public schema
+let exsitstables = db.getAllRows(sql"select tablename from pg_tables where schemaname='public'").mapIt(it[0])
+
+# drop table in sql file
+for name in tableNames:
+  if name in exsitstables:
+    echo "drop exsits table: " & name
+    db.exec(sql("drop table if exists " & name & " cascade"))
+
+# create table in sql file
+echo "create postgres table from sql: " & tableNames.join(", ")
+let model = readFile("tests/model_postgres.sql")
+for m in model.split(';'):
+  if m.strip != "":
+    db.exec(sql(m), [])
+
+db.close()

tests/model_postgres.nim

@@ -0,0 +1,26 @@
+# Generated by ormin_importer. DO NOT EDIT.
+
+type
+  Attr = object
+    name: string
+    tabIndex: int
+    typ: DbTypekind
+    key: int   # 0 nothing special,
+               # +1 -- primary key
+               # -N -- references attribute N
+const tableNames = [
+  "users",
+  "messages"
+]
+
+const attributes = [
+  Attr(name: "id", tabIndex: 0, typ: dbInt, key: 1),
+  Attr(name: "name", tabIndex: 0, typ: dbVarchar, key: 0),
+  Attr(name: "password", tabIndex: 0, typ: dbVarchar, key: 0),
+  Attr(name: "creation", tabIndex: 0, typ: dbTimestamp, key: 0),
+  Attr(name: "lastonline", tabIndex: 0, typ: dbTimestamp, key: 0),
+  Attr(name: "id", tabIndex: 1, typ: dbInt, key: 1),
+  Attr(name: "author", tabIndex: 1, typ: dbInt, key: -1),
+  Attr(name: "content", tabIndex: 1, typ: dbVarchar, key: 0),
+  Attr(name: "creation", tabIndex: 1, typ: dbTimestamp, key: 0)
+]

tests/model_postgres.sql

@@ -0,0 +1,16 @@
+create table if not exists users(
+  id integer primary key ,
+  name varchar(20) not null,
+  password varchar(32) not null,
+  creation timestamp not null default CURRENT_TIMESTAMP,
+  lastOnline timestamp not null default CURRENT_TIMESTAMP
+);
+
+create table if not exists messages(
+  id integer primary key,
+  author integer not null,
+  content varchar(1000) not null,
+  creation timestamp not null default CURRENT_TIMESTAMP,
+
+  foreign key (author) references users(id)
+);

tests/tpostgres.nim

@@ -0,0 +1,99 @@
+import unittest, sequtils, strformat
+import ../ormin
+
+importModel(DbBackend.postgre, "model_postgres")
+
+static:
+  functions.add([
+    Function(name: "upper", arity: 1, typ: dbVarchar),
+    Function(name: "lower", arity: 1, typ: dbVarchar),
+    Function(name: "row", arity: -1, typ: dbUnknown),
+  ])
+
+suite "test postgres":
+  let db {.global.} = open("localhost", "test", "test", "test")
+
+  test "insert data":
+    for i in 1..3:
+      let name = fmt"john{i}"
+      let password = fmt"pass{i}"
+      query:
+        insert users(id = ?i, name = ?name, password = ?password,
+                    lastOnline = !!"CURRENT_TIMESTAMP")
+
+  test "query data":
+    let users = query:
+      select users(id, name, password)
+    assert users == [1, 2, 3].mapIt((id: it, name: fmt"john{it}",
+                                    password: fmt"pass{it}"))
+
+  test "query count":
+    let count = query:
+      select users(count(_))
+      limit 1
+    assert count == 3
+
+  test "update data":
+    let updatedstr = "updated"
+    let id = 3
+    query:
+      update users(name = name || ?updatedstr,
+                  lastOnline = !!"CURRENT_TIMESTAMP")
+      where id == ?id
+    let updatedname = query:
+      select users(name)
+      where id == ?id
+      limit 1
+    assert updatedname == fmt"john{id}{updatedstr}"
+
+  # test "delete data":
+  #   let id = 3
+  #   query:
+  #     delete users
+  #     where id == ?id
+  #   let user = query:
+  #     select users(_)
+  #     where id == ?id
+  #   assert user == []
+
+  test "more sql function upper":
+    let id = 1
+    let name = query:
+      select users(upper(name))
+      where id == ?id
+      limit 1
+    assert name == "JOHN1"
+
+  test "more sql function lower":
+    let id = 1
+    let name = query:
+      select users(lower(name))
+      where id == ?id
+      limit 1
+    assert name == "john1"
+
+  test "more sql function row with a parameter":
+    let id = 1
+    let name = query:
+      select users(row(name))
+      where id == ?id
+      limit 1
+    assert name == "(john1)"
+
+  # test "more sql function row with two parameters":
+  #   let id = 1
+  #   let row = query:
+  #     select users(row(id, name))
+  #     where id == ?id
+  #     limit 1
+  #   assert row == "(1, john1)"
+
+  test "ormin sql function coalesce with a parameter":
+    let id = 1
+    let name = query:
+      select users(coalesce(name))
+      where id == ?id
+      limit 1
+    assert name == "john1"
+
+  db.close()

tests/tsqlite.nim

@@ -0,0 +1,15 @@
+import unittest
+import db_sqlite
+
+suite "connect to sqlite":
+  setup:
+    var db {.global.} = open("test.db", "", "", "")
+
+  test "create table":
+    db.exec(sql"""CREATE TABLE my_table (
+                id   INTEGER,
+                name VARCHAR(50) NOT NULL
+              )""")
+
+  teardown:
+    db.close()

tools/ormin_importer.nim

@@ -95,6 +95,7 @@ proc getType(n: SqlNode): DbType =
     of "inet", "ip", "tcpip": k = dbInet
     of "mac", "macaddress": k = dbMacAddress
     of "geometry": k = dbGeometry
+    # of "geometry": k = dbVarchar
     of "point": k = dbPoint
     of "line": k = dbLine
     of "lseg": k = dbLseg