@asla/yoursql 0.8.3 → 0.8.5

package/README.md

@@ -77,3 +77,116 @@ const s = Selection.from("user", "u")
   .where(`u.name LIKE %${v(searchName)}%`)
   .toString();
 ```
+
+### client 抽象类
+
+yoursql 还导出了一些抽象类，实现抽象类后可以方便的进行数据查询
+
+```ts
+import {
+  type DbQueryPool,
+  type DbTransaction,
+  type DbConnection,
+  DbQuery,
+  DbCursor,
+  DbPoolConnection,
+  DbPoolTransaction,
+} from "@asla/yoursql/client";
+```
+
+#### DbQuery 抽象类
+
+```ts
+class YourQuery extends DbQuery {
+  // implement
+}
+const db: DbQuery = new YourQuery();
+```
+
+```ts
+declare const db: DbQuery;
+
+type Row = { name: string; age: number };
+const sqlText = "SELECT * FROM user";
+
+const rows: Row[] = await db.queryRows<Row>(sqlText);
+const count: number = await db.queryCount(sqlText);
+const rows: Map<string, Row> = await db.queryMap<Row>(sqlText, "name");
+```
+
+#### DbQueryPool 接口
+
+```ts
+class YourPool extends DbQuery implements DbQuery {
+  // implement
+}
+const pool: DbQueryPool = new YourPool();
+```
+
+##### 普通查询
+
+```ts
+const conn = await pool.connect();
+try {
+  await conn.queryRows(sqlText);
+} finally {
+  conn.release();
+}
+```
+
+或者，使用 `using` 语法更优雅
+
+```ts
+using conn = await pool.connect();
+await conn.queryRows(sqlText);
+```
+
+##### 事务查询
+
+```ts
+const conn = pool.begin();
+try {
+  await conn.queryRows(sqlText);
+  await conn.queryRows(sqlText);
+  await conn.commit();
+} catch (e) {
+  await conn.rollback();
+  throw e;
+}
+```
+
+或者，使用 `using` 语法更优雅
+
+```ts
+await using conn = pool.begin();
+
+await conn.queryRows(sqlText);
+await conn.queryRows(sqlText);
+await conn.commit();
+```
+
+##### 游标查询
+
+```ts
+const cursor = await pool.cursor(sqlText);
+
+let rows = await cursor.read(20);
+while (rows.length) {
+  console.log(rows);
+  rows = await cursor.read(20);
+  if (conditions) {
+    await cursor.close(); // 提前关闭游标
+    break;
+  }
+}
+```
+
+或者使用 `for await of` 更优雅
+
+```ts
+const cursor = await pool.cursor(sqlText);
+for await (const element of cursor) {
+  console.log(element);
+  if (conditions) break; //提前关闭游标
+}
+```

package/dist/client/DbPoolTransaction.d.ts

@@ -3,14 +3,19 @@ import { DbQuery } from "./DbQuery.ts";
 import type { MultipleQueryResult, QueryRowsResult } from "./DbQuery.ts";
 import type { DbPoolConnection } from "./DbPoolConnection.ts";
 import type { DbTransaction, TransactionMode } from "./interfaces.ts";
+/** @public */
+export type DbPoolTransactionOption = {
+    errorRollback?: boolean;
+    mode?: TransactionMode;
+};
 /**
  * @public
  * 池连接事务
  */
 export declare class DbPoolTransaction extends DbQuery implements DbTransaction {
     #private;
-    readonly mode?: TransactionMode | undefined;
-    constructor(connect: () => Promise<DbPoolConnection>, mode?: TransactionMode | undefined);
+    readonly mode?: TransactionMode;
+    constructor(connect: () => Promise<DbPoolConnection>, option?: TransactionMode | DbPoolTransactionOption);
     commit(): Promise<void>;
     rollback(): Promise<void>;
     savePoint(savePoint: string): Promise<void>;

package/dist/client/DbPoolTransaction.js

@@ -6,10 +6,18 @@ import { ParallelQueryError, ConnectionNotAvailableError } from './errors.js';
  * 池连接事务
  */
 class DbPoolTransaction extends DbQuery {
+    #errorRollback;
     mode;
-    constructor(connect, mode) {
+    constructor(connect, option) {
         super();
-        this.mode = mode;
+        if (option) {
+            if (typeof option === "string")
+                this.mode = option;
+            else {
+                this.mode = option.mode;
+                this.#errorRollback = option.errorRollback;
+            }
+        }
         this.#query = (sql) => {
             return new Promise((resolve, reject) => {
                 this.#pending = connect()
@@ -24,10 +32,16 @@ class DbPoolTransaction extends DbQuery {
                     this.#pending = undefined;
                     resolve(res[1]);
                 }, (e) => {
+                    // 语法错误、查询错误、网络错误
                     this.#pending = undefined;
                     reject(e);
-                    if (this.#conn)
-                        this.#release(this.#conn, e);
+                    const conn = this.#conn;
+                    if (conn) {
+                        this.#release(conn, e);
+                        if (this.#errorRollback) {
+                            return conn.rollback().catch((e) => { });
+                        }
+                    }
                 });
             });
         };
@@ -60,12 +74,20 @@ class DbPoolTransaction extends DbQuery {
     }
     /** 拿到连接后执行这个 */
     #queryAfter(sql) {
-        return this.#conn.query(sql).then((res) => {
+        const conn = this.#conn;
+        return conn.query(sql).then((res) => {
             this.#pending = undefined;
             return res;
         }, (e) => {
             this.#pending = undefined;
-            this.#release(this.#conn, e);
+            this.#release(conn, e);
+            if (this.#errorRollback) {
+                return conn.rollback().then(() => {
+                    throw e;
+                }, () => {
+                    throw e;
+                });
+            }
             throw e;
         });
     }
@@ -73,12 +95,12 @@ class DbPoolTransaction extends DbQuery {
     query(sql) {
         if (this.#pending)
             return Promise.reject(new ParallelQueryError());
-        return this.#query(sql.toString());
+        return this.#query(sql);
     }
     multipleQuery(sql) {
         if (this.#pending)
             return Promise.reject(new ParallelQueryError());
-        return this.#query(sql.toString());
+        return this.#query(sql);
     }
     #error;
     #release(conn, error = new ConnectionNotAvailableError("Connection already release")) {

package/dist/sql_gen/mod.d.ts

@@ -3,7 +3,9 @@ export * from "./sql_value/sql_value.ts";
 export * from "./select/type.ts";
 export * from "./select/DbTable.ts";
 export * from "./select/query_chain_select.ts";
-export * from "./select/query_chain_abstract.ts";
+export * from "./select/chain_base.ts";
+export * from "./select/chain_modify.ts";
+export * from "./select/chain_select.ts";
 export * from "./select/TableQuery.ts";
 export * from "./util.ts";
 export * from "./your_table/mod.ts";

package/dist/sql_gen/mod.js

@@ -3,7 +3,7 @@ import { SqlValuesCreator } from './sql_value/sql_value.js';
 export { SqlRaw } from './sql_value/sql_value.js';
 export { DbTable } from './select/DbTable.js';
 export { Selection, SqlSelectChain } from './select/query_chain_select.js';
-export { SqlStatement, SqlStatementDataset, SqlTextStatementDataset } from './select/query_chain_abstract.js';
+export { SqlStatement, SqlStatementDataset, SqlTextStatementDataset } from './select/chain_base.js';
 export { DbTableQuery } from './select/TableQuery.js';
 export { getObjectListKeys, having, orderBy, selectColumns, where } from './util.js';
 export { TypeChecker } from './your_table/checker.js';

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

@@ -1,7 +1,8 @@
 import { ConditionParam, Constructable } from "../util.ts";
 import type { TableType } from "./type.ts";
 import { Selection } from "./query_chain_select.ts";
-import { ChainModifyWhere, ChainOnConflict, ChainSelectWhere } from "./query_chain_abstract.ts";
+import { ChainDelete, ChainInsert, ChainUpdate } from "./chain_modify.ts";
+import { ChainSelect } from "./chain_select.ts";
 /**
  * 数据库表
  * @public
@@ -11,13 +12,17 @@ export declare class DbTable<T extends TableType> {
     constructor(name: string);
     fromAs(as?: string): Selection;
     /** 选择单表全部列 */
-    select(columns: "*", as?: string): ChainSelectWhere<T>;
-    /** 选择单表  */
-    select(columns: Constructable<Record<string, boolean | string> | string>, as?: string): ChainSelectWhere<Record<string, any>>;
+    select(columns: "*", as?: string): ChainSelect<T>;
+    /** 选择单表，带提示  */
+    select(columns: Constructable<{
+        [key in keyof T]?: string | boolean;
+    } & {
+        [key: string]: string | boolean;
+    }>, as?: string): ChainSelect<Record<string, any>>;
     /** 选择单表  */
     select<R extends {}>(columns: Constructable<{
         [key in keyof R]: boolean | string;
-    } | string>, as?: string): ChainSelectWhere<R>;
+    } | string | string[]>, as?: string): ChainSelect<R>;
     /**
      * INSERT 语句，需要注意 SQL 注入
      * @example
@@ -25,7 +30,7 @@ export declare class DbTable<T extends TableType> {
      * table.insert(["age","name"], "VALUES (18, 'hi'), (17, 'hh')") // INSERT INTO table(age,name) VALUES(18, 'hi'), (17, 'hh')
      * ```
      */
