@asla/yoursql 0.11.1 → 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, QueryRowsResult, 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,36 +1,47 @@
 import { SqlLike } from "./interfaces.ts";
-import { MultipleQueryResult, DbQueryBase, QueryRowsResult } from "./DbQueryBase.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 implements DbQueryBase {
-    abstract query<T = any>(sql: SqlLike): Promise<QueryRowsResult<T>>;
+export declare abstract class DbQuery {
+    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

@@ -1,4 +1,4 @@
-import { SqlStatementDataset } from "./_type.ts";
+import { SqlTemplate } from "./_type.ts";
 import { SqlLike } from "./interfaces.ts";
 /** @public */
 export interface SingleQueryResult {
@@ -12,17 +12,27 @@ export interface QueryRowsResult<T = any> extends SingleQueryResult {
 }
 /** @public */
 export type MultipleQueryResult = SingleQueryResult[];
-/** @public */
-export type QueryResult = MultipleQueryResult | SingleQueryResult;
-/** @public */
+/**
+ * 数据库客户端的最小实现接口
+ * @public
+ */
 export interface DbQueryBase {
-    /** 单语句查询，不应查询多语句，否则返回错误值  */
-    query<T = any>(sql: SqlStatementDataset<T>): Promise<QueryRowsResult<T>>;
-    /** 单语句查询，不应查询多语句，否则返回错误值  */
+    /** 单语句查询， 忽略返回值 */
+    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>;
 }
-/** @public */
+/**
+ * 将 SqlLike 转换为字符串
+ * @public
+ *
+ */
 export declare function sqlLikeToString(sqlLike: SqlLike): string;
+/** @public */
+export declare function isSqlTemplate(obj: any): obj is SqlTemplate;
 //# sourceMappingURL=DbQueryBase.d.ts.map

package/dist/client/DbQueryBase.js

@@ -1,11 +1,32 @@
-/** @public */
+/**
+ * 将 SqlLike 转换为字符串
+ * @public
+ *
+ */
 function sqlLikeToString(sqlLike) {
     if (typeof sqlLike === "string") {
         return sqlLike;
     }
     else {
-        return sqlLike.genSql();
+        if (isSqlTemplate(sqlLike)) {
+            const { templates } = sqlLike;
+            const textArgs = sqlLike.toTextArgs();
+            let sql = templates[0];
+            for (let i = 1; i < templates.length; i++) {
+                sql += textArgs[i - 1] + templates[i];
+            }
+            return sql;
+        }
+        else {
+            return sqlLike.genSql();
+        }
     }
 }
+/** @public */
+function isSqlTemplate(obj) {
+    if (typeof obj !== "object" || obj === null)
+        return false;
+    return Array.isArray(obj.templates) && Array.isArray(obj.args) && typeof obj.toTextArgs === "function";
+}
 
-export { sqlLikeToString };
+export { isSqlTemplate, sqlLikeToString };

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 } 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

@@ -1,7 +1,7 @@
 import { DbQuery } from "./DbQuery.ts";
 import { DbPoolConnection } from "./DbPoolConnection.ts";
 import { DbCursor, DbCursorOption } from "./DbCursor.ts";
-import { SqlStatementDataset } from "./_type.ts";
+import { SqlStatementDataset, SqlTemplate } from "./_type.ts";
 /**
  * 数据库连接
  * @public
@@ -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;
@@ -64,5 +64,5 @@ export interface DbQueryPool extends DbQuery {
 /** @public */
 export type SqlLike = {
     genSql(): string;
-} | string;
+} | SqlTemplate | string;
 //# sourceMappingURL=interfaces.d.ts.map

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

@@ -1,6 +1,7 @@
 export { ConnectionNotAvailableError, ParallelQueryError } from './errors.js';
