mysql2-core 0.3.10 → 0.5.1

package/src/build.ts

@@ -59,35 +59,55 @@ export function metadata(attrs: Attributes): Metadata {
   }
   return m
 }
-export function buildToSave<T>(obj: T, table: string, attrs: Attributes, buildParam?: (i: number) => string, i?: number): Statement {
-  if (!i) {
-    i = 1
-  }
+export function buildToSave<T>(obj: T, table: string, attrs: Attributes, pks?: Attribute[], ver?: string, buildParam?: (i: number) => string): Statement {
   if (!buildParam) {
     buildParam = param
   }
   const ks = Object.keys(attrs)
-  const pks: Attribute[] = []
+  if (!pks) {
+    pks = []
+    for (const k of ks) {
+      const attr = attrs[k]
+      attr.name = k
+      if (attr.key) {
+        pks.push(attr)
+      }
+      if (attr.version) {
+        ver = k
+      }
+    }
+  }
+
   const cols: string[] = []
   const values: string[] = []
   const args: any[] = []
-  let isVersion = false
   const o: any = obj
+  let isUpdate = true
+  let isVersion = false
+  for (const k of pks) {
+    if (k.name) {
+      let v = o[k.name]
+      if (v == null) {
+        isUpdate = false
+      }
+    }
+  }
+  let i = 1
   for (const k of ks) {
     const attr = attrs[k]
-    attr.name = k
-    if (attr.key) {
-      pks.push(attr)
+    if (!attr) {
+      continue
     }
     let v = o[k]
-    if (v == null) {
+    if (v == null && attr.default !== undefined) {
       v = attr.default
     }
     if (v != null && !attr.ignored && !attr.noinsert) {
       const field = attr.column ? attr.column : k
       cols.push(field)
-      if (attr.version) {
+      if (k === ver) {
         isVersion = true
+        ver = k
         values.push(`${1}`)
       } else {
         if (v === "") {
@@ -99,10 +119,10 @@ export function buildToSave<T>(obj: T, table: string, attrs: Attributes, buildPa
           values.push(p)
           if (typeof v === "boolean") {
             if (v === true) {
-              const v2 = attr.true !== undefined ? attr.true : `'1'`
+              const v2 = attr.true !== undefined ? attr.true : `1`
               args.push(v2)
             } else {
-              const v2 = attr.false !== undefined ? attr.false : `'0'`
+              const v2 = attr.false !== undefined ? attr.false : `0`
               args.push(v2)
             }
           } else {
@@ -112,15 +132,29 @@ export function buildToSave<T>(obj: T, table: string, attrs: Attributes, buildPa
       }
     }
   }
-  if (pks.length === 0) {
+  if (cols.length > 0 && ver && isVersion === false) {
+    const attr = attrs[ver]
+    if (attr) {
+      const field = attr.column ? attr.column : ver
+      cols.push(field)
+      values.push("1")
+    }
+  }
+  if (isUpdate === false || pks.length === 0) {
     if (cols.length === 0) {
       return { query: "", params: args }
     } else {
-      const q = `insert into ${table}(${cols.join(",")})values(${values.join(",")})`
-      return { query: q, params: args }
+      if (pks.length === 0) {
+        const q = `insert into ${table}(${cols.join(",")})values(${values.join(",")})`
+        return { query: q, params: args }
+      } else {
+        const q = `insert ignore into ${table}(${cols.join(",")})values(${values.join(",")})`
+        return { query: q, params: args }
+      }
     }
   } else {
     const colSet: string[] = []
+    let version: string | null = null
     for (const k of ks) {
       const v = o[k]
       if (v !== undefined) {
@@ -128,98 +162,52 @@ export function buildToSave<T>(obj: T, table: string, attrs: Attributes, buildPa
         if (attr && !attr.key && !attr.ignored && !attr.noupdate) {
           const field = attr.column ? attr.column : k
           let x: string
-          if (v === null) {
-            x = "null"
-          } else if (v === "") {
-            x = `''`
-          } else if (typeof v === "number") {
-            x = toString(v)
+          if (attr.version) {
+            version = k
+            x = `${field} + 1`
           } else {
-            x = buildParam(i++)
-            if (typeof v === "boolean") {
-              if (v === true) {
-                const v2 = attr.true !== undefined ? attr.true : `'1'`
-                args.push(v2)
+            if (v === "") {
+              x = `''`
+            } else if (typeof v === "number") {
+              x = toString(v)
+            } else {
+              x = buildParam(i++)
+              if (typeof v === "boolean") {
+                if (v === true) {
+                  const v2 = attr.true !== undefined ? attr.true : `1`
+                  args.push(v2)
+                } else {
+                  const v2 = attr.false !== undefined ? attr.false : `0`
+                  args.push(v2)
+                }
               } else {
-                const v2 = attr.false !== undefined ? attr.false : `'0'`
-                args.push(v2)
+                args.push(v)
               }
-            } else {
-              args.push(v)
             }
           }
           colSet.push(`${field}=${x}`)
         }
       }
     }
-    if (colSet.length === 0) {
-      const q = `insert ignore into ${table}(${cols.join(",")})values(${values.join(",")})`
-      return { query: q, params: args }
-    } else {
-      const q = `insert into ${table}(${cols.join(",")})values(${values.join(",")}) on duplicate key update ${colSet.join(",")}`
-      return { query: q, params: args }
-    }
-  }
-}
-export function buildToSaveBatch<T>(objs: T[], table: string, attrs: Attributes, buildParam?: (i: number) => string): Statement[] {
-  if (!buildParam) {
-    buildParam = param
-  }
-  const sts: Statement[] = []
-  const ks = Object.keys(attrs)
-  for (const obj of objs) {
-    let i = 1
-    const cols: string[] = []
-    const values: string[] = []
-    const args: any[] = []
-    let isVersion = false
-    const o: any = obj
-    for (const k of ks) {
-      const attr = attrs[k]
-      let v = o[k]
-      if (v == null) {
-        v = attr.default
-      }
-      if (v != null && !attr.ignored && !attr.noinsert) {
-        const field = attr.column ? attr.column : k
-        cols.push(field)
-        if (attr.version) {
-          isVersion = true
-          values.push(`${1}`)
-        } else {
-          if (v === "") {
-            values.push(`''`)
-          } else if (typeof v === "number") {
-            values.push(toString(v))
-          } else {
-            const p = buildParam(i++)
-            values.push(p)
-            if (typeof v === "boolean") {
-              if (v === true) {
-                const v2 = attr.true !== undefined ? attr.true : `'1'`
-                args.push(v2)
-              } else {
-                const v2 = attr.false !== undefined ? attr.false : `'0'`
-                args.push(v2)
-              }
-            } else {
-              args.push(v)
-            }
-          }
-        }
+    if (cols.length > 0) {
+      if (colSet.length === 0) {
+        const q = `insert ignore into ${table}(${cols.join(",")})values(${values.join(",")})`
+        return { query: q, params: args }
+      } else {
+        const q = `insert into ${table}(${cols.join(",")})values(${values.join(",")}) on duplicate key update ${colSet.join(",")}`
+        return { query: q, params: args }
       }
-    }
-    const colSet: string[] = []
-    for (const k of ks) {
-      const v = o[k]
-      if (v !== undefined) {
-        const attr = attrs[k]
-        if (attr && !attr.key && !attr.ignored && !attr.noupdate) {
-          const field = attr.column ? attr.column : k
+    } else {
+      if (colSet.length === 0) {
+        return { query: "", params: args }
+      } else {
+        const colQuery: string[] = []
+        for (const attr of pks) {
+          const field = attr.column ? attr.column : attr.name
+          const na = attr.name ? attr.name : ""
+          const v = o[na]
           let x: string
-          if (v === null) {
-            x = "null"
-          } else if (v === "") {
+          if (v === "") {
             x = `''`
           } else if (typeof v === "number") {
             x = toString(v)
@@ -227,27 +215,64 @@ export function buildToSaveBatch<T>(objs: T[], table: string, attrs: Attributes,
             x = buildParam(i++)
             if (typeof v === "boolean") {
               if (v === true) {
-                const v2 = attr.true !== undefined ? attr.true : `'1'`
+                const v2 = attr.true !== undefined ? "" + attr.true : `1`
                 args.push(v2)
               } else {
-                const v2 = attr.false !== undefined ? attr.false : `'0'`
+                const v2 = attr.false !== undefined ? "" + attr.false : `0`
                 args.push(v2)
               }
             } else {
               args.push(v)
             }
           }
-          colSet.push(`${field}=${x}`)
+          colQuery.push(`${field}=${x}`)
+        }
+        if (version && version.length > 0) {
+          const v = o[version]
+          if (typeof v === "number" && !isNaN(v)) {
+            const attr = attrs[version]
+            if (attr) {
+              const field = attr.column ? attr.column : version
+              colQuery.push(`${field}=${v}`)
+            }
+          }
         }
+        const q = `update ${table} set ${colSet.join(",")} where ${colQuery.join(" and ")}`
+        return { query: q, params: args }
       }
     }
-    if (colSet.length === 0) {
-      const q = `insert ignore into ${table}(${cols.join(",")})values(${values.join(",")});`
-      const smt: Statement = { query: q, params: args }
-      sts.push(smt)
-    } else {
-      const q = `insert into ${table}(${cols.join(",")})values(${values.join(",")}) on duplicate key update ${colSet.join(",")};`
-      const smt: Statement = { query: q, params: args }
+  }
+}
+export function buildToSaveBatch<T>(
+  objs: T[],
+  table: string,
+  attrs: Attributes,
+  pks?: Attribute[],
+  ver?: string,
+  buildParam?: (i: number) => string,
+): Statement[] {
+  if (!buildParam) {
+    buildParam = param
+  }
+  const sts: Statement[] = []
+  if (!pks) {
+    pks = []
+    const ks = Object.keys(attrs)
+    for (const k of ks) {
+      const attr = attrs[k]
+      attr.name = k
+      if (attr.key) {
+        pks.push(attr)
+      }
+      if (attr.version) {
+        ver = k
+      }
+    }
+  }
+
+  for (const obj of objs) {
+    const smt = buildToSave(obj, table, attrs, pks, ver, buildParam)
+    if (smt.query) {
       sts.push(smt)
     }
   }

package/src/index.ts

@@ -1,6 +1,6 @@
 import { Connection, createPool as createPool2, FieldPacket, Pool, PoolConnection, ResultSetHeader } from "mysql2"
 import { Pool as PromisePool } from "mysql2/promise"
-import { buildToSave, buildToSaveBatch, param } from "./build"
+import { buildToSave, buildToSaveBatch, metadata, param } from "./build"
 import { Attribute, Attributes, DB, Statement, StringMap, Transaction } from "./metadata"
 
 export * from "./build"
@@ -40,32 +40,24 @@ export function getConnection(pool: Pool): Promise<PoolConnection> {
     })
   })
 }
-export function beginTransaction(connection: PoolConnection, rollbackIfError?: boolean): Promise<void> {
+export function beginTransaction(connection: PoolConnection): Promise<void> {
   return new Promise<void>((resolve, reject) => {
-    connection.beginTransaction((err) => {
-      if (err) {
-        if (!rollbackIfError) {
-          return reject(err)
-        }
-        return connection.rollback(() => {
-          return reject(err)
-        })
+    connection.beginTransaction((beginError) => {
+      if (beginError) {
+        connection.release()
+        return reject(beginError)
       }
       return resolve()
     })
   })
 }
-export function commit(connection: PoolConnection, rollbackIfError?: boolean): Promise<void> {
+export function commit(connection: PoolConnection): Promise<void> {
   return new Promise<void>((resolve, reject) => {
     connection.commit((err) => {
       if (err) {
-        if (!rollbackIfError) {
-          return reject(err)
-        }
-        return connection.rollback(() => {
-          return reject(err)
-        })
+        return reject(err)
       }
+      connection.release()
       return resolve()
     })
   })
@@ -73,6 +65,7 @@ export function commit(connection: PoolConnection, rollbackIfError?: boolean): P
 export function rollback(connection: PoolConnection): Promise<void> {
   return new Promise<void>((resolve, reject) => {
     connection.rollback((err) => {
+      connection.release()
       if (err) {
         return reject(err)
       }
@@ -103,10 +96,8 @@ export class PoolManager implements DB {
         }
         connection.beginTransaction((beginError) => {
           if (beginError) {
-            return connection.rollback(() => {
-              connection.release()
-              return reject(beginError)
-            })
+            connection.release()
+            return reject(beginError)
           }
           return resolve(new PoolConnectionManager(connection))
         })
@@ -116,8 +107,8 @@ export class PoolManager implements DB {
   execute(sql: string, args?: any[]): Promise<number> {
     return execute(this.pool, sql, args)
   }
-  executeBatch(statements: Statement[], firstAffected?: boolean): Promise<number> {
-    return executeBatch(this.pool, statements, firstAffected)
+  executeBatch(statements: Statement[], requireFirstAffected?: boolean): Promise<number> {
+    return executeBatch(this.pool, statements, requireFirstAffected)
   }
   query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[]): Promise<T[]> {
     return query(this.pool, sql, args, m, bools)
@@ -143,6 +134,7 @@ export class PoolConnectionManager implements Transaction {
     this.queryOne = this.queryOne.bind(this)
     this.executeScalar = this.executeScalar.bind(this)
     this.count = this.count.bind(this)
+    this.release = this.release.bind(this)
   }
   driver = "mysql"
   param(i: number): string {
@@ -152,10 +144,7 @@ export class PoolConnectionManager implements Transaction {
     return new Promise<void>((resolve, reject) => {
       this.connection.commit((err) => {
         if (err) {
-          return this.connection.rollback(() => {
-            this.release()
-            return reject(err)
-          })
+          return reject(err)
         }
         this.release()
         return resolve()
@@ -183,10 +172,10 @@ export class PoolConnectionManager implements Transaction {
   execute(sql: string, args?: any[]): Promise<number> {
     return execute(this.connection, sql, args)
   }
-  executeBatch(statements: Statement[], firstAffected?: boolean): Promise<number> {
-    return executeBatchConnection(this.connection, statements, firstAffected)
+  executeBatch(statements: Statement[], requireFirstAffected?: boolean): Promise<number> {
+    return executeBatchConnection(this.connection, statements, requireFirstAffected)
   }
-  query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any): Promise<T[]> {
+  query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[]): Promise<T[]> {
     return query(this.connection, sql, args, m, bools)
   }
   queryOne<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[]): Promise<T | null> {
@@ -199,7 +188,7 @@ export class PoolConnectionManager implements Transaction {
     return count(this.connection, sql, args)
   }
 }
-export async function executeBatch(pool: Pool, statements: Statement[], firstAffected?: boolean): Promise<number> {
+export async function executeBatch(pool: Pool, statements: Statement[], requireFirstAffected?: boolean): Promise<number> {
   if (!statements || statements.length === 0) {
     return 0
   }
@@ -207,31 +196,29 @@ export async function executeBatch(pool: Pool, statements: Statement[], firstAff
     return execute(pool, statements[0].query, statements[0].params)
   }
   const connection = await getConnection(pool)
-  try {
-    return await executeBatchConnectionTx(connection, statements, firstAffected)
-  } finally {
-    connection.release()
-  }
+  return await executeBatchConnectionTx(connection, statements, requireFirstAffected)
 }
-export async function executeBatchConnectionTx(connection: PoolConnection, statements: Statement[], firstAffected?: boolean): Promise<number> {
+export async function executeBatchConnectionTx(connection: PoolConnection, statements: Statement[], requireFirstAffected?: boolean): Promise<number> {
   if (!statements || statements.length === 0) {
     return 0
   }
   if (statements.length === 1) {
-    return execute(connection, statements[0].query, statements[0].params)
+    const count = await execute(connection, statements[0].query, statements[0].params)
+    connection.release()
+    return count
   }
-  await beginTransaction(connection, true)
+  await beginTransaction(connection)
   try {
     let count = 0
 
     if (resource.multipleStatements) {
-      if (firstAffected) {
+      if (requireFirstAffected) {
         const firstCount = await execute(connection, statements[0].query, statements[0].params)
 
         count = firstCount
 
         if (firstCount === 0) {
-          await commit(connection, true)
+          await commit(connection)
           return 0
         }
         const remaining = statements.slice(1)
@@ -240,12 +227,12 @@ export async function executeBatchConnectionTx(connection: PoolConnection, state
         count = await executeMultipleStatements(connection, statements)
       }
     } else {
-      const start = firstAffected ? 1 : 0
-      if (firstAffected) {
+      const start = requireFirstAffected ? 1 : 0
+      if (requireFirstAffected) {
         const firstCount = await execute(connection, statements[0].query, statements[0].params)
         count = firstCount
         if (firstCount === 0) {
-          await commit(connection, true)
+          await commit(connection)
           return 0
         }
       }
@@ -255,7 +242,7 @@ export async function executeBatchConnectionTx(connection: PoolConnection, state
       }
     }
 
-    await commit(connection, true)
+    await commit(connection)
 
     return count
   } catch (err) {
@@ -264,11 +251,12 @@ export async function executeBatchConnectionTx(connection: PoolConnection, state
     } catch {
       // Preserve the original error.
     }
-    throw buildError(err)
+    buildError(err)
+    throw err
   }
 }
 
-export async function executeBatchConnection(connection: PoolConnection, statements: Statement[], firstAffected?: boolean): Promise<number> {
+export async function executeBatchConnection(connection: PoolConnection, statements: Statement[], requireFirstAffected?: boolean): Promise<number> {
   if (!statements || statements.length === 0) {
     return 0
   }
@@ -278,7 +266,7 @@ export async function executeBatchConnection(connection: PoolConnection, stateme
   }
 
   if (resource.multipleStatements) {
-    if (firstAffected) {
+    if (requireFirstAffected) {
       const firstCount = await execute(connection, statements[0].query, statements[0].params)
 
       if (firstCount === 0) {
@@ -292,9 +280,9 @@ export async function executeBatchConnection(connection: PoolConnection, stateme
   }
 
   let count = 0
-  const start = firstAffected ? 1 : 0
+  const start = requireFirstAffected ? 1 : 0
 
-  if (firstAffected) {
+  if (requireFirstAffected) {
     const firstCount = await execute(connection, statements[0].query, statements[0].params)
 
     count = firstCount
@@ -424,25 +412,6 @@ export function count(pool: Pool | PoolConnection, sql: string, args?: any[]): P
   return executeScalar<number>(pool, sql, args).then((res) => (res !== null ? res : 0))
 }
 
-export function save<T>(pool: Pool | PoolConnection | ((sql: string, args?: any[]) => Promise<number>), obj: T, table: string, attrs: Attributes, buildParam?: (i: number) => string): Promise<number> {
-  const s = buildToSave(obj, table, attrs, buildParam)
-  if (!s.query) {
-    return Promise.resolve(-1)
-  }
-  if (typeof pool === "function") {
-    return pool(s.query, s.params)
-  } else {
-    return execute(pool, s.query, s.params)
-  }
-}
-export function saveBatch<T>(pool: Pool | ((statements: Statement[]) => Promise<number>), objs: T[], table: string, attrs: Attributes, buildParam?: (i: number) => string): Promise<number> {
-  const s = buildToSaveBatch(objs, table, attrs, buildParam)
-  if (typeof pool === "function") {
-    return pool(s)
-  } else {
-    return executeBatch(pool, s)
-  }
-}
 export function toArray(arr?: any[]): any[] {
   if (!arr || arr.length === 0) {
     return []
@@ -633,9 +602,13 @@ export class StringAdapter {
     return execute(this.pool, s, values)
   }
 }
+export const StringRepository = StringAdapter
+export const StringService = StringAdapter
 
 // tslint:disable-next-line:max-classes-per-file
 export class MySQLWriter<T> {
+  protected keys: Attribute[]
+  protected version?: string
   protected param?: (i: number) => string
   constructor(
     protected pool: Pool | PoolConnection,
@@ -647,6 +620,9 @@ export class MySQLWriter<T> {
   ) {
     this.write = this.write.bind(this)
     this.param = buildParam ? buildParam : param
+    const m = metadata(attributes)
+    this.keys = m.keys
+    this.version = m.version
   }
   write(obj: T): Promise<number> {
     if (!obj) {
@@ -656,7 +632,7 @@ export class MySQLWriter<T> {
     if (this.map) {
       obj2 = this.map(obj)
     }
-    const stmt = buildToSave(obj2, this.table, this.attributes, this.param)
+    const stmt = buildToSave(obj2, this.table, this.attributes, this.keys, this.version, this.param)
     if (stmt.query) {
       if (this.oneIfSuccess) {
         return execute(this.pool, stmt.query, stmt.params).then((ct) => (ct > 0 ? 1 : 0))
@@ -669,8 +645,10 @@ export class MySQLWriter<T> {
   }
 }
 // tslint:disable-next-line:max-classes-per-file
-export class MySQLStreamWriter<T> {
+export class BufferedBatchWriter<T> {
   protected list: T[] = []
+  protected keys: Attribute[]
+  protected version?: string
   protected param?: (i: number) => string
   constructor(
     protected pool: Pool,
@@ -683,6 +661,9 @@ export class MySQLStreamWriter<T> {
     this.write = this.write.bind(this)
     this.flush = this.flush.bind(this)
     this.param = buildParam ? buildParam : param
+    const m = metadata(attributes)
+    this.keys = m.keys
+    this.version = m.version
   }
   write(obj: T): Promise<number> {
     if (!obj) {
@@ -705,11 +686,11 @@ export class MySQLStreamWriter<T> {
     if (!this.list || this.list.length === 0) {
       return Promise.resolve(0)
     } else {
-      const stmt = buildToSaveBatch(this.list, this.table, this.attributes, this.param)
+      const stmt = buildToSaveBatch(this.list, this.table, this.attributes, this.keys, this.version, this.param)
       if (stmt.length > 0) {
         return executeBatch(this.pool as any, stmt).then((r) => {
           this.list = []
-          return stmt.length
+          return r
         })
       } else {
         this.list = []
@@ -719,18 +700,22 @@ export class MySQLStreamWriter<T> {
   }
 }
 // tslint:disable-next-line:max-classes-per-file
-export class MySQLBatchWriter<T> {
+export class BatchWriter<T> {
+  protected keys: Attribute[]
+  protected version?: string
   protected param?: (i: number) => string
   constructor(
     protected pool: Pool,
     protected table: string,
     protected attributes: Attributes,
-    protected oneIfSuccess?: boolean,
     protected map?: (v: T) => T,
     buildParam?: (i: number) => string,
   ) {
     this.write = this.write.bind(this)
     this.param = buildParam ? buildParam : param
+    const m = metadata(attributes)
+    this.keys = m.keys
+    this.version = m.version
   }
   write(objs: T[]): Promise<number> {
     if (!objs || objs.length === 0) {
@@ -744,13 +729,9 @@ export class MySQLBatchWriter<T> {
         list.push(obj2)
       }
     }
-    const stmts = buildToSaveBatch(list, this.table, this.attributes, this.param)
+    const stmts = buildToSaveBatch(list, this.table, this.attributes, this.keys, this.version, this.param)
     if (stmts.length > 0) {
-      if (this.oneIfSuccess) {
-        return executeBatch(this.pool, stmts).then((ct) => stmts.length)
-      } else {
-        return executeBatch(this.pool, stmts)
-      }
+      return executeBatch(this.pool, stmts)
     } else {
       return Promise.resolve(0)
     }

package/src/metadata.ts

@@ -10,7 +10,7 @@ export interface Executor {
   driver: string
   param(i: number): string
   execute(sql: string, args?: any[]): Promise<number>
-  executeBatch(statements: Statement[], firstAffected?: boolean): Promise<number>
+  executeBatch(statements: Statement[], requireFirstAffected?: boolean): Promise<number>
   query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[]): Promise<T[]>
   queryOne<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[]): Promise<T | null>
   executeScalar<T>(sql: string, args?: any[]): Promise<T | null>