-    insert(columns: string, values: Constructable<string>): ChainOnConflict<T>;
+    insert(columns: string, values: Constructable<string>): ChainInsert<T>;
     /**
      * UPDATE 语句，需要注意 SQL 注入
      * @example
@@ -36,8 +41,8 @@ export declare class DbTable<T extends TableType> {
      */
     update(values: Constructable<{
         [key in keyof T]?: string;
-    } | string>): ChainModifyWhere<T>;
-    delete(option?: DeleteOption): ChainModifyWhere<T>;
+    } | string>): ChainUpdate<T>;
+    delete(option?: DeleteOption): ChainDelete<T>;
     toSelect(): string;
 }
 /** @public */

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

@@ -2,7 +2,7 @@ import { SqlValuesCreator } from "../sql_value/sql_value.ts";
 import { UpdateRowValue, TableType } from "./type.ts";
 import { Constructable } from "../util.ts";
 import { DbTable } from "./DbTable.ts";
-import { ChainModifyWhere, ChainOnConflict } from "./query_chain_abstract.ts";
+import { ChainInsert, ChainUpdate } from "./chain_modify.ts";
 /** @public */
 export declare class DbTableQuery<T extends TableType = Record<string, any>, C extends TableType = Partial<T>> extends DbTable<T> {
     private statement;
@@ -14,8 +14,8 @@ export declare class DbTableQuery<T extends TableType = Record<string, any>, C e
      * table.insert([{age:18, name:"hi"}, {age:17, name:"hh"}]) // INSERT INTO table(age,name) VALUES(18, 'hi'), (17, 'hh')
      * ```
      */
-    insert(values: Constructable<UpdateRowValue<C> | UpdateRowValue<C>[]>): ChainOnConflict<T>;
-    insert(columns: string, values: Constructable<string>): ChainOnConflict<T>;
+    insert(values: Constructable<UpdateRowValue<C> | UpdateRowValue<C>[]>): ChainInsert<T>;
+    insert(columns: string, values: Constructable<string>): ChainInsert<T>;
     /**
      * UPDATE 语句，与 update() 不同的是，它会将值进行安全转换
      * @example
@@ -23,6 +23,6 @@ export declare class DbTableQuery<T extends TableType = Record<string, any>, C e
      * table.update({age:3, name:"hi"}, true) // "UPDATE table SET age=3, name='hi'"
      * ```
      */
-    updateFrom(values: Constructable<UpdateRowValue<T>>): ChainModifyWhere<T>;
+    updateFrom(values: Constructable<UpdateRowValue<T>>): ChainUpdate<T>;
 }
 //# sourceMappingURL=TableQuery.d.ts.map

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

