query-core 0.2.0 → 0.2.1

package/src/SearchBuilder.ts

@@ -1,150 +1,183 @@
-import {exist, metadata, param, select} from './build';
-import {Attribute, Attributes, Statement, StringMap} from './metadata';
-import {buildDollarParam, buildMsSQLParam, buildOracleParam, buildQuery, buildSort as bs, LikeType} from './query';
-import {buildFromQuery, oracle, SearchResult} from './search';
+import { exist, metadata, param, select } from "./build"
+import { Attribute, Attributes, Statement, StringMap } from "./metadata"
+import { buildSort as bs, buildDollarParam, buildMsSQLParam, buildOracleParam, buildQuery, LikeType } from "./query"
+import { buildFromQuery, oracle, SearchResult } from "./search"
 
-export const postgres = 'postgres';
-export const mssql = 'mssql';
-export const mysql = 'mysql';
-export const sqlite = 'sqlite';
+export const postgres = "postgres"
+export const mssql = "mssql"
+export const mysql = "mysql"
+export const sqlite = "sqlite"
 export class SearchBuilder<T, S> {
-  map?: StringMap;
-  bools?: Attribute[];
-  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;
-  param: (i: number) => string;
-  total?: string;
-  constructor(public query: <K>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any) => Promise<K[]>,
+  map?: StringMap
+  bools?: Attribute[]
+  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
+  param: (i: number) => string
+  total?: string
+  constructor(
+    public query: <K>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any) => Promise<K[]>,
     public table: string,
     public attributes?: Attributes,
     public provider?: string,
-    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,
+    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,
     excluding?: string,
-    buildSort?: (sort?: string, map?: Attributes|StringMap) => string,
+    buildSort?: (sort?: string, map?: Attributes | StringMap) => string,
     buildParam?: (i: number) => string,
-    total?: string) {
-      if (attributes) {
-        this.attributes = attributes;
-        const meta = metadata(attributes);
-        this.map = meta.map;
-        this.bools = meta.bools;
-      }
-      this.buildQuery = buildQ ? buildQ : buildQuery;
-      this.buildSort = (buildSort ? buildSort : bs);
-      this.q = (q && q.length > 0 ? q : 'q');
-      this.excluding = (excluding && excluding.length > 0 ? excluding : 'excluding');
-      this.search = this.search.bind(this);
-      if (buildParam) {
-        this.param = buildParam;
+    total?: string,
+  ) {
+    if (attributes) {
+      this.attributes = attributes
+      const meta = metadata(attributes)
+      this.map = meta.map
+      this.bools = meta.bools
+    }
+    this.buildQuery = buildQ ? buildQ : buildQuery
+    this.buildSort = buildSort ? buildSort : bs
+    this.q = q && q.length > 0 ? q : "q"
+    this.excluding = excluding && excluding.length > 0 ? excluding : "excluding"
+    this.search = this.search.bind(this)
+    if (buildParam) {
+      this.param = buildParam
+    } else {
+      if (provider === oracle) {
+        this.param = buildOracleParam
+      } else if (provider === postgres) {
+        this.param = buildDollarParam
+      } else if (provider === mssql) {
+        this.param = buildMsSQLParam
       } else {
-        if (provider === oracle) {
-          this.param = buildOracleParam;
-        } else if (provider === postgres) {
-          this.param = buildDollarParam;
-        } else if (provider === mssql) {
-          this.param = buildMsSQLParam;
-        } else {
-          this.param = param;
-        }
+        this.param = param
       }
-      this.total = (total && total.length > 0 ? total : 'total');
     }
-  search(s: S, limit?: number, offset?: number|string, fields?: string[]): Promise<SearchResult<T>> {
-    let skip = 0;
-    if (typeof offset === 'number' && offset > 0) {
-      skip = offset;
+    this.total = total && total.length > 0 ? total : "total"
+  }
+  search(s: S, limit?: number, offset?: number | string, fields?: string[]): Promise<SearchResult<T>> {
+    let skip = 0
+    if (typeof offset === "number" && offset > 0) {
+      skip = offset
     }
-    const st = (this.sort ? this.sort : 'sort');
-    const sn = (s as any)[st] as string;
-    delete (s as any)[st];
-    const x = (this.provider === postgres ? 'ilike' : this.param);
-    const q2 = this.buildQuery(s, x, sn, this.buildSort, this.attributes, this.table, fields, this.q, this.excluding);
+    const st = this.sort ? this.sort : "sort"
+    const sn = (s as any)[st] as string
+    delete (s as any)[st]
+    const x = this.provider === postgres ? "ilike" : this.param
+    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');
+      throw new Error("Cannot build query")
     }
-    const fn = this.fromDB;
+    const fn = this.fromDB
     if (fn) {
-      return buildFromQuery<T>(this.query, q2.query, q2.params, limit, skip, this.map, this.bools, this.provider, this.total).then(r => {
+      return buildFromQuery<T>(this.query, q2.query, q2.params, limit, skip, this.map, this.bools, this.provider, this.total).then((r) => {
         if (r.list && r.list.length > 0) {
-          r.list = r.list.map(o => fn(o));
-          return r;
+          r.list = r.list.map((o) => fn(o))
+          return r
         } else {
-          return r;
+          return r
         }
-      });
+      })
     } else {
-      return buildFromQuery(this.query, q2.query, q2.params, limit, skip, this.map, this.bools, this.provider, this.total);
+      return buildFromQuery(this.query, q2.query, q2.params, limit, skip, this.map, this.bools, this.provider, this.total)
     }
   }
 }
 // tslint:disable-next-line:max-classes-per-file
 export class Query<T, ID, S> extends SearchBuilder<T, S> {
-  primaryKeys: Attribute[];
-  map?: StringMap;
+  primaryKeys: Attribute[]
+  map?: StringMap
   // attributes: Attributes;
-  bools?: Attribute[];
+  bools?: Attribute[]
   constructor(
-      query: <K>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any) => Promise<K[]>,
-      table: string,
-      attributes: Attributes,
-      provider?: string,
-      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,
-      fromDB?: (v: T) => T,
+    query: <K>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any) => Promise<K[]>,
+    table: string,
+    attributes: Attributes,
+    provider?: string,
+    buildQ?: (
+      s: S,
+      bparam: LikeType | ((i: number) => string),
       sort?: string,
-      q?: string,
-      excluding?: string,
-      buildSort?: (sort?: string, map?: Attributes|StringMap) => string,
-      buildParam?: (i: number) => string,
-      total?: string) {
-    super(query, table, attributes, provider, buildQ, fromDB, sort, q, excluding, buildSort, buildParam, total);
-    const m = metadata(attributes);
-    this.primaryKeys = m.keys;
-    this.map = m.map;
-    this.bools = m.bools;
+      buildSort3?: (sort?: string, map?: Attributes | StringMap) => string,
+      attrs?: Attributes,
+      table?: string,
+      fields?: string[],
+      sq?: string,
+      strExcluding?: string,
+    ) => Statement | undefined,
+    fromDB?: (v: T) => T,
+    sort?: string,
+    q?: string,
+    excluding?: string,
+    buildSort?: (sort?: string, map?: Attributes | StringMap) => string,
+    buildParam?: (i: number) => string,
+    total?: string,
+  ) {
+    super(query, table, attributes, provider, buildQ, fromDB, sort, q, excluding, buildSort, buildParam, total)
+    const m = metadata(attributes)
+    this.primaryKeys = m.keys
+    this.map = m.map
+    this.bools = m.bools
     if (this.metadata) {
-      this.metadata = this.metadata.bind(this);
+      this.metadata = this.metadata.bind(this)
     }
-    this.all = this.all.bind(this);
-    this.load = this.load.bind(this);
-    this.exist = this.exist.bind(this);
+    this.all = this.all.bind(this)
+    this.load = this.load.bind(this)
+    this.exist = this.exist.bind(this)
   }
