@asla/yoursql 0.11.2 → 0.11.3

package/dist/client/DbPoolConnection.d.ts

@@ -1,6 +1,5 @@
-import { SqlStatementDataset } from "./_type.ts";
-import { DbQuery } from "./DbQuery.ts";
-import { type MultipleQueryResult, type QueryRowsResult, type DbQueryBase } from "./DbQueryBase.ts";
+import { DbQuery, MultipleQueryInput, QueryDataInput, QueryInput } from "./DbQuery.ts";
+import { type QueryRowsResult, type DbQueryBase, MultipleQueryResult } from "./DbQueryBase.ts";
 import type { SqlLike, TransactionMode } from "./interfaces.ts";
 /**
 
@@ -12,8 +11,11 @@ export declare class DbPoolConnection extends DbQuery {
     #private;
     constructor(conn: DbQueryBase, onRelease: (conn: DbQueryBase) => void);
     begin(mode?: TransactionMode): Promise<void>;
-    query<T = any>(sql: SqlStatementDataset<T>): Promise<QueryRowsResult<T>>;
-    query<T = any>(sql: SqlLike): Promise<QueryRowsResult<T>>;
+    query<T extends MultipleQueryResult = MultipleQueryResult>(sql: MultipleQueryInput): Promise<T>;
+    query<T = any>(sql: QueryDataInput<T>): Promise<QueryRowsResult<T>>;
+    query<T = any>(sql: QueryInput): Promise<QueryRowsResult<T>>;
+    execute(sql: QueryInput | MultipleQueryInput): Promise<void>;
+    /** @deprecated 不建议使用 */
     multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: SqlLike | SqlLike[]): Promise<T>;
     rollback(): Promise<void>;
     commit(): Promise<void>;

package/dist/client/DbPoolConnection.js