@@ -0,0 +1,44 @@
+/** @public */
+export declare abstract class SqlStatement {
+    /** 获取 SQL 语句 */
+    abstract toString(): string;
+}
+/**
+ * 可选择项。可以是 table、查询结果等，它能被 select 语句选择
+ * @example
+ * ```ts
+ * declare const item: SqlStatementDataset
+ * await query(`select * from ${item.toSelect()}`)
+ *
+ * ```
+ * @public
+ */
+export interface SqlSelectable {
+    /**
+     * 转成子选择语句, 你可以使用 select form xxx 选择
+     * 如果是 table 则是 table name
+     * 如果是 选择语句，则是 (xxx)
+     */
+    toSelect(): string;
+}
+/** @public */
+export declare abstract class SqlStatementDataset<T> extends SqlStatement implements SqlSelectable {
+    /**
+     * 转成子选择语句, 你可以使用 select form xxx 选择
+     * 如果是 table 则是 table name
+     * 如果是 选择语句，则是 (xxx)
+     */
+    toSelect(): string;
+}
+/** @public */
+export declare class SqlTextStatementDataset<T> extends SqlStatementDataset<T> {
+    readonly sql: string;
+    constructor(sql: string);
+    toString(): string;
+}
+/**
+ * 推断查询结果的类型
+ * @public
+ */
+export type InferQueryResult<T> = T extends SqlStatementDataset<infer P> ? P : never;
+//# sourceMappingURL=chain_base.d.ts.map

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

