@asla/yoursql 0.8.10 → 0.9.1

package/dist/client/DbPoolConnection.d.ts

@@ -1,7 +1,7 @@
 import type { SqlStatementDataset } from "../sql_gen/mod.ts";
 import { DbQuery } from "./DbQuery.ts";
 import type { MultipleQueryResult, QueryRowsResult, DbQueryBase } from "./DbQueryBase.ts";
-import type { StringLike, TransactionMode } from "./interfaces.ts";
+import type { SqlLike, TransactionMode } from "./interfaces.ts";
 /**
 
 /**
@@ -13,8 +13,8 @@ export declare class DbPoolConnection extends DbQuery {
     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: StringLike): Promise<QueryRowsResult<T>>;
-    multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: StringLike): Promise<T>;
+    query<T = any>(sql: SqlLike): Promise<QueryRowsResult<T>>;
+    multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: SqlLike | SqlLike[]): Promise<T>;
     rollback(): Promise<void>;
     commit(): Promise<void>;
     get released(): boolean;

package/dist/client/DbPoolTransaction.d.ts

@@ -2,7 +2,7 @@ import type { SqlStatementDataset } from "../sql_gen/mod.ts";
 import { DbQuery } from "./DbQuery.ts";
 import type { MultipleQueryResult, QueryRowsResult } from "./DbQueryBase.ts";
 import type { DbPoolConnection } from "./DbPoolConnection.ts";
-import type { DbTransaction, StringLike, TransactionMode } from "./interfaces.ts";
+import type { DbTransaction, SqlLike, TransactionMode } from "./interfaces.ts";
 /** @public */
 export type DbPoolTransactionOption = {
     errorRollback?: boolean;
@@ -21,9 +21,9 @@ export declare class DbPoolTransaction extends DbQuery implements DbTransaction
     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: StringLike): Promise<QueryRowsResult<T>>;
+    query<T extends object = any>(sql: SqlLike): Promise<QueryRowsResult<T>>;
     multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: SqlStatementDataset<T>): Promise<T>;
-    multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: StringLike): Promise<T>;
+    multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: SqlLike | SqlLike[]): Promise<T>;
     get released(): boolean;
     [Symbol.asyncDispose](): Promise<void>;
 }

package/dist/client/DbPoolTransaction.js

@@ -18,19 +18,20 @@ class DbPoolTransaction extends DbQuery {
                 this.#errorRollback = option.errorRollback;
             }
         }
-        this.#query = (sql) => {
+        this.#query = ((sql, multiple) => {
             return new Promise((resolve, reject) => {
                 this.#pending = connect()
                     .then((conn) => {
                     this.#conn = conn;
-                    const promise = conn.multipleQuery("BEGIN" + (this.mode ? " TRANSACTION ISOLATION LEVEL " + this.mode : "") + ";\n" + sql);
+                    const begin = "BEGIN" + (this.mode ? " TRANSACTION ISOLATION LEVEL " + this.mode : "");
+                    const promise = conn.multipleQuery([begin, sql]);
                     this.#pending = promise;
                     this.#query = this.#queryAfter;
                     return promise;
                 })
                     .then((res) => {
                     this.#pending = undefined;
-                    resolve(res[1]);
+                    resolve(multiple ? res.slice(1) : res[1]);
                 }, (e) => {
                     // 语法错误、查询错误、网络错误
                     this.#pending = undefined;
@@ -50,7 +51,7 @@ class DbPoolTransaction extends DbQuery {
                         onFinally();
                 });
             });
-        };
+        });
     }
     #pending;
     #conn;