-  metadata?(): Attributes|undefined {
-    return this.attributes;
+  metadata?(): Attributes | undefined {
+    return this.attributes
   }
   all(): Promise<T[]> {
-    const sql = `select * from ${this.table}`;
-    return this.query(sql, [], this.map);
+    const sql = `select * from ${this.table}`
+    return this.query(sql, [], this.map)
   }
-  load(id: ID, ctx?: any): Promise<T|null> {
-    const stmt = select<ID>(id, this.table, this.primaryKeys, this.param);
+  load(id: ID, ctx?: any): Promise<T | null> {
+    const stmt = select<ID>(id, this.table, this.primaryKeys, this.param)
     if (!stmt) {
-      throw new Error('cannot build query by id');
+      throw new Error("cannot build query by id")
     }
-    const fn = this.fromDB;
+    const fn = this.fromDB
     if (fn) {
-      return this.query<T>(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;
+          return null
         } else {
-          const obj = res[0];
-          return fn(obj);
+          const obj = res[0]
+          return fn(obj)
         }
-      });
+      })
     } else {
-      return this.query<T>(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> {
-    const field = (this.primaryKeys[0].column ? this.primaryKeys[0].column : this.primaryKeys[0].name);
-    const stmt = exist<ID>(id, this.table, this.primaryKeys, this.param, field);
+    const field = this.primaryKeys[0].column ? this.primaryKeys[0].column : this.primaryKeys[0].name
+    const stmt = exist<ID>(id, this.table, this.primaryKeys, this.param, field)
     if (!stmt) {
-      throw new Error('cannot build query by id');
+      throw new Error("cannot build query by id")
     }
-    return this.query(stmt.query, stmt.params, this.map, undefined, ctx).then(res => (!res || res.length === 0) ? false : true);
+    return this.query(stmt.query, stmt.params, this.map, undefined, ctx).then((res) => (!res || res.length === 0 ? false : true))
   }
 }

package/src/batch.ts

@@ -1,233 +1,276 @@
-import { buildToInsert, buildToInsertBatch, buildToUpdate, buildToUpdateBatch, version } from './build';
-import { Attributes, Statement } from './metadata';
+import { buildToInsert, buildToInsertBatch, buildToUpdate, buildToUpdateBatch, version } from "./build"
+import { Attributes, Statement } from "./metadata"
 
 export class SqlInserter<T> {
-  version?: string;
-  constructor(public exec: (sql: string, args?: any[]) => Promise<number>, public table: string, public attributes: Attributes, public param: (i: number) => string, public oneIfSuccess?: boolean, public map?: (v: T) => T) {
-    this.write = this.write.bind(this);
-    const x = version(attributes);
+  version?: string
+  constructor(
+    public exec: (sql: string, args?: any[]) => Promise<number>,
+    public table: string,
+    public attributes: Attributes,
+    public param: (i: number) => string,
+    public oneIfSuccess?: boolean,
+    public map?: (v: T) => T,
+  ) {
+    this.write = this.write.bind(this)
+    const x = version(attributes)
     if (x) {
-      this.version = x.name;
+      this.version = x.name
     }
   }
   write(obj: T): Promise<number> {
     if (!obj) {
-      return Promise.resolve(0);
+      return Promise.resolve(0)
     }
-    let obj2: NonNullable<T> | T = obj;
+    let obj2: NonNullable<T> | T = obj
     if (this.map) {
-      obj2 = this.map(obj);
+      obj2 = this.map(obj)
     }
-    const stmt = buildToInsert(obj2, this.table, this.attributes, this.param, this.version);
+    const stmt = buildToInsert(obj2, this.table, this.attributes, this.param, this.version)
     if (stmt) {
       if (this.oneIfSuccess) {
-        return this.exec(stmt.query, stmt.params).then(ct => ct > 0 ? 1 : 0);
+        return this.exec(stmt.query, stmt.params).then((ct) => (ct > 0 ? 1 : 0))
       } else {
-        return this.exec(stmt.query, stmt.params);
+        return this.exec(stmt.query, stmt.params)
       }
     } else {
-      return Promise.resolve(0);
+      return Promise.resolve(0)
     }
   }
 }
 // tslint:disable-next-line:max-classes-per-file
 export class SqlUpdater<T> {
-  version?: string;
-  constructor(public exec: (sql: string, args?: any[]) => Promise<number>, public table: string, public attributes: Attributes, public param: (i: number) => string, public oneIfSuccess?: boolean, public map?: (v: T) => T) {
-    this.write = this.write.bind(this);
-    const x = version(attributes);
+  version?: string
+  constructor(
+    public exec: (sql: string, args?: any[]) => Promise<number>,
+    public table: string,
+    public attributes: Attributes,
+    public param: (i: number) => string,
+    public oneIfSuccess?: boolean,
+    public map?: (v: T) => T,
+  ) {
+    this.write = this.write.bind(this)
+    const x = version(attributes)
     if (x) {
-      this.version = x.name;
+      this.version = x.name
     }
   }
   write(obj: T): Promise<number> {
     if (!obj) {
-      return Promise.resolve(0);
+      return Promise.resolve(0)
     }
-    let obj2: NonNullable<T> | T = obj;
+    let obj2: NonNullable<T> | T = obj
     if (this.map) {
-      obj2 = this.map(obj);
+      obj2 = this.map(obj)
     }
-    const stmt = buildToUpdate(obj2, this.table, this.attributes, this.param, this.version);
+    const stmt = buildToUpdate(obj2, this.table, this.attributes, this.param, this.version)
     if (stmt) {
       if (this.oneIfSuccess) {
-        return this.exec(stmt.query, stmt.params).then(ct => ct > 0 ? 1 : 0);
+        return this.exec(stmt.query, stmt.params).then((ct) => (ct > 0 ? 1 : 0))
       } else {
-        return this.exec(stmt.query, stmt.params);
+        return this.exec(stmt.query, stmt.params)
       }
     } else {
-      return Promise.resolve(0);
+      return Promise.resolve(0)
     }
   }
 }
 // tslint:disable-next-line:max-classes-per-file
 export class SqlBatchInserter<T> {
-  version?: string;
-  constructor(public exec: (sql: string, args?: any[]) => Promise<number>, public table: string, public attributes: Attributes, public param: ((i: number) => string) | boolean, public oneIfSuccess?: boolean, public map?: (v: T) => T) {
-    this.write = this.write.bind(this);
-    const x = version(attributes);
+  version?: string
+  constructor(
+    public exec: (sql: string, args?: any[]) => Promise<number>,
+    public table: string,
+    public attributes: Attributes,
+    public param: ((i: number) => string) | boolean,
+    public oneIfSuccess?: boolean,
+    public map?: (v: T) => T,
+  ) {
+    this.write = this.write.bind(this)
+    const x = version(attributes)
     if (x) {
-      this.version = x.name;
+      this.version = x.name
     }
   }
   write(objs: T[]): Promise<number> {
     if (!objs || objs.length === 0) {
-      return Promise.resolve(0);
+      return Promise.resolve(0)
     }
-    let list = objs;
+    let list = objs
     if (this.map) {
-      list = [];
+      list = []
       for (const obj of objs) {
-        const obj2 = this.map(obj);
-        list.push(obj2);
+        const obj2 = this.map(obj)
+        list.push(obj2)
       }
     }
-    const stmt = buildToInsertBatch(list, this.table, this.attributes, this.param, this.version);
+    const stmt = buildToInsertBatch(list, this.table, this.attributes, this.param, this.version)
     if (stmt) {
       if (this.oneIfSuccess) {
-        return this.exec(stmt.query, stmt.params).then(ct => objs.length);
+        return this.exec(stmt.query, stmt.params).then((ct) => objs.length)
       } else {
-        return this.exec(stmt.query, stmt.params);
+        return this.exec(stmt.query, stmt.params)
       }
     } else {
-      return Promise.resolve(0);
+      return Promise.resolve(0)
     }
   }
 }
 // tslint:disable-next-line:max-classes-per-file
 export class SqlBatchUpdater<T> {
-  version?: string;
-  constructor(public execBatch: (statements: Statement[]) => Promise<number>, public table: string, public attributes: Attributes, public param: (i: number) => string, public oneIfSuccess?: boolean, protected notSkipInvalid?: boolean, public map?: (v: T) => T) {
-    this.write = this.write.bind(this);
-    const x = version(attributes);
+  version?: string
+  constructor(
+    public execBatch: (statements: Statement[]) => Promise<number>,
+    public table: string,
+    public attributes: Attributes,
+    public param: (i: number) => string,
+    public oneIfSuccess?: boolean,
+    protected notSkipInvalid?: boolean,
+    public map?: (v: T) => T,
+  ) {
+    this.write = this.write.bind(this)
+    const x = version(attributes)
     if (x) {
-      this.version = x.name;
+      this.version = x.name
     }
   }
   write(objs: T[]): Promise<number> {
     if (!objs || objs.length === 0) {
-      return Promise.resolve(0);
+      return Promise.resolve(0)
     }
-    let list = objs;
+    let list = objs
     if (this.map) {
-      list = [];
+      list = []
       for (const obj of objs) {
-        const obj2 = this.map(obj);
-        list.push(obj2);
+        const obj2 = this.map(obj)
+        list.push(obj2)
       }
     }
-    const stmts = buildToUpdateBatch(list, this.table, this.attributes, this.param, this.notSkipInvalid);
+    const stmts = buildToUpdateBatch(list, this.table, this.attributes, this.param, this.notSkipInvalid)
     if (stmts && stmts.length > 0) {
       if (this.oneIfSuccess) {
-        return this.execBatch(stmts).then(ct => stmts.length);
+        return this.execBatch(stmts).then((ct) => stmts.length)
       } else {
-        return this.execBatch(stmts);
+        return this.execBatch(stmts)
       }
     } else {
-      return Promise.resolve(0);
+      return Promise.resolve(0)
     }
   }
 }
 // tslint:disable-next-line:max-classes-per-file
 export class StreamInserter<T> {
-  list: T[] = [];
-  size = 0;
-  version?: string;
-  map?: (v: T) => T;
-  constructor(public exec: ((sql: string, args?: any[]) => Promise<number>), public table: string, public attributes: Attributes, public param: (i: number) => string, size?: number, toDB?: (v: T) => T) {
-    this.write = this.write.bind(this);
-    this.flush = this.flush.bind(this);
-    this.map = toDB;
-    const x = version(attributes);
+  list: T[] = []
+  size = 0
+  version?: string
+  map?: (v: T) => T
+  constructor(
+    public exec: (sql: string, args?: any[]) => Promise<number>,
+    public table: string,
+    public attributes: Attributes,
+    public param: (i: number) => string,
+    size?: number,
+    toDB?: (v: T) => T,
+  ) {
+    this.write = this.write.bind(this)
+    this.flush = this.flush.bind(this)
+    this.map = toDB
+    const x = version(attributes)
     if (x) {
-      this.version = x.name;
+      this.version = x.name
     }
     if (size !== undefined && size > 0) {
-      this.size = size;
+      this.size = size
     }
   }
   write(obj: T): Promise<number> {
     if (!obj) {
-      return Promise.resolve(0);
+      return Promise.resolve(0)
     }
-    let obj2: NonNullable<T> | T = obj;
+    let obj2: NonNullable<T> | T = obj
     if (this.map) {
-      obj2 = this.map(obj);
-      this.list.push(obj2);
+      obj2 = this.map(obj)
+      this.list.push(obj2)
     } else {
-      this.list.push(obj);
+      this.list.push(obj)
     }
     if (this.list.length < this.size) {
-      return Promise.resolve(0);
+      return Promise.resolve(0)
     } else {
-      return this.flush();
+      return this.flush()
     }
   }
   flush(): Promise<number> {
     if (!this.list || this.list.length === 0) {
-      return Promise.resolve(0);
+      return Promise.resolve(0)
     } else {
-      const total = this.list.length;
-      const stmt = buildToInsertBatch(this.list, this.table, this.attributes, this.param, this.version);
+      const total = this.list.length
+      const stmt = buildToInsertBatch(this.list, this.table, this.attributes, this.param, this.version)
       if (stmt) {
-        return this.exec(stmt.query, stmt.params).then(r => {
-          this.list = [];
-          return total;
-        });
+        return this.exec(stmt.query, stmt.params).then((r) => {
+          this.list = []
+          return total
+        })
       } else {
-        return Promise.resolve(0);
+        return Promise.resolve(0)
       }
     }
   }
 }
 // tslint:disable-next-line:max-classes-per-file
 export class StreamUpdater<T> {
-  list: T[] = [];
-  size = 0;
-  version?: string;
-  map?: (v: T) => T;
-  constructor(public execBatch: ((statements: Statement[]) => Promise<number>), public table: string, public attributes: Attributes, public param: (i: number) => string, size?: number, toDB?: (v: T) => T) {
-    this.write = this.write.bind(this);
-    this.flush = this.flush.bind(this);
-    this.map = toDB;
-    const x = version(attributes);
+  list: T[] = []
+  size = 0
+  version?: string
+  map?: (v: T) => T
+  constructor(
+    public execBatch: (statements: Statement[]) => Promise<number>,
+    public table: string,
+    public attributes: Attributes,
+    public param: (i: number) => string,
+    size?: number,
+    toDB?: (v: T) => T,
+  ) {
+    this.write = this.write.bind(this)
+    this.flush = this.flush.bind(this)
+    this.map = toDB
+    const x = version(attributes)
     if (x) {
-      this.version = x.name;
+      this.version = x.name
     }
     if (size !== undefined && size > 0) {
-      this.size = size;
+      this.size = size
     }
   }
   write(obj: T): Promise<number> {
     if (!obj) {
-      return Promise.resolve(0);
+      return Promise.resolve(0)
     }
-    let obj2: NonNullable<T> | T = obj;
+    let obj2: NonNullable<T> | T = obj
     if (this.map) {
-      obj2 = this.map(obj);
-      this.list.push(obj2);
+      obj2 = this.map(obj)
+      this.list.push(obj2)
     } else {
-      this.list.push(obj);
+      this.list.push(obj)
     }
     if (this.list.length < this.size) {
-      return Promise.resolve(0);
+      return Promise.resolve(0)
     } else {
-      return this.flush();
+      return this.flush()
     }
   }
   flush(): Promise<number> {
     if (!this.list || this.list.length === 0) {
-      return Promise.resolve(0);
+      return Promise.resolve(0)
     } else {
-      const total = this.list.length;
-      const stmt = buildToUpdateBatch(this.list, this.table, this.attributes, this.param);
+      const total = this.list.length
+      const stmt = buildToUpdateBatch(this.list, this.table, this.attributes, this.param)
       if (stmt) {
-        return this.execBatch(stmt).then(r => {
-          this.list = [];
-          return total;
-        });
+        return this.execBatch(stmt).then((r) => {
+          this.list = []
+          return total
+        })
       } else {
-        return Promise.resolve(0);
+        return Promise.resolve(0)
       }
     }
   }