@@ -0,0 +1,33 @@
+import { ConditionParam, Constructable, SelectParam } from "../util.ts";
+import { TableType } from "./type.ts";
+import { SqlStatement, SqlStatementDataset } from "./chain_base.ts";
+/** @public */
+export interface ChainModifyReturning<T extends TableType = {}> extends SqlStatement {
+    returning(columns: "*"): SqlStatementDataset<T>;
+    returning(columns: Constructable<SelectParam>): SqlStatementDataset<Record<string, any>>;
+    returning<R extends TableType>(columns: Constructable<SelectParam>): SqlStatementDataset<R>;
+}
+/** @public */
+export interface ChainAfterConflictDo<T extends TableType = {}> {
+    doNotThing(): ChainModifyReturning<T>;
+    /**
+     * 需要注意 SQL 注入
+     */
+    doUpdate(set: Constructable<string | {
+        [key in keyof T]?: string;
+    }>): ChainModifyReturning<T>;
+    toString(): string;
+}
+/** @public */
+export interface ChainInsert<T extends TableType = {}> extends ChainModifyReturning<T> {
+    onConflict(option: Constructable<readonly (keyof T)[] | string>): ChainAfterConflictDo<T>;
+}
+/** @public */
+export interface ChainUpdate<T extends TableType = {}> extends ChainModifyReturning<T> {
+    where(where: Constructable<ConditionParam | void>): ChainModifyReturning<T>;
+}
+/** @public */
+export interface ChainDelete<T extends TableType = {}> extends ChainModifyReturning<T> {
+    where(where: Constructable<ConditionParam | void>): ChainModifyReturning<T>;
+}
+//# sourceMappingURL=chain_modify.d.ts.map

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