@@ -78,13 +79,14 @@ class DbPoolTransaction extends DbQuery {
     rollbackTo(savePoint) {
         return this.query("ROLLBACK TO " + savePoint).then(() => { });
     }
-    /** 拿到连接后执行这个 */
-    #queryAfter(sql) {
+    #queryAfter(sql, multiple) {
         const conn = this.#conn;
-        return conn.query(sql).then((res) => {
+        const onFinish = (res) => {
+            this.#query = this.#queryAfter;
             this.#pending = undefined;
             return res;
-        }, (e) => {
+        };
+        const onError = (e) => {
             this.#pending = undefined;
             if (this.#errorRollback) {
                 const onOk = () => {
@@ -97,7 +99,11 @@ class DbPoolTransaction extends DbQuery {
                 this.#release(conn, e);
                 throw e;
             }
-        });
+        };
+        if (multiple)
+            return conn.multipleQuery(sql).then(onFinish, onError);
+        else
+            return conn.query(sql).then(onFinish, onError);
     }
     #query;
     query(sql) {
@@ -108,7 +114,7 @@ class DbPoolTransaction extends DbQuery {
     multipleQuery(sql) {
         if (this.#pending)
             return Promise.reject(new ParallelQueryError());
-        return this.#query(sql);
+        return this.#query(sql, true);
     }
     #error;
     #release(conn, error = new ConnectionNotAvailableError("Connection already release")) {

package/dist/client/DbQuery.d.ts

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

package/dist/client/DbQuery.js

@@ -5,27 +5,27 @@
 class DbQuery {
     /** 单语句查询受影响的行 */
     queryCount(sql) {
-        return this.query(sql.toString()).then((res) => {
+        return this.query(sql).then((res) => {
             if (res.rowCount === null)
                 return 0;
             return res.rowCount;
         });
     }
     queryRows(sql) {
-        return this.query(sql.toString()).then((res) => res.rows);
+        return this.query(sql).then((res) => res.rows);
     }
     queryFirstRow(sql) {
-        return this.query(sql.toString()).then(({ rows, rowCount }) => {
+        return this.query(sql).then(({ rows, rowCount }) => {
             if (rows.length === 0)
                 throw new Error("Query did not return any rows");
             return rows[0];
         });
     }
     multipleQueryRows(sql) {
-        return this.multipleQuery(sql.toString()).then((res) => res.map((item) => item.rows ?? []));
+        return this.multipleQuery(sql).then((res) => res.map((item) => item.rows ?? []));
     }
     async queryMap(sql, key) {
-        const { rows } = await this.query(sql.toString());
+        const { rows } = await this.query(sql);
         let map = new Map();
         for (let i = 0; i < rows.length; i++) {
             map.set(rows[i][key], rows[i]);

package/dist/client/DbQueryBase.d.ts

@@ -1,5 +1,5 @@
 import type { SqlStatementDataset } from "../sql_gen/mod.ts";
-import { StringLike } from "./interfaces.ts";
+import { SqlLike } from "./interfaces.ts";
 /** @public */
 export interface SingleQueryResult {
     rowCount: number;
@@ -19,8 +19,10 @@ export interface DbQueryBase {
     /** 单语句查询，不应查询多语句，否则返回错误值  */
     query<T = any>(sql: SqlStatementDataset<T>): Promise<QueryRowsResult<T>>;
     /** 单语句查询，不应查询多语句，否则返回错误值  */
-    query<T = any>(sql: StringLike): Promise<QueryRowsResult<T>>;
+    query<T = any>(sql: SqlLike): Promise<QueryRowsResult<T>>;
     /** 多语句查询 */
-    multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: StringLike): Promise<T>;
+    multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: SqlLike | SqlLike[]): Promise<T>;
 }
+/** @public */
+export declare function sqlLikeToString(sqlLike: SqlLike): string;
 //# sourceMappingURL=DbQueryBase.d.ts.map

package/dist/client/DbQueryBase.js

@@ -0,0 +1,11 @@
+/** @public */
+function sqlLikeToString(sqlLike) {
+    if (typeof sqlLike === "string") {
+        return sqlLike;
+    }
+    else {
+        return sqlLike.genSql();
+    }
+}
+
+export { sqlLikeToString };

package/dist/client/interfaces.d.ts

@@ -59,10 +59,10 @@ export interface DbQueryPool extends DbQuery {
     totalCount: number;
     begin(mode?: TransactionMode): DbTransaction;
     cursor<T extends {}>(sql: SqlStatementDataset<T>): Promise<DbCursor<T>>;
-    cursor<T>(sql: StringLike, option?: DbCursorOption): Promise<DbCursor<T>>;
+    cursor<T>(sql: SqlLike, option?: DbCursorOption): Promise<DbCursor<T>>;
 }
 /** @public */
-export type StringLike = {
-    toString(): string;
+export type SqlLike = {
+    genSql(): string;
 } | string;
 //# sourceMappingURL=interfaces.d.ts.map

package/dist/client/mod.js

@@ -1,4 +1,5 @@
 export { ConnectionNotAvailableError, ParallelQueryError } from './errors.js';
+export { sqlLikeToString } from './DbQueryBase.js';
 export { DbQuery } from './DbQuery.js';
 export { DbCursor } from './DbCursor.js';
 export { DbPoolConnection } from './DbPoolConnection.js';

package/dist/sql_gen/select/chain_base.d.ts

@@ -1,7 +1,9 @@
 /** @public */
 export declare abstract class SqlStatement {
     /** 获取 SQL 语句 */
-    abstract toString(): string;
+    toString(): string;
+    /** 获取 SQL 语句 */
+    abstract genSql(): string;
 }
 /**
  * 可选择项。可以是 table、查询结果等，它能被 select 语句选择
@@ -34,7 +36,7 @@ export declare abstract class SqlStatementDataset<T> extends SqlStatement implem
 export declare class SqlTextStatementDataset<T> extends SqlStatementDataset<T> {
     readonly sql: string;
     constructor(sql: string);
-    toString(): string;
+    genSql(): string;
 }
 /**
  * 推断查询结果的类型

package/dist/sql_gen/select/chain_base.js

@@ -1,5 +1,9 @@
 /** @public */
 class SqlStatement {
+    /** 获取 SQL 语句 */
+    toString() {
+        return this.genSql();
+    }
 }
 /** @public */
 class SqlStatementDataset extends SqlStatement {
@@ -9,7 +13,7 @@ class SqlStatementDataset extends SqlStatement {
      * 如果是 选择语句，则是 (xxx)
      */
     toSelect() {
-        return "(" + this.toString() + ")";
+        return "(" + this.genSql() + ")";
     }
 }
 /** @public */
@@ -19,7 +23,7 @@ class SqlTextStatementDataset extends SqlStatementDataset {
         super();
         this.sql = sql;
     }
-    toString() {
+    genSql() {
         return this.sql;
     }
 }

package/dist/sql_gen/select/query_chain_insert.d.ts

@@ -8,7 +8,7 @@ export declare class SqlChainModify<T extends TableType = {}> extends SqlStateme
     returning<R extends {}>(returns: Constructable<SelectParam | "*">): SqlStatementDataset<R>;
     onConflict(onConflict: Constructable<readonly string[] | string>): ChainAfterConflictDo<T>;
     where(where: Constructable<ConditionParam | void>): ChainModifyReturning<T>;
-    toString(): string;
+    genSql(): string;
 }
 export declare class SqlInsertConflictBranch<T extends TableType = {}> implements ChainAfterConflictDo<T> {
     readonly sql: string;

package/dist/sql_gen/select/query_chain_insert.js

@@ -18,7 +18,7 @@ class SqlChainModify extends SqlStatement {
         else {
             columnsStr = selectColumns(returns);
         }
-        let sql = this.toString() + "\nRETURNING " + columnsStr;
+        let sql = this.genSql() + "\nRETURNING " + columnsStr;
         return new SqlTextStatementDataset(sql);
     }
     onConflict(onConflict) {
@@ -26,14 +26,14 @@ class SqlChainModify extends SqlStatement {
             onConflict = onConflict();
         if (typeof onConflict !== "string")
             onConflict = onConflict.join(",");
-        let sql = this.toString() + `\nON CONFLICT (${onConflict})`;
+        let sql = this.genSql() + `\nON CONFLICT (${onConflict})`;
         return new SqlInsertConflictBranch(sql);
     }
     where(where$1) {
         const sql = where(where$1);
-        return new SqlChainModify(this.toString() + sql);
+        return new SqlChainModify(this.genSql() + sql);
     }
-    toString() {
+    genSql() {
         return this.sql;
     }
 }

package/dist/sql_gen/select/query_chain_select.js

@@ -8,10 +8,10 @@ var _a;
  */
 class SqlSelectChain extends SqlTextStatementDataset {
     where(param) {
-        return new SqlSelectChain(this.toString() + where(param));
+        return new SqlSelectChain(this.genSql() + where(param));
     }
     groupBy(columns) {
-        let sql = this.toString();
+        let sql = this.genSql();
         if (typeof columns === "string")
             sql += " GROUP BY " + columns;
         else
@@ -19,13 +19,13 @@ class SqlSelectChain extends SqlTextStatementDataset {
         return new SqlSelectChain(sql);
     }
     having(param) {
-        return new SqlSelectChain(this.toString() + having(param));
+        return new SqlSelectChain(this.genSql() + having(param));
     }
     orderBy(param) {
-        return new SqlSelectChain(this.toString() + orderBy(param));
+        return new SqlSelectChain(this.genSql() + orderBy(param));
     }
     limit(limit, offset) {
-        let sql = this.toString();
+        let sql = this.genSql();
         let type;
         if (limit) {
             type = typeof limit;

package/dist/sql_gen/sql_value/sql_value.js

@@ -276,7 +276,7 @@ class YourValuesAs extends SqlStatementDataset {
     toSelect() {
         return this.#sql;
     }
-    toString() {
+    genSql() {
         return this.#sql;
     }
 }

package/package.json

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