-export { sqlLikeToString } from './DbQueryBase.js';
+export { isSqlTemplate, sqlLikeToString } from './DbQueryBase.js';
 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> {
@@ -44,13 +48,14 @@ export declare class SqlTextStatementDataset<T> extends SqlStatementDataset<T> {
  */
 export type InferQueryResult<T> = T extends SqlStatementDataset<infer P> ? P : never;
 /** @public */
-export interface SqlTemplate {
+export interface SqlTemplate<T extends readonly any[] = readonly unknown[]> {
     readonly templates: readonly string[];
-    readonly args: readonly unknown[];
-    toTextTemplate(): {
-        text: string;
-        args: string[];
-    };
-    genSql(): string;
+    readonly args: T;
+    toTextArgs(): string[];
+}
+/** @public */
+export interface SqlTextTemplate {
+    readonly textTemplate: string;
+    readonly textArgs: readonly string[];
 }
 //# sourceMappingURL=SqlStatement.d.ts.map

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/dist/sql_gen/mod.js

@@ -11,6 +11,7 @@ export { selectColumns } from './util.js';
 export { TypeChecker } from './your_table/checker.js';
 export { ColumnMeta, CustomDbType, YourTypeMap } from './your_table/infer_db_type.js';
 export { YourTable } from './your_table/table.js';
+export { TemplateSqlStatement as ValueSqlTemplate } from './sql_value/ValueSqlTemplate.js';
 export { orderBy } from './statement/select_impl.js';
 
 /**

package/dist/sql_gen/sql_value/ValueSqlTemplate.d.ts

@@ -1,13 +1,14 @@
-import { SqlTemplate } from "../SqlStatement.ts";
-export declare class ValueSqlTemplate implements SqlTemplate {
+import { SqlTemplate, SqlTextTemplate, SqlStatement } from "../SqlStatement.ts";
+/** @alpha */
+export declare class TemplateSqlStatement extends SqlStatement implements SqlTemplate, SqlTextTemplate {
+    #private;
     private v;
     readonly templates: readonly string[];
     readonly args: readonly unknown[];
     constructor(v: (value: unknown) => string, templates: readonly string[], values: readonly unknown[]);
-    toTextTemplate(): {
-        text: string;
-        args: string[];
-    };
+    get textArgs(): readonly string[];
+    get textTemplate(): string;
+    toTextArgs(): string[];
     genSql(): string;
 }
 //# sourceMappingURL=ValueSqlTemplate.d.ts.map

package/dist/sql_gen/sql_value/ValueSqlTemplate.js

@@ -1,30 +1,49 @@
-class ValueSqlTemplate {
+import { SqlStatement } from '../SqlStatement.js';
+
+/** @alpha */
+class TemplateSqlStatement extends SqlStatement {
     v;
     templates;
     args;
     constructor(v, templates, values) {
+        super();
         this.v = v;
         this.templates = templates;
         this.args = values;
     }
-    toTextTemplate() {
-        const { templates, args } = this;
-        let text = templates[0];
-        for (let i = 1; i < templates.length; i++) {
-            text += "$" + i;
-            text += templates[i];
+    #textArgs;
+    get textArgs() {
+        if (!this.#textArgs) {
+            const textArgs = this.args.map((value) => this.v(value));
+            this.#textArgs = textArgs;
         }
-        const values = args.map((value) => this.v(value));
-        return { text, args: values };
+        return this.#textArgs;
+    }
+    #textTemplate;
+    get textTemplate() {
+        if (this.#textTemplate === undefined) {
+            const { templates } = this;
+            let text = templates[0];
+            for (let i = 1; i < templates.length; i++) {
+                text += "$" + i;
+                text += templates[i];
+            }
+            this.#textTemplate = text;
+        }
+        return this.#textTemplate;
+    }
+    toTextArgs() {
+        return [...this.textArgs];
     }
     genSql() {
-        const { templates, args } = this;
+        const { templates } = this;
+        const textArgs = this.textArgs;
         let sql = this.templates[0];
         for (let i = 1; i < templates.length; i++) {
-            sql += this.v(args[i - 1]) + templates[i];
+            sql += textArgs[i - 1] + templates[i];
         }
         return sql;
     }
 }
 
-export { ValueSqlTemplate };
+export { TemplateSqlStatement };

package/dist/sql_gen/sql_value/sql_value.d.ts

@@ -1,5 +1,6 @@
-import { SqlTemplate } from "../SqlStatement.ts";
+import { TemplateSqlStatement } from "./ValueSqlTemplate.ts";
 import { AssertJsType, ObjectToValueKeys } from "./type.ts";
+export { TemplateSqlStatement as ValueSqlTemplate } from "./ValueSqlTemplate.ts";
 /** @public js 对象到编码函数的映射*/
 export type JsObjectMapSql = Map<new (...args: any[]) => any, SqlValueEncoder>;
 /** @public 将 js 值转为 SQl 字符串的函数*/
@@ -41,7 +42,7 @@ export declare class SqlValuesCreator {
      */
     toSqlStr(value: any, assertJsType?: AssertJsType): string;
     /** @alpha */
-    gen(split: TemplateStringsArray, ...values: any[]): SqlTemplate;
+    gen(split: TemplateStringsArray, ...values: any[]): TemplateSqlStatement;
     /** 获取值对应已定义的类 */
     getClassType(value: object): undefined | (new (...args: unknown[]) => unknown);
     protected defaultObject(value: object): string;

package/dist/sql_gen/sql_value/sql_value.js

@@ -1,5 +1,5 @@
 import { getObjectListKeys } from '../_statement.js';
-import { ValueSqlTemplate } from './ValueSqlTemplate.js';
+import { TemplateSqlStatement } from './ValueSqlTemplate.js';
 
 /**
  * SQL value 生成器
@@ -102,7 +102,7 @@ class SqlValuesCreator {
             sql += this.toSqlStr(values[i]);
             sql += split[i + 1];
         }
-        return new ValueSqlTemplate(this.toSqlStr.bind(this), split, values);
+        return new TemplateSqlStatement(this.toSqlStr.bind(this), split, values);
     }
     /** 获取值对应已定义的类 */
     getClassType(value) {
@@ -277,4 +277,4 @@ class SqlExplicitValuesStatement {
     }
 }
 
-export { SqlExplicitValuesStatement, SqlValuesCreator };
+export { SqlExplicitValuesStatement, SqlValuesCreator, TemplateSqlStatement as ValueSqlTemplate };

package/package.json

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