@@ -22,8 +22,18 @@ class DbPoolConnection extends DbQuery {
     query(sql) {
         if (!this.#conn)
             return Promise.reject(new ConnectionNotAvailableError("Connection already release"));
+        if (typeof sql === "function")
+            sql = sql();
         return this.#conn.query(sql);
     }
+    execute(sql) {
+        if (!this.#conn)
+            return Promise.reject(new ConnectionNotAvailableError("Connection already release"));
+        if (typeof sql === "function")
+            sql = sql();
+        return this.#conn.execute(sql);
+    }
+    /** @deprecated 不建议使用 */
     multipleQuery(sql) {
         if (!this.#conn)
             return Promise.reject(new ConnectionNotAvailableError("Connection already release"));

package/dist/client/DbPoolTransaction.d.ts

@@ -1,8 +1,7 @@
-import { DbQuery } from "./DbQuery.ts";
+import { DbQuery, MultipleQueryInput, QueryDataInput, QueryInput } from "./DbQuery.ts";
 import type { MultipleQueryResult, QueryRowsResult } from "./DbQueryBase.ts";
 import type { DbPoolConnection } from "./DbPoolConnection.ts";
 import type { DbTransaction, SqlLike, TransactionMode } from "./interfaces.ts";
-import { SqlStatementDataset } from "./_type.ts";
 /** @public */
 export type DbPoolTransactionOption = {
     errorRollback?: boolean;
@@ -20,9 +19,11 @@ export declare class DbPoolTransaction extends DbQuery implements DbTransaction
     rollback(): Promise<void>;
     savePoint(savePoint: string): Promise<void>;
     rollbackTo(savePoint: string): Promise<void>;
-    query<T extends object = any>(sql: SqlStatementDataset<T>): Promise<QueryRowsResult<T>>;
-    query<T extends object = any>(sql: SqlLike): Promise<QueryRowsResult<T>>;
-    multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: SqlStatementDataset<T>): Promise<T>;
+    query<T extends MultipleQueryResult = MultipleQueryResult>(sql: MultipleQueryInput): Promise<T>;
+    query<T extends object = any>(sql: QueryDataInput<T>): Promise<QueryRowsResult<T>>;
+    query<T extends object = any>(sql: QueryInput): Promise<QueryRowsResult<T>>;
+    execute(sql: QueryInput | MultipleQueryInput): Promise<void>;
+    /** @deprecated 不建议使用 */
     multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: SqlLike | SqlLike[]): Promise<T>;
     get released(): boolean;
     [Symbol.asyncDispose](): Promise<void>;

package/dist/client/DbPoolTransaction.js

@@ -8,6 +8,7 @@ import { ParallelQueryError, ConnectionNotAvailableError } from './errors.js';
 class DbPoolTransaction extends DbQuery {
     #errorRollback;
     mode;
+    #begin;
     constructor(connect, option) {
         super();
         if (option) {
@@ -18,110 +19,127 @@ class DbPoolTransaction extends DbQuery {
                 this.#errorRollback = option.errorRollback;
             }
         }
-        this.#query = ((sql, multiple) => {
-            return new Promise((resolve, reject) => {
-                this.#pending = connect()
-                    .then((conn) => {
-                    this.#conn = conn;
-                    const begin = "BEGIN" + (this.mode ? " TRANSACTION ISOLATION LEVEL " + this.mode : "");
-                    const promise = conn.multipleQuery(sql instanceof Array ? [begin, ...sql] : [begin, sql]);
-                    this.#pending = promise;
-                    this.#query = this.#queryAfter;
-                    return promise;
-                })
-                    .then((res) => {
-                    this.#pending = undefined;
-                    resolve(multiple ? res.slice(1) : res[1]);
-                }, (e) => {
-                    // 语法错误、查询错误、网络错误
-                    this.#pending = undefined;
-                    const conn = this.#conn;
-                    if (!conn) {
-                        reject(e);
-                        return;
-                    }
-                    const onFinally = () => {
-                        this.#release(conn, e);
-                        reject(e);
-                    };
-                    if (this.#errorRollback) {
-                        return conn.rollback().then(onFinally, onFinally);
-                    }
-                    else
-                        onFinally();
-                });
-            });
-        });
+        this.#begin = "BEGIN" + (this.mode ? " TRANSACTION ISOLATION LEVEL " + this.mode : "");
+        this.#connect = connect;
     }
-    #pending;
+    #connect;
     #conn;
     async commit() {
-        if (this.#pending)
-            throw new ParallelQueryError();
         if (this.#conn) {
-            const promise = this.#conn.query("COMMIT");
+            const promise = this.#conn.execute("COMMIT");
             this.#release(this.#conn);
-            await promise;
+            return promise;
+        }
+        else {
+            this.#release(undefined);
         }
     }
     async rollback() {
-        if (this.#pending)
-            throw new ParallelQueryError();
         if (this.#conn) {
-            const promise = this.#conn.query("ROLLBACK");
+            const promise = this.#conn.execute("ROLLBACK");
             this.#release(this.#conn);
-            await promise;
+            return promise;
+        }
+        else {
+            this.#release(undefined);
         }
     }
     savePoint(savePoint) {
-        return this.query("SAVEPOINT" + savePoint).then(() => { });
+        return this.execute("SAVEPOINT " + savePoint);
     }
     rollbackTo(savePoint) {
-        return this.query("ROLLBACK TO " + savePoint).then(() => { });
+        return this.execute("ROLLBACK TO " + savePoint);
     }
-    #queryAfter(sql, multiple) {
-        const conn = this.#conn;
-        const onFinish = (res) => {
-            this.#query = this.#queryAfter;
-            this.#pending = undefined;
-            return res;
-        };
-        const onError = (e) => {
+    #pending;
+    #getConnQuery(call, callIfFirst = call, queryError) {
+        if (this.#pending) {
+            return Promise.reject(new ParallelQueryError());
+        }
+        if (this.#error) {
+            return Promise.reject(this.#error);
+        }
+        let promise;
+        if (!this.#conn) {
+            promise = this.#connect().then((conn) => {
+                if (this.released) {
+                    conn.release();
+                    throw this.#error;
+                }
+                this.#conn = conn;
+                let promise = callIfFirst(conn);
+                if (queryError) {
+                    promise = promise.catch((e) => {
+                        queryError();
+                        throw e;
+                    });
+                }
+                return promise;
+            }, (e) => {
+                this.#release(undefined);
+                throw e;
+            });
+        }
+        else {
+            promise = call(this.#conn);
+            if (queryError) {
+                promise = promise.catch((e) => {
+                    queryError();
+                    throw e;
+                });
+            }
+        }
+        this.#pending = promise;
+        return promise.finally(() => {
             this.#pending = undefined;
+        });
+    }
+    #query(call, callIfFirst) {
+        const onError = () => {
             if (this.#errorRollback) {
-                const onOk = () => {
-                    this.#release(conn, e);
-                    throw e;
-                };
-                return conn.rollback().then(onOk, onOk);
+                this.rollback();
             }
             else {
-                this.#release(conn, e);
-                throw e;
+                this.#release(this.#conn);
             }
         };
-        if (multiple)
-            return conn.multipleQuery(sql).then(onFinish, onError);
-        else
-            return conn.query(sql).then(onFinish, onError);
+        return this.#getConnQuery(call, callIfFirst, onError);
     }
-    #query;
     query(sql) {
-        if (this.#pending)
-            return Promise.reject(new ParallelQueryError());
-        return this.#query(sql);
+        return this.#query((conn) => {
+            return conn.query(sql);
+        }, async (conn) => {
+            if (typeof sql === "function")
+                sql = sql();
+            const isArray = sql instanceof Array;
+            const result = await conn.query(isArray ? [this.#begin, ...sql] : [this.#begin, sql]);
+            if (isArray)
+                return result.slice(1);
+            else
+                return result[1];
+        });
     }
+    async execute(sql) {
+        return this.#query((conn) => {
+            return conn.execute(sql);
+        }, (conn) => {
+            if (typeof sql === "function")
+                sql = sql();
+            return conn.execute(sql instanceof Array ? [this.#begin, ...sql] : [this.#begin, sql]);
+        });
+    }
+    /** @deprecated 不建议使用 */
     multipleQuery(sql) {
-        if (this.#pending)
-            return Promise.reject(new ParallelQueryError());
-        return this.#query(sql, true);
+        return this.#query((conn) => {
+            return conn.multipleQuery(sql);
+        }, (conn) => {
+            return conn.multipleQuery(sql instanceof Array ? [this.#begin, ...sql] : [this.#begin, sql]);
+        });
     }
     #error;
     #release(conn, error = new ConnectionNotAvailableError("Connection already release")) {
         this.#error = error;
-        this.#query = () => Promise.reject(this.#error);
         this.#conn = undefined;
-        conn.release();
+        conn?.release();
     }
     get released() {
         return !!this.#error;

package/dist/client/DbQuery.d.ts

@@ -1,37 +1,47 @@
 import { SqlLike } from "./interfaces.ts";
 import { MultipleQueryResult, QueryRowsResult } from "./DbQueryBase.ts";
 import { SqlStatementDataset } from "./_type.ts";
+/** @public */
+export type QueryInput = SqlLike | (() => SqlLike);
+/** @public */
+export type QueryDataInput<T> = SqlStatementDataset<T> | (() => SqlStatementDataset<T>);
+/** @public */
+export type MultipleQueryInput = SqlLike[] | (() => SqlLike[]);
 /**
  * SQL 查询相关操作
  * @public
  */
 export declare abstract class DbQuery {
-    abstract query<T = any>(sql: SqlStatementDataset<T>): Promise<QueryRowsResult<T>>;
-    abstract query<T = any>(sql: SqlLike): Promise<QueryRowsResult<T>>;
+    abstract execute(sql: QueryInput | MultipleQueryInput): Promise<void>;
+    abstract query<T extends MultipleQueryResult = MultipleQueryResult>(sql: MultipleQueryInput): Promise<T>;
+    abstract query<T = any>(sql: QueryDataInput<T>): Promise<QueryRowsResult<T>>;
+    abstract query<T = any>(sql: QueryInput): Promise<QueryRowsResult<T>>;
+    /** @deprecated 不建议使用。改用 query() */
     abstract multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: SqlLike | SqlLike[]): Promise<T>;
     /** 单语句查询受影响的行 */
-    queryCount(sql: SqlLike): Promise<number>;
+    queryCount(sql: QueryInput): Promise<number>;
     /** 单语句查询，不应查询多语句，否则返回错误值  */
-    queryRows<T = any>(sql: SqlStatementDataset<T>): Promise<T[]>;
+    queryRows<T = any>(sql: QueryDataInput<T>): Promise<T[]>;
     /** 单语句查询，不应查询多语句，否则返回错误值  */
-    queryRows<T = any>(sql: SqlLike): Promise<T[]>;
+    queryRows<T = any>(sql: QueryInput): Promise<T[]>;
     /** 单语句查询，只返回第一行。如果查询没有返回行，则抛出异常。 */
-    queryFirstRow<T = any>(sql: SqlStatementDataset<T>): Promise<T>;
-    queryFirstRow<T = any>(sql: SqlLike): Promise<T>;
+    queryFirstRow<T = any>(sql: QueryDataInput<T>): Promise<T>;
+    queryFirstRow<T = any>(sql: QueryInput): Promise<T>;
     /**
      * 查询行
      * 不应查询单语句，否则返回错误值
+     *  @deprecated 不建议使用。
      */
     multipleQueryRows<T extends any[] = any[]>(sql: SqlLike | SqlLike[]): Promise<T[]>;
     /**
      * 指定某一列为key，返回 key 到 row 的映射
      * 单语句查询，不应查询多语句，否则返回错误值
      */
-    queryMap<T extends Record<string, any> = Record<string, any>, K extends keyof T = string>(sql: SqlStatementDataset<T>, key: K): Promise<Map<T[K], T>>;
+    queryMap<T extends Record<string, any> = Record<string, any>, K extends keyof T = string>(sql: QueryDataInput<T>, key: K): Promise<Map<T[K], T>>;
     /**
      * 指定某一列为key，返回 key 到 row 的映射
      * 单语句查询，不应查询多语句，否则返回错误值
      */
-    queryMap<T extends Record<string, any> = Record<string, any>, K extends keyof T = string>(sql: SqlLike, key: K): Promise<Map<T[K], T>>;
+    queryMap<T extends Record<string, any> = Record<string, any>, K extends keyof T = string>(sql: QueryInput, key: K): Promise<Map<T[K], T>>;
 }
 //# sourceMappingURL=DbQuery.d.ts.map

package/dist/client/DbQuery.js

@@ -24,6 +24,7 @@ class DbQuery {
     /**
      * 查询行
      * 不应查询单语句，否则返回错误值
+     *  @deprecated 不建议使用。
      */
     multipleQueryRows(sql) {
         return this.multipleQuery(sql).then((res) => res.map((item) => item.rows ?? []));

package/dist/client/DbQueryBase.d.ts

@@ -12,20 +12,19 @@ export interface QueryRowsResult<T = any> extends SingleQueryResult {
 }
 /** @public */
 export type MultipleQueryResult = SingleQueryResult[];
-/**
- *
- * @deprecated 已废弃
- * @public
- */
-export type QueryResult = MultipleQueryResult | SingleQueryResult;
 /**
  * 数据库客户端的最小实现接口
  * @public
  */
 export interface DbQueryBase {
-    /** 单语句查询，不应查询多语句，否则返回错误值  */
+    /** 单语句查询， 忽略返回值 */
+    execute(sql: SqlLike | SqlLike[]): Promise<void>;
+    /** 单语句查询。单个 SqlLike 不应包含多语句，否则返回错误值  */
     query<T = any>(sql: SqlLike): Promise<QueryRowsResult<T>>;
     /** 多语句查询 */
+    query<T extends MultipleQueryResult = MultipleQueryResult>(sql: SqlLike[]): Promise<T>;
+    query(sql: SqlLike[] | SqlLike): Promise<unknown[] | unknown>;
+    /** 多语句查询 */
     multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: SqlLike | SqlLike[]): Promise<T>;
 }
 /**

package/dist/client/DbQueryPool.d.ts

@@ -0,0 +1,40 @@
+import { DbCursor, DbCursorOption } from "./DbCursor.ts";
+import { DbPoolConnection } from "./DbPoolConnection.ts";
+import { DbQuery } from "./DbQuery.ts";
+import { DbPool, DbTransaction, SqlLike, TransactionMode } from "./interfaces.ts";
+import { QueryRowsResult } from "./DbQueryBase.ts";
+import { SqlStatementDataset, InferQueryResult } from "./_type.ts";
+/** @public */
+export interface ExecutableSQL<T = unknown> {
+    genSql(): string;
+    then(resolve: (data: T) => void, reject: () => void): void;
+}
+/** @public */
+export interface QueryableDataSQL<Raw, Res = QueryRowsResult<Raw>> extends ExecutableSQL<Res> {
+    query(): Promise<QueryRowsResult<Raw>>;
+    queryCount(): Promise<number>;
+    queryRows(): Promise<Raw[]>;
+    queryFirstRow(): Promise<Raw>;
+    queryMap<K>(key: string): Promise<Map<K, Raw>>;
+    cursor(): Promise<DbCursor<Raw>>;
+}
+/**
+ * @public
+ * 池链接查询
+ */
+export declare abstract class DbQueryPool extends DbQuery implements DbPool {
+    abstract connect(): Promise<DbPoolConnection>;
+    /** 连接池空闲链接数量 */
+    abstract idleCount: number;
+    /** 连接池总链接数量 */
+    abstract totalCount: number;
+    abstract begin(mode?: TransactionMode): DbTransaction;
+    abstract cursor<T extends {}>(sql: SqlStatementDataset<T>): Promise<DbCursor<T>>;
+    abstract cursor<T>(sql: SqlLike, option?: DbCursorOption): Promise<DbCursor<T>>;
+    createQueryableSQL<Raw>(statement: SqlStatementDataset<Raw>): QueryableDataSQL<Raw, void>;
+    createQueryableSQL<Raw>(statement: SqlLike): QueryableDataSQL<Raw, void>;
+    createQueryableSQL<T extends SqlStatementDataset<any>, Res>(statement: T, transform: (queryable: DbQueryPool, statement: T) => Promise<Res>): QueryableDataSQL<InferQueryResult<T>, Awaited<Res>>;
+    createQueryableSQL<Raw, Res>(statement: SqlLike, transform: (queryable: DbQueryPool, statement: SqlLike) => Promise<Res>): QueryableDataSQL<Raw, Res>;
+    createExecutableSQL(statement: SqlLike): ExecutableSQL<void>;
+}
+//# sourceMappingURL=DbQueryPool.d.ts.map

package/dist/client/DbQueryPool.js

@@ -0,0 +1,56 @@
+import { DbQuery } from './DbQuery.js';
+
+/**
+ * @public
+ * 池链接查询
+ */
+class DbQueryPool extends DbQuery {
+    createQueryableSQL(statement, transform) {
+        return new QueryableSqlImpl(this, statement, transform);
+    }
+    createExecutableSQL(statement) {
+        return new QueryableSqlImpl(this, statement);
+    }
+}
+class QueryableSqlImpl {
+    queryClient;
+    statement;
+    transform;
+    constructor(queryClient, statement, transform = defaultTransform) {
+        this.queryClient = queryClient;
+        this.statement = statement;
+        this.transform = transform;
+    }
+    genSql() {
+        return this.statement.toString();
+    }
+    toString() {
+        return this.genSql();
+    }
+    query() {
+        return this.queryClient.query(this.statement);
+    }
+    queryCount() {
+        return this.queryClient.queryCount(this.statement);
+    }
+    queryRows() {
+        return this.queryClient.queryRows(this.statement);
+    }
+    queryFirstRow() {
+        return this.queryClient.queryFirstRow(this.statement);
+    }
+    queryMap(key) {
+        return this.queryClient.queryMap(this.statement, key);
+    }
+    cursor() {
+        return this.queryClient.cursor(this.statement);
+    }
+    then(resolve, reject) {
+        this.transform(this.queryClient, this.statement).then(resolve, reject);
+    }
+}
+function defaultTransform(queryClient, statement) {
+    return queryClient.execute(statement);
+}
+
+export { DbQueryPool };

package/dist/client/_type.d.ts

@@ -1,2 +1,2 @@
-export type { SqlStatementDataset, SqlTemplate, SqlTextTemplate } from "../sql_gen/mod.ts";
+export type { SqlStatementDataset, SqlTemplate, SqlTextTemplate, InferQueryResult } from "../sql_gen/mod.ts";
 //# sourceMappingURL=_type.d.ts.map

package/dist/client/interfaces.d.ts

@@ -50,10 +50,10 @@ export interface DbTransaction extends DbQuery, AsyncDisposable {
     commit(): Promise<void>;
 }
 /**
+ * 数据库连接池
  * @public
- * 池链接查询
  */
-export interface DbQueryPool extends DbQuery {
+export interface DbPool {
     connect(): Promise<DbPoolConnection>;
     idleCount: number;
     totalCount: number;

package/dist/client/mod.d.ts

@@ -5,4 +5,5 @@ export * from "./DbQuery.ts";
 export * from "./DbCursor.ts";
 export * from "./DbPoolConnection.ts";
 export * from "./DbPoolTransaction.ts";
+export * from "./DbQueryPool.ts";
 //# sourceMappingURL=mod.d.ts.map

package/dist/client/mod.js

@@ -4,3 +4,4 @@ export { DbQuery } from './DbQuery.js';
 export { DbCursor } from './DbCursor.js';
 export { DbPoolConnection } from './DbPoolConnection.js';
 export { DbPoolTransaction } from './DbPoolTransaction.js';
+export { DbQueryPool } from './DbQueryPool.js';

package/dist/sql_gen/SqlStatement.d.ts

@@ -31,6 +31,10 @@ export declare abstract class SqlStatementDataset<T> extends SqlStatement implem
      * 如果是 选择语句，则是 (xxx)
      */
     toSelect(asName?: string): string;
+    /**
+     * 仅用于类型推断，不应被调用
+     */
+    __infer(v: T): never;
 }
 /** @public */
 export declare class SqlTextStatementDataset<T> extends SqlStatementDataset<T> {

package/dist/sql_gen/SqlStatement.js

@@ -18,6 +18,12 @@ class SqlStatementDataset extends SqlStatement {
             result += " AS " + asName;
         return result;
     }
+    /**
+     * 仅用于类型推断，不应被调用
+     */
+    __infer(v) {
+        throw new Error("cannot call test on SqlStatementDataset");
+    }
 }
 /** @public */
 class SqlTextStatementDataset extends SqlStatementDataset {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asla/yoursql",
-  "version": "0.11.2",
+  "version": "0.11.3",
   "description": "",
   "type": "module",
   "types": "./dist/mod.d.ts",