query-core 0.1.14 → 0.1.18

package/lib/SearchBuilder.js

@@ -54,7 +54,7 @@ var SearchBuilder = (function () {
     var sn = s[st];
     delete s[st];
     var x = (this.provider === exports.postgres ? 'ilike' : this.buildParam);
-    var q2 = this.buildQuery(s, x, this.table, this.attributes, sn, fields, this.q, this.excluding, this.buildSort);
+    var q2 = this.buildQuery(s, x, sn, this.buildSort, this.attributes, this.table, fields, this.q, this.excluding);
     if (!q2) {
       throw new Error('Cannot build query');
     }

package/lib/health.js

@@ -0,0 +1,116 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+  function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+    function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+    function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+  var _ = { label: 0, sent: function () { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
+  function verb(n) { return function (v) { return step([n, v]); }; }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (_) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0: case 1: t = op; break;
+        case 4: _.label++; return { value: op[1], done: false };
+        case 5: _.label++; y = op[1]; op = [0]; continue;
+        case 7: op = _.ops.pop(); _.trys.pop(); continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+          if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+          if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+          if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+          if (t[2]) _.ops.pop();
+          _.trys.pop(); continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+    if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+  }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Checker = (function () {
+  function Checker(select, query, service, timeout) {
+    this.select = select;
+    this.query = query;
+    this.timeout = (timeout ? timeout : 4200);
+    this.service = (service ? service : 'sql');
+    this.check = this.check.bind(this);
+    this.name = this.name.bind(this);
+    this.build = this.build.bind(this);
+  }
+  Checker.prototype.check = function () {
+    return __awaiter(this, void 0, void 0, function () {
+      var obj, promise;
+      return __generator(this, function (_a) {
+        obj = {};
+        promise = this.select(this.query).then(function (r) { return obj; });
+        if (this.timeout > 0) {
+          return [2, promiseTimeOut(this.timeout, promise)];
+        }
+        else {
+          return [2, promise];
+        }
+        return [2];
+      });
+    });
+  };
+  Checker.prototype.name = function () {
+    return this.service;
+  };
+  Checker.prototype.build = function (data, err) {
+    if (err) {
+      if (!data) {
+        data = {};
+      }
+      data['error'] = err;
+    }
+    return data;
+  };
+  return Checker;
+}());
+exports.Checker = Checker;
+function promiseTimeOut(timeoutInMilliseconds, promise) {
+  return Promise.race([
+    promise,
+    new Promise(function (resolve, reject) {
+      setTimeout(function () {
+        reject("Timed out in: " + timeoutInMilliseconds + " milliseconds!");
+      }, timeoutInMilliseconds);
+    })
+  ]);
+}
+exports.driverMap = {
+  'oracle': 'SELECT SYSDATE FROM DUAL',
+  'postgres': 'select now()',
+  'mssql': 'select getdate()',
+  'mysql': 'select current_time',
+  'sqlite': 'select date()'
+};
+function createChecker(query, sql, service, timeout) {
+  if (typeof query === 'function') {
+    if (!sql) {
+      sql = 'select getdate()';
+    }
+    return new Checker(query, sql, service, timeout);
+  }
+  else {
+    var db = query;
+    var s = exports.driverMap[db.driver];
+    if (!s) {
+      s = 'select getdate()';
+    }
+    if (!service) {
+      service = db.driver;
+    }
+    return new Checker(db.query, s, service, timeout);
+  }
+}
+exports.createChecker = createChecker;

package/lib/index.js

@@ -3,6 +3,8 @@ function __export(m) {
   for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
 }
 Object.defineProperty(exports, "__esModule", { value: true });
+var health_1 = require("./health");
+exports.SqlChecker = health_1.Checker;
 var services_1 = require("./services");
 exports.SqlLoadRepository = services_1.SqlLoader;
 exports.SqlViewRepository = services_1.SqlLoader;
@@ -20,10 +22,11 @@ exports.GenericSearchRepository = services_1.SqlSearchWriter;
 exports.GenericSearchService = services_1.SqlSearchWriter;
 exports.SqlRepository = services_1.SqlSearchWriter;
 exports.SqlService = services_1.SqlSearchWriter;
-exports.Repository = services_1.SqlSearchWriter;
 exports.Service = services_1.SqlSearchWriter;
 exports.SqlGenericRepository = services_1.SqlWriter;
+exports.Repository = services_1.SqlWriter;
 exports.SqlGenericService = services_1.SqlWriter;
+__export(require("./health"));
 __export(require("./build"));
 __export(require("./services"));
 __export(require("./batch"));

package/lib/query.js

@@ -56,7 +56,7 @@ function buildDollarParam(i) {
   return '$' + i;
 }
 exports.buildDollarParam = buildDollarParam;
-function buildQuery(filter, bparam, table, attrs, sort, fields, sq, strExcluding, buildSort3) {
+function buildQuery(filter, bparam, sort, buildSort3, attrs, table, fields, sq, strExcluding) {
   if (!table || !attrs) {
     return undefined;
   }
@@ -166,6 +166,10 @@ function buildQuery(filter, bparam, table, attrs, sort, fields, sq, strExcluding
                 filters.push(field + " <= " + param(i++));
                 args.push(v['max']);
               }
+              else if (v['top']) {
+                filters.push(field + " < " + param(i++));
+                args.push(v['top']);
+              }
               else if (v['endDate']) {
                 filters.push(field + " <= " + param(i++));
                 args.push(v['endDate']);
@@ -201,6 +205,9 @@ function buildQuery(filter, bparam, table, attrs, sort, fields, sq, strExcluding
               if (v['max']) {
                 filters.push(field + " <= " + v['max']);
               }
+              else if (v['top']) {
+                filters.push(field + " < " + v['top']);
+              }
               else if (v['upper']) {
                 filters.push(field + " < " + v['upper']);
               }

package/lib/services.js

@@ -91,6 +91,252 @@ var SqlSearchLoader = (function (_super) {
   return SqlSearchLoader;
 }(SqlLoader));
 exports.SqlSearchLoader = SqlSearchLoader;
+function log(db, isLog, logger, q, result, r, duration) {
+  if (!isLog) {
+    return db;
+  }
+  if (q !== undefined && q != null && q.length > 0) {
+    if (!logger.isDebugEnabled()) {
+      return db;
+    }
+    return new LogManager(db, logger.error, logger.debug, q, result, r, duration);
+  }
+  if (!logger.isInfoEnabled()) {
+    return db;
+  }
+  return new LogManager(db, logger.error, logger.info, q, result, r, duration);
+}
+exports.log = log;
+function useLog(db, isLog, err, lg, q, result, r, duration) {
+  if (!isLog) {
+    return db;
+  }
+  if (err) {
+    return new LogManager(db, err, lg, q, result, r, duration);
+  }
+  return db;
+}
+exports.useLog = useLog;
+var LogManager = (function () {
+  function LogManager(db, err, lg, q, result, r, duration) {
+    this.db = db;
+    this.driver = db.driver;
+    this.duration = (duration && duration.length > 0 ? duration : 'duration');
+    this.sql = (q === undefined ? '' : q);
+    this.return = (r !== undefined && r != null ? r : 'count');
+    this.result = (result !== undefined && result != null ? result : '');
+    this.log = lg;
+    this.error = err;
+    this.param = this.param.bind(this);
+    this.exec = this.exec.bind(this);
+    this.execBatch = this.execBatch.bind(this);
+    this.query = this.query.bind(this);
+    this.queryOne = this.queryOne.bind(this);
+    this.execScalar = this.execScalar.bind(this);
+    this.count = this.count.bind(this);
+  }
+  LogManager.prototype.param = function (i) {
+    return this.db.param(i);
+  };
+  LogManager.prototype.exec = function (sql, args, ctx) {
+    var t1 = new Date();
+    return this.db.exec(sql, args, ctx);
+  };
+  LogManager.prototype.execBatch = function (statements, firstSuccess, ctx) {
+    var _this = this;
+    var t1 = new Date();
+    return this.db.execBatch(statements, firstSuccess, ctx).then(function (v) {
+      setTimeout(function () {
+        if (_this.log) {
+          var d = diff(t1);
+          var obj = {};
+          if (_this.sql.length > 0) {
+            obj[_this.sql] = JSON.stringify(statements);
+          }
+          if (_this.return.length > 0) {
+            obj[_this.return] = v;
+          }
+          obj[_this.duration] = d;
+          _this.log('exec batch', obj);
+        }
+      }, 0);
+      return v;
+    }).catch(function (er) {
+      setTimeout(function () {
+        var d = diff(t1);
+        var obj = {};
+        if (_this.sql.length > 0) {
+          obj[_this.sql] = JSON.stringify(statements);
+        }
+        obj[_this.duration] = d;
+        _this.error('error exec batch: ' + buildString(er));
+      }, 0);
+      throw er;
+    });
+  };
+  LogManager.prototype.query = function (sql, args, m, bools, ctx) {
+    var _this = this;
+    var t1 = new Date();
+    return this.db.query(sql, args, m, bools, ctx).then(function (v) {
+      setTimeout(function () {
+        if (_this.log) {
+          var d = diff(t1);
+          var obj = {};
+          if (_this.sql.length > 0) {
+            obj[_this.sql] = getString(sql, args);
+          }
+          if (_this.result.length > 0) {
+            if (v && v.length > 0) {
+              obj[_this.result] = JSON.stringify(v);
+            }
+          }
+          if (_this.return.length > 0) {
+            obj[_this.return] = v ? v.length : 0;
+          }
+          obj[_this.duration] = d;
+          _this.log('query', obj);
+        }
+      }, 0);
+      return v;
+    }).catch(function (er) {
+      setTimeout(function () {
+        var d = diff(t1);
+        var obj = {};
+        if (_this.sql.length > 0) {
+          obj[_this.sql] = getString(sql, args);
+        }
+        obj[_this.duration] = d;
+        _this.error('error query: ' + buildString(er));
+      }, 0);
+      throw er;
+    });
+  };
+  LogManager.prototype.queryOne = function (sql, args, m, bools, ctx) {
+    var _this = this;
+    var t1 = new Date();
+    return this.db.queryOne(sql, args, m, bools, ctx).then(function (v) {
+      setTimeout(function () {
+        if (_this.log) {
+          var d = diff(t1);
+          var obj = {};
+          if (_this.sql.length > 0) {
+            obj[_this.sql] = getString(sql, args);
+          }
+          if (_this.result.length > 0) {
+            obj[_this.result] = v ? JSON.stringify(v) : 'null';
+          }
+          if (_this.return.length > 0) {
+            obj[_this.return] = v ? 1 : 0;
+          }
+          obj[_this.duration] = d;
+          _this.log('query one', obj);
+        }
+      }, 0);
+      return v;
+    }).catch(function (er) {
+      setTimeout(function () {
+        var d = diff(t1);
+        var obj = {};
+        if (_this.sql.length > 0) {
+          obj[_this.sql] = getString(sql, args);
+        }
+        obj[_this.duration] = d;
+        _this.error('error query one: ' + buildString(er));
+      }, 0);
+      throw er;
+    });
+  };
+  LogManager.prototype.execScalar = function (sql, args, ctx) {
+    var _this = this;
+    var t1 = new Date();
+    return this.db.execScalar(sql, args, ctx).then(function (v) {
+      setTimeout(function () {
+        if (_this.log) {
+          var d = diff(t1);
+          var obj = {};
+          if (_this.sql.length > 0) {
+            obj[_this.sql] = getString(sql, args);
+          }
+          if (_this.result.length > 0) {
+            obj[_this.result] = v ? buildString(v) : 'null';
+          }
+          if (_this.return.length > 0) {
+            obj[_this.return] = v ? 1 : 0;
+          }
+          obj[_this.duration] = d;
+          _this.log('exec scalar', obj);
+        }
+      }, 0);
+      return v;
+    }).catch(function (er) {
+      setTimeout(function () {
+        var d = diff(t1);
+        var obj = {};
+        if (_this.sql.length > 0) {
+          obj[_this.sql] = getString(sql, args);
+        }
+        obj[_this.duration] = d;
+        _this.error('error exec scalar: ' + buildString(er));
+      }, 0);
+      throw er;
+    });
+  };
+  LogManager.prototype.count = function (sql, args, ctx) {
+    var _this = this;
+    var t1 = new Date();
+    return this.db.count(sql, args).then(function (v) {
+      setTimeout(function () {
+        if (_this.log) {
+          var d = diff(t1);
+          var obj = {};
+          if (_this.sql.length > 0) {
+            obj[_this.sql] = getString(sql, args);
+          }
+          if (_this.return.length > 0) {
+            obj[_this.return] = v;
+          }
+          obj[_this.duration] = d;
+          _this.log('count', obj);
+        }
+      }, 0);
+      return v;
+    }).catch(function (er) {
+      setTimeout(function () {
+        var d = diff(t1);
+        var obj = {};
+        if (_this.sql.length > 0) {
+          obj[_this.sql] = getString(sql, args);
+        }
+        obj[_this.duration] = d;
+        _this.error('error count: ' + buildString(er));
+      }, 0);
+      throw er;
+    });
+  };
+  return LogManager;
+}());
+exports.LogManager = LogManager;
+function buildString(v) {
+  if (typeof v === 'string') {
+    return v;
+  }
+  else {
+    return JSON.stringify(v);
+  }
+}
+function getString(sql, args) {
+  if (args && args.length > 0) {
+    return sql + ' ' + JSON.stringify(args);
+  }
+  else {
+    return sql;
+  }
+}
+function diff(d1) {
+  var d2 = new Date();
+  return d2.getTime() - d1.getTime();
+}
+exports.diff = diff;
 var SqlWriter = (function (_super) {
   __extends(SqlWriter, _super);
   function SqlWriter(manager, table, attrs, toDB, fromDB) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "query-core",
-  "version": "0.1.14",
+  "version": "0.1.18",
   "description": "query",
   "main": "./lib/index.js",
   "types": "./src/index.ts",

package/src/SearchBuilder.ts

@@ -10,7 +10,7 @@ export const sqlite = 'sqlite';
 export class SearchBuilder<T, S> {
   map?: StringMap;
   bools?: Attribute[];
-  buildQuery: (s: S, bparam: LikeType|((i: number ) => string), table?: string, attrs?: Attributes, sort?: string, fields?: string[], sq?: string, strExcluding?: string, buildSort3?: (sort?: string, map?: Attributes|StringMap) => string) => Statement|undefined;
+  buildQuery: (s: S, bparam: LikeType|((i: number ) => string), sort?: string, buildSort3?: (sort?: string, map?: Attributes|StringMap) => string, attrs?: Attributes, table?: string, fields?: string[], sq?: string, strExcluding?: string) => Statement|undefined;
   q?: string;
   excluding?: string;
   buildSort?: (sort?: string, map?: Attributes|StringMap) => string;
@@ -19,7 +19,7 @@ export class SearchBuilder<T, S> {
   constructor(public query: (sql: string, args?: any[], m?: StringMap, bools?: Attribute[]) => Promise<T[]>, public table: string,
     public attributes?: Attributes,
     public provider?: string,
-    buildQ?: (s: S, bparam: LikeType|((i: number ) => string), table?: string, attrs?: Attributes, sort?: string, fields?: string[], sq?: string, strExcluding?: string, buildSort3?: (sort?: string, map?: Attributes|StringMap) => string) => Statement|undefined,
+    buildQ?: (s: S, bparam: LikeType|((i: number ) => string), sort?: string, buildSort3?: (sort?: string, map?: Attributes|StringMap) => string, attrs?: Attributes, table?: string, fields?: string[], sq?: string, strExcluding?: string) => Statement|undefined,
     public fromDB?: (v: T) => T,
     public sort?: string,
     q?: string,
@@ -62,7 +62,7 @@ export class SearchBuilder<T, S> {
     const sn = (s as any)[st] as string;
     delete (s as any)[st];
     const x = (this.provider === postgres ? 'ilike' : this.buildParam);
-    const q2 = this.buildQuery(s, x, this.table, this.attributes, sn, fields, this.q, this.excluding, this.buildSort);
+    const q2 = this.buildQuery(s, x, sn, this.buildSort, this.attributes, this.table, fields, this.q, this.excluding);
     if (!q2) {
       throw new Error('Cannot build query');
     }

package/src/health.ts

@@ -0,0 +1,78 @@
+import {StringMap} from './metadata';
+
+export interface SimpleDB {
+  driver: string;
+  query<T>(sql: string): Promise<T[]>;
+}
+export interface AnyMap {
+  [key: string]: any;
+}
+export class Checker {
+  timeout: number;
+  service: string;
+  constructor(public select: (sql: string) => Promise<any[]>, public query: string, service?: string, timeout?: number) {
+    this.timeout = (timeout ? timeout : 4200);
+    this.service = (service ? service : 'sql');
+    this.check = this.check.bind(this);
+    this.name = this.name.bind(this);
+    this.build = this.build.bind(this);
+  }
+  async check(): Promise<AnyMap> {
+    const obj = {} as AnyMap;
+    const promise = this.select(this.query).then(r => obj);
+    if (this.timeout > 0) {
+      return promiseTimeOut(this.timeout, promise);
+    } else {
+      return promise;
+    }
+  }
+  name(): string {
+    return this.service;
+  }
+  build(data: AnyMap, err: any): AnyMap {
+    if (err) {
+      if (!data) {
+        data = {} as AnyMap;
+      }
+      data['error'] = err;
+    }
+    return data;
+  }
+}
+
+function promiseTimeOut(timeoutInMilliseconds: number, promise: Promise<any>): Promise<any> {
+  return Promise.race([
+    promise,
+    new Promise((resolve, reject) => {
+      setTimeout(() => {
+        reject(`Timed out in: ${timeoutInMilliseconds} milliseconds!`);
+      }, timeoutInMilliseconds);
+    })
+  ]);
+}
+
+export const driverMap: StringMap = {
+  'oracle': 'SELECT SYSDATE FROM DUAL',
+  'postgres': 'select now()',
+  'mssql': 'select getdate()',
+  'mysql': 'select current_time',
+  'sqlite': 'select date()'
+};
+export function createChecker(query: SimpleDB|((sql: string) => Promise<any[]>), sql?: string, service?: string, timeout?: number): Checker {
+  if (typeof query === 'function') {
+    if (!sql) {
+      sql = 'select getdate()';
+    }
+    return new Checker(query, sql, service, timeout);
+  } else {
+    const db = query as SimpleDB;
+    let s = driverMap[db.driver];
+    if (!s) {
+      s = 'select getdate()';
+    }
+    if (!service) {
+      service = db.driver;
+    }
+    return new Checker(db.query, s, service, timeout);
+  }
+}

package/src/index.ts

@@ -1,8 +1,12 @@
+import {Checker} from './health';
+export {Checker as SqlChecker};
+
 import {Attribute, StringMap} from './metadata';
 import {SqlLoader, SqlSearchLoader, SqlSearchWriter, SqlWriter} from './services';
 export {SqlLoader as SqlLoadRepository};
 export {SqlLoader as SqlViewRepository};
 export {SqlWriter as SqlGenericRepository};
+export {SqlWriter as Repository};
 
 export {SqlLoader as SqlLoadService};
 export {SqlLoader as SqlViewService};
@@ -21,10 +25,10 @@ export {SqlSearchWriter as GenericSearchRepository};
 export {SqlSearchWriter as GenericSearchService};
 export {SqlSearchWriter as SqlRepository};
 export {SqlSearchWriter as SqlService};
-export {SqlSearchWriter as Repository};
 export {SqlSearchWriter as Service};
 
 export * from './metadata';
+export * from './health';
 export * from './build';
 export * from './services';
 export * from './batch';

package/src/query.ts

@@ -52,7 +52,7 @@ export function buildOracleParam(i: number): string {
 export function buildDollarParam(i: number): string {
   return '$' + i;
 }
-export function buildQuery<S>(filter: S, bparam: LikeType|((i: number ) => string), table?: string, attrs?: Attributes, sort?: string, fields?: string[], sq?: string, strExcluding?: string, buildSort3?: (sort?: string, map?: Attributes|StringMap) => string): Statement|undefined {
+export function buildQuery<S>(filter: S, bparam: LikeType|((i: number ) => string), sort?: string, buildSort3?: (sort?: string, map?: Attributes|StringMap) => string, attrs?: Attributes, table?: string, fields?: string[], sq?: string, strExcluding?: string): Statement|undefined {
   if (!table || !attrs) {
     return undefined;
   }
@@ -149,6 +149,9 @@ export function buildQuery<S>(filter: S, bparam: LikeType|((i: number ) => strin
               if (v['max']) {
                 filters.push(`${field} <= ${param(i++)}`);
                 args.push(v['max']);
+              } else if (v['top']) {
+                filters.push(`${field} < ${param(i++)}`);
+                args.push(v['top']);
               } else if (v['endDate']) {
                 filters.push(`${field} <= ${param(i++)}`);
                 args.push(v['endDate']);
@@ -177,6 +180,8 @@ export function buildQuery<S>(filter: S, bparam: LikeType|((i: number ) => strin
             if (isNumberRange(v)) {
               if (v['max']) {
                 filters.push(`${field} <= ${v['max']}`);
+              } else if (v['top']) {
+                filters.push(`${field} < ${v['top']}`);
               } else if (v['upper']) {
                 filters.push(`${field} < ${v['upper']}`);
               }

package/src/services.ts

@@ -1,4 +1,4 @@
-import {attributes, buildToDelete, buildToInsert, buildToUpdate, exist, metadata, select, version} from './build';
+import {attributes, buildToDelete, buildToInsert, buildToUpdate, exist, metadata, select, toString, version} from './build';
 import {Attribute, Attributes, Statement, StringMap} from './metadata';
 import {SearchResult} from './search';
 
@@ -13,7 +13,7 @@ export class SqlLoader<T, ID> {
   attributes: Attributes;
   bools?: Attribute[];
   constructor(public table: string,
-    public query: (sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any) => Promise<T[]>,
+    public query: <K>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any) => Promise<K[]>,
     attrs: Attributes|string[],
     public param: (i: number) => string,
     public fromDB?: (v: T) => T) {
@@ -48,7 +48,7 @@ export class SqlLoader<T, ID> {
     }
     const fn = this.fromDB;
     if (fn) {
-      return this.query(stmt.query, stmt.params, this.map, ctx).then(res => {
+      return this.query<T>(stmt.query, stmt.params, this.map, ctx).then(res => {
         if (!res || res.length === 0) {
           return null;
         } else {
@@ -57,7 +57,7 @@ export class SqlLoader<T, ID> {
         }
       });
     } else {
-      return this.query(stmt.query, stmt.params, this.map).then(res => (!res || res.length === 0) ? null : res[0]);
+      return this.query<T>(stmt.query, stmt.params, this.map).then(res => (!res || res.length === 0) ? null : res[0]);
     }
   }
   exist(id: ID, ctx?: any): Promise<boolean> {
@@ -69,11 +69,12 @@ export class SqlLoader<T, ID> {
     return this.query(stmt.query, stmt.params, this.map, undefined, ctx).then(res => (!res || res.length === 0) ? false : true);
   }
 }
+// tslint:disable-next-line:max-classes-per-file
 export class SqlSearchLoader<T, ID, S extends Filter> extends SqlLoader<T, ID> {
   constructor(
       protected find: (s: S, limit?: number, offset?: number|string, fields?: string[]) => Promise<SearchResult<T>>,
       table: string,
-      query: (sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any) => Promise<T[]>,
+      query: <K>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any) => Promise<K[]>,
       attrs: Attributes|string[],
       param: (i: number) => string,
       fromDB?: (v: T) => T) {
@@ -91,13 +92,280 @@ export interface Manager {
   execBatch(statements: Statement[], firstSuccess?: boolean, ctx?: any): Promise<number>;
   query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any): Promise<T[]>;
 }
-export interface DB {
+export type DB  = Manager;
+export interface ExtManager {
   driver: string;
   param(i: number): string;
   exec(sql: string, args?: any[], ctx?: any): Promise<number>;
   execBatch(statements: Statement[], firstSuccess?: boolean, ctx?: any): Promise<number>;
   query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any): Promise<T[]>;
+  queryOne<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any): Promise<T|null>;
+  execScalar<T>(sql: string, args?: any[], ctx?: any): Promise<T>;
+  count(sql: string, args?: any[], ctx?: any): Promise<number>;
 }
+export interface SimpleMap {
+  [key: string]: string|number|boolean|Date;
+}
+export interface Logger {
+  level: number;
+  debug(msg: string, m?: SimpleMap, ctx?: any): void;
+  info(msg: string, m?: SimpleMap, ctx?: any): void;
+  error(msg: string, m?: SimpleMap, ctx?: any): void;
+  isDebugEnabled(): boolean;
+  isInfoEnabled(): boolean;
+}
+export function log(db: ExtManager, isLog: boolean|undefined|null, logger: Logger, q?: string, result?: string, r?: string, duration?: string): ExtManager {
+  if (!isLog) {
+    return db;
+  }
+  if (q !== undefined && q != null && q.length > 0) {
+    if (!logger.isDebugEnabled()) {
+      return db;
+    }
+    return new LogManager(db, logger.error, logger.debug, q, result, r, duration);
+  }
+  if (!logger.isInfoEnabled()) {
+    return db;
+  }
+  return new LogManager(db, logger.error, logger.info, q, result, r, duration);
+}
+export function useLog(db: ExtManager, isLog: boolean|undefined|null, err: ((msg: string, m?: SimpleMap) => void)|undefined, lg?: (msg: string, m?: SimpleMap) => void, q?: string, result?: string, r?: string, duration?: string): ExtManager {
+  if (!isLog) {
+    return db;
+  }
+  if (err) {
+    return new LogManager(db, err, lg, q, result, r, duration);
+  }
+  return db;
+}
+// tslint:disable-next-line:max-classes-per-file
+export class LogManager implements ExtManager {
+  constructor(public db: ExtManager, err: (msg: string, m?: SimpleMap) => void, lg?: (msg: string, m?: SimpleMap) => void, q?: string, result?: string, r?: string, duration?: string) {
+    this.driver = db.driver;
+    this.duration = (duration && duration.length > 0 ? duration : 'duration');
+    this.sql = (q === undefined ? '' : q);
+    this.return = (r !== undefined && r != null ? r : 'count');
+    this.result = (result !== undefined && result != null ? result : '');
+    // this.err = (er ? er : 'error');
+    this.log = lg;
+    this.error = err;
+    this.param = this.param.bind(this);
+    this.exec = this.exec.bind(this);
+    this.execBatch = this.execBatch.bind(this);
+    this.query = this.query.bind(this);
+    this.queryOne = this.queryOne.bind(this);
+    this.execScalar = this.execScalar.bind(this);
+    this.count = this.count.bind(this);
+  }
+  log?: (msg: string, m?: SimpleMap, ctx?: any) => void;
+  error: (msg: string, m?: SimpleMap, ctx?: any) => void;
+  driver: string;
+  duration: string;
+  sql: string;
+  return: string;
+  result: string;
+  // err: string;
+  param(i: number): string {
+    return this.db.param(i);
+  }
+  exec(sql: string, args?: any[], ctx?: any): Promise<number> {
+    const t1 = new Date();
+    return this.db.exec(sql, args, ctx);
+  }
+  execBatch(statements: Statement[], firstSuccess?: boolean, ctx?: any): Promise<number> {
+    const t1 = new Date();
+    return this.db.execBatch(statements, firstSuccess, ctx).then(v => {
+      setTimeout(() => {
+        if (this.log) {
+          const d = diff(t1);
+          const obj: SimpleMap = {} ;
+          if (this.sql.length > 0) {
+            obj[this.sql] = JSON.stringify(statements);
+          }
+          if (this.return.length > 0) {
+            obj[this.return] = v;
+          }
+          obj[this.duration] = d;
+          this.log('exec batch', obj);
+        }
+      }, 0);
+      return v;
+    }).catch(er => {
+      setTimeout(() => {
+        const d = diff(t1);
+        const obj: SimpleMap = {};
+        if (this.sql.length > 0) {
+          obj[this.sql] = JSON.stringify(statements);
+        }
+        obj[this.duration] = d;
+        this.error('error exec batch: ' + buildString(er));
+      }, 0);
+      throw er;
+    });
+  }
+  query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any): Promise<T[]> {
+    const t1 = new Date();
+    return this.db.query<T>(sql, args, m, bools, ctx).then(v => {
+      setTimeout(() => {
+        if (this.log) {
+          const d = diff(t1);
+          const obj: SimpleMap = {} ;
+          if (this.sql.length > 0) {
+            obj[this.sql] = getString(sql, args);
+          }
+          if (this.result.length > 0) {
+            if (v && v.length > 0) {
+              obj[this.result] = JSON.stringify(v);
+            }
+          }
+          if (this.return.length > 0) {
+            obj[this.return] = v ? v.length : 0;
+          }
+          obj[this.duration] = d;
+          this.log('query', obj);
+        }
+      }, 0);
+      return v;
+    }).catch(er => {
+      setTimeout(() => {
+        const d = diff(t1);
+        const obj: SimpleMap = {};
+        if (this.sql.length > 0) {
+          obj[this.sql] = getString(sql, args);
+        }
+        obj[this.duration] = d;
+        this.error('error query: ' + buildString(er));
+      }, 0);
+      throw er;
+    });
+  }
+  queryOne<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any): Promise<T|null> {
+    const t1 = new Date();
+    return this.db.queryOne<T>(sql, args, m, bools, ctx).then(v => {
+      setTimeout(() => {
+        if (this.log) {
+          const d = diff(t1);
+          const obj: SimpleMap = {} ;
+          if (this.sql.length > 0) {
+            obj[this.sql] = getString(sql, args);
+          }
+          if (this.result.length > 0) {
+            obj[this.result] = v ? JSON.stringify(v) : 'null';
+          }
+          if (this.return.length > 0) {
+            obj[this.return] = v ? 1 : 0;
+          }
+          obj[this.duration] = d;
+          this.log('query one', obj);
+        }
+      }, 0);
+      return v;
+    }).catch(er => {
+      setTimeout(() => {
+        const d = diff(t1);
+        const obj: SimpleMap = {};
+        if (this.sql.length > 0) {
+          obj[this.sql] = getString(sql, args);
+        }
+        obj[this.duration] = d;
+        this.error('error query one: ' + buildString(er));
+      }, 0);
+      throw er;
+    });
+  }
+  execScalar<T>(sql: string, args?: any[], ctx?: any): Promise<T> {
+    const t1 = new Date();
+    return this.db.execScalar<T>(sql, args, ctx).then(v => {
+      setTimeout(() => {
+        if (this.log) {
+          const d = diff(t1);
+          const obj: SimpleMap = {} ;
+          if (this.sql.length > 0) {
+            obj[this.sql] = getString(sql, args);
+          }
+          if (this.result.length > 0) {
+            obj[this.result] = v ? buildString(v) : 'null';
+          }
+          if (this.return.length > 0) {
+            obj[this.return] = v ? 1 : 0;
+          }
+          obj[this.duration] = d;
+          this.log('exec scalar', obj);
+        }
+      }, 0);
+      return v;
+    }).catch(er => {
+      setTimeout(() => {
+        const d = diff(t1);
+        const obj: SimpleMap = {};
+        if (this.sql.length > 0) {
+          obj[this.sql] = getString(sql, args);
+        }
+        obj[this.duration] = d;
+        this.error('error exec scalar: ' + buildString(er));
+      }, 0);
+      throw er;
+    });
+  }
+  count(sql: string, args?: any[], ctx?: any): Promise<number> {
+    const t1 = new Date();
+    return this.db.count(sql, args).then(v => {
+      setTimeout(() => {
+        if (this.log) {
+          const d = diff(t1);
+          const obj: SimpleMap = {} ;
+          if (this.sql.length > 0) {
+            obj[this.sql] = getString(sql, args);
+          }
+          if (this.return.length > 0) {
+            obj[this.return] = v;
+          }
+          obj[this.duration] = d;
+          this.log('count', obj);
+        }
+      }, 0);
+      return v;
+    }).catch(er => {
+      setTimeout(() => {
+        const d = diff(t1);
+        const obj: SimpleMap = {};
+        if (this.sql.length > 0) {
+          obj[this.sql] = getString(sql, args);
+        }
+        obj[this.duration] = d;
+        this.error('error count: ' + buildString(er));
+      }, 0);
+      throw er;
+    });
+  }
+}
+function buildString(v: any): string {
+  if (typeof v === 'string') {
+    return v;
+  } else {
+    return JSON.stringify(v);
+  }
+}
+function getString(sql: string, args?: any[]): string {
+  if (args && args.length > 0) {
+    return sql + ' ' + JSON.stringify(args);
+  } else {
+    return sql;
+  }
+}
+export function diff(d1: Date): number {
+  const d2 = new Date();
+  return d2.getTime() - d1.getTime();
+}
+/*
+const NS_PER_SEC = 1e9;
+const NS_TO_MS = 1e6;
+const getDurationInMilliseconds = (start: [number, number] | undefined) => {
+  const diff = process.hrtime(start);
+  return (diff[0] * NS_PER_SEC + diff[1]) / NS_TO_MS;
+};
+*/
+// tslint:disable-next-line:max-classes-per-file
 export class SqlWriter<T, ID> extends SqlLoader<T, ID> {
   version?: string;
   exec: (sql: string, args?: any[], ctx?: any) => Promise<number>;
@@ -160,6 +428,7 @@ export class SqlWriter<T, ID> extends SqlLoader<T, ID> {
     }
   }
 }
+// tslint:disable-next-line:max-classes-per-file
 export class SqlSearchWriter<T, ID, S extends Filter> extends SqlWriter<T, ID> {
   constructor(
       protected find: (s: S, limit?: number, offset?: number|string, fields?: string[]) => Promise<SearchResult<T>>,