@@ -0,0 +1,28 @@
+import { ConditionParam, Constructable, OrderByParam } from "../util.ts";
+import { SqlStatementDataset } from "./chain_base.ts";
+import { TableType } from "./type.ts";
+/** @public */
+export interface ChainSelect<T extends TableType> extends ChainSelectAfterWhere<T> {
+    where(param: Constructable<ConditionParam | void>): ChainSelectAfterWhere<T>;
+}
+/** @public */
+export interface ChainSelectAfterWhere<T extends TableType> extends ChainSelectAfterHaving<T> {
+    groupBy(columns: string | string[]): ChainSelectAfterGroupBy<T>;
+}
+/** @public */
+export interface ChainSelectAfterGroupBy<T extends TableType> extends ChainSelectAfterHaving<T> {
+    orderBy(param: Constructable<OrderByParam | void>): ChainSelectAfterOrderBy<T>;
+    having(param: Constructable<ConditionParam | void>): ChainSelectAfterHaving<T>;
+}
+/** @public */
+export interface ChainSelectAfterHaving<T extends TableType> extends ChainSelectAfterOrderBy<T> {
+    orderBy(param: Constructable<OrderByParam | void>): ChainSelectAfterOrderBy<T>;
+}
+/** @public */
+export interface ChainSelectAfterOrderBy<T extends TableType> extends SqlStatementDataset<T> {
+    limit(limit?: number | bigint, offset?: number | bigint): ChainSelectAfterLimit<T>;
+}
+/** @public */
+export interface ChainSelectAfterLimit<T extends TableType> extends SqlStatementDataset<T> {
+}
+//# sourceMappingURL=chain_select.d.ts.map

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

@@ -1,20 +1,22 @@
 import { ConditionParam, Constructable, SelectParam } from "../util.ts";
-import { SqlStatementDataset, SqlStatement, ChainModifyWhere, ChainOnConflict, ChainConflictDo, ChainModifyReturning } from "./query_chain_abstract.ts";
+import { SqlStatementDataset, SqlStatement } from "./chain_base.ts";
+import { ChainAfterConflictDo, ChainModifyReturning, ChainInsert, ChainDelete, ChainUpdate } from "./chain_modify.ts";
 import { TableType } from "./type.ts";
-export declare class SqlChainModify<T extends TableType = {}> extends SqlStatement implements ChainOnConflict<T>, ChainModifyWhere<T> {
+export declare class SqlChainModify<T extends TableType = {}> extends SqlStatement implements ChainInsert<T>, ChainUpdate<T>, ChainDelete<T> {
     readonly sql: string;
     constructor(sql: string);
     returning<R extends {}>(returns: Constructable<SelectParam | "*">): SqlStatementDataset<R>;
-    onConflict(onConflict: Constructable<readonly string[] | string>): ChainConflictDo<T>;
+    onConflict(onConflict: Constructable<readonly string[] | string>): ChainAfterConflictDo<T>;
     where(where: Constructable<ConditionParam | void>): ChainModifyReturning<T>;
     toString(): string;
 }
-export declare class SqlInsertConflictBranch<T extends TableType = {}> implements ChainConflictDo<T> {
+export declare class SqlInsertConflictBranch<T extends TableType = {}> implements ChainAfterConflictDo<T> {
     readonly sql: string;
     constructor(sql: string);
     doUpdate(set?: Constructable<string | {
         [key: string]: string | undefined;
-    }>): ChainModifyWhere<T>;
+    }>): ChainModifyReturning<T>;
     doNotThing(): ChainModifyReturning<T>;
+    toString(): string;
 }
 //# sourceMappingURL=query_chain_insert.d.ts.map

package/dist/sql_gen/select/query_chain_insert.js

@@ -1,6 +1,6 @@
 import { selectColumns, where } from '../util.js';
 import { createUpdateSetFromObject } from './_statement.js';
-import { SqlStatement, SqlTextStatementDataset } from './query_chain_abstract.js';
+import { SqlStatement, SqlTextStatementDataset } from './chain_base.js';
 
 class SqlChainModify extends SqlStatement {
     sql;
@@ -51,7 +51,7 @@ class SqlInsertConflictBranch {
             sql += createUpdateSetFromObject(set);
         }
         else if (set)
-            sql += "DO UPDATE SET\n" + set;
+            sql += "DO UPDATE\n" + set;
         else
             sql += "DO NOTHING";
         return new SqlChainModify(sql);
@@ -59,6 +59,9 @@ class SqlInsertConflictBranch {
     doNotThing() {
         return new SqlChainModify(this.sql + " DO NOTHING");
     }
+    toString() {
+        return this.sql;
+    }
 }
 
 export { SqlChainModify, SqlInsertConflictBranch };

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

@@ -1,15 +1,16 @@
-import { ChainSelectGroupBy, ChainSelectHaving, ChainSelectLimit, ChainSelectWhere, SqlSelectable, SqlStatementDataset, SqlTextStatementDataset } from "./query_chain_abstract.ts";
+import { SqlSelectable, SqlTextStatementDataset } from "./chain_base.ts";
+import { ChainSelect, ChainSelectAfterHaving, ChainSelectAfterLimit, ChainSelectAfterOrderBy, ChainSelectAfterGroupBy, ChainSelectAfterWhere } from "./chain_select.ts";
 import { OrderByParam, ConditionParam, SelectParam, Constructable } from "../util.ts";
 import type { TableType } from "./type.ts";
 /**
  * @public ChainSelectWhere 的默认实现
  */
-export declare class SqlSelectChain<T extends TableType> extends SqlTextStatementDataset<T> implements ChainSelectWhere<T> {
-    where(param?: Constructable<ConditionParam | void>): ChainSelectGroupBy<T>;
-    groupBy(columns: string | string[]): ChainSelectHaving<T>;
-    having(param?: Constructable<ConditionParam | void>): ChainSelectLimit<T>;
-    orderBy(param?: Constructable<OrderByParam | void>): ChainSelectLimit<T>;
-    limit(limit?: number, offset?: number): SqlStatementDataset<T>;
+export declare class SqlSelectChain<T extends TableType> extends SqlTextStatementDataset<T> implements ChainSelect<T> {
+    where(param?: Constructable<ConditionParam | void>): ChainSelectAfterWhere<T>;
+    groupBy(columns: string | string[]): ChainSelectAfterGroupBy<T>;
+    having(param?: Constructable<ConditionParam | void>): ChainSelectAfterHaving<T>;
+    orderBy(param?: Constructable<OrderByParam | void>): ChainSelectAfterOrderBy<T>;
+    limit(limit?: number, offset?: number): ChainSelectAfterLimit<T>;
 }
 /** @public */
 export declare class Selection {
@@ -25,7 +26,7 @@ export declare class Selection {
     crossJoin(selectable: Constructable<SqlSelectable | string>, as?: string | undefined): Selection;
     from(selectable: Constructable<SqlSelectable | string>, as?: string): Selection;
     /** 选择全部列 */
-    select<T extends TableType = Record<string, any>>(columns: "*"): ChainSelectWhere<T>;
+    select<T extends TableType = Record<string, any>>(columns: "*"): ChainSelect<T>;
     /**
      * 自定义SQL选择语句
      * @example
@@ -33,7 +34,7 @@ export declare class Selection {
      * selection.select("t.age, count(*) AS c") // SELECT t.age,count(*) AS c FROM ...
      * ```
      */
-    select(columns: Constructable<SelectParam>): ChainSelectWhere<Record<string, any>>;
+    select(columns: Constructable<SelectParam>): ChainSelect<Record<string, any>>;
     /**
      * 通过 object 选择 列
      * @example
@@ -43,6 +44,6 @@ export declare class Selection {
      */
     select<T extends TableType>(columns: Constructable<{
         [key in keyof T]: string | boolean;
-    } | string>): ChainSelectWhere<T>;
+    } | string>): ChainSelect<T>;
 }
 //# sourceMappingURL=query_chain_select.d.ts.map

package/dist/sql_gen/select/query_chain_select.js

@@ -1,4 +1,4 @@
-import { SqlTextStatementDataset } from './query_chain_abstract.js';
+import { SqlTextStatementDataset } from './chain_base.js';
 import { where, having, orderBy, selectColumns } from '../util.js';
 import { condition } from './_statement.js';
 

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

@@ -1,4 +1,4 @@
-import { SqlStatementDataset } from "../select/query_chain_abstract.ts";
+import { SqlStatementDataset } from "../select/chain_base.ts";
 declare const SQL_RAW: unique symbol;
 /**
  * SQL 原始字符类。可以使用 String 类代替，这只是为了推断类型

package/dist/sql_gen/sql_value/sql_value.js

@@ -1,5 +1,5 @@
 import { getObjectListKeys } from '../util.js';
-import { SqlStatementDataset } from '../select/query_chain_abstract.js';
+import { SqlStatementDataset } from '../select/chain_base.js';
 
 /**
  * SQL 原始字符类。可以使用 String 类代替，这只是为了推断类型

package/package.json

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

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

@@ -1,91 +0,0 @@
-import { ConditionParam, Constructable, OrderByParam, SelectParam } from "../util.ts";
-import { TableType } from "./type.ts";
-/** @public */
-export declare abstract class SqlStatement {
-    /** 获取 SQL 语句 */
-    abstract toString(): string;
-}
-/**
- * 可选择项。可以是 table、查询结果等，它能被 select 语句选择
- * @example
- * ```ts
- * declare const item: SqlStatementDataset
- * await query(`select * from ${item.toSelect()}`)
- *
- * ```
- * @public
- */
-export interface SqlSelectable {
-    /**
-     * 转成子选择语句, 你可以使用 select form xxx 选择
-     * 如果是 table 则是 table name
-     * 如果是 选择语句，则是 (xxx)
-     */
-    toSelect(): string;
-}
-/** @public */
-export declare abstract class SqlStatementDataset<T> extends SqlStatement implements SqlSelectable {
-    /**
-     * 转成子选择语句, 你可以使用 select form xxx 选择
-     * 如果是 table 则是 table name
-     * 如果是 选择语句，则是 (xxx)
-     */
-    toSelect(): string;
-}
-/** @public */
-export interface ChainSelectLimit<T extends TableType> extends SqlStatementDataset<T> {
-    limit(limit?: number | bigint, offset?: number | bigint): SqlStatementDataset<T>;
-}
-/** @public */
-export interface ChainSelectOrderBy<T extends TableType> extends ChainSelectLimit<T> {
-    orderBy(param: Constructable<OrderByParam | void>): ChainSelectLimit<T>;
-}
-/** @public */
-export interface ChainSelectHaving<T extends TableType> extends ChainSelectOrderBy<T> {
-    having(param: Constructable<ConditionParam | void>): ChainSelectLimit<T>;
-}
-/** @public */
-export interface ChainSelectGroupBy<T extends TableType> extends ChainSelectOrderBy<T> {
-    groupBy(columns: string | string[]): ChainSelectHaving<T>;
-}
-/** @public */
-export interface ChainSelectWhere<T extends TableType> extends ChainSelectGroupBy<T> {
-    where(param: Constructable<ConditionParam | void>): ChainSelectGroupBy<T>;
-}
-/** @public */
-export interface ChainModifyReturning<T extends TableType = {}> extends SqlStatement {
-    returning(columns: "*"): SqlStatementDataset<T>;
-    returning(columns: Constructable<SelectParam>): SqlStatementDataset<Record<string, any>>;
-    returning<R extends TableType>(columns: Constructable<SelectParam>): SqlStatementDataset<R>;
-}
-/** @public */
-export interface ChainModifyWhere<T extends TableType = {}> extends ChainModifyReturning<T> {
-    where(where: Constructable<ConditionParam | void>): ChainModifyReturning<T>;
-}
-/** @public */
-export interface ChainConflictDo<T extends TableType = {}> {
-    doNotThing(): ChainModifyReturning<T>;
-    /**
-     * 需要注意 SQL 注入
-     */
-    doUpdate(set: Constructable<string | {
-        [key in keyof T]?: string;
-    }>): ChainModifyWhere<T>;
-    toString(): string;
-}
-/** @public */
-export interface ChainOnConflict<T extends TableType = {}> extends ChainModifyReturning<T> {
-    onConflict(option: Constructable<readonly (keyof T)[] | string>): ChainConflictDo<T>;
-}
-/** @public */
-export declare class SqlTextStatementDataset<T> extends SqlStatementDataset<T> {
-    readonly sql: string;
-    constructor(sql: string);
-    toString(): string;
-}
-/**
- * 推断查询结果的类型
- * @public
- */
-export type InferQueryResult<T> = T extends SqlStatementDataset<infer P> ? P : never;
-//# sourceMappingURL=query_chain_abstract.d.ts.map