@asla/yoursql 0.7.0 → 0.8.0

package/dist/mod.d.ts

@@ -2,8 +2,8 @@ export * from "./sql_value/db_type.ts";
 export * from "./sql_value/sql_value.ts";
 export * from "./select/type.ts";
 export * from "./select/DbTable.ts";
-export * from "./select/query_link.ts";
-export * from "./select/selectable.ts";
+export * from "./select/query_chain_select.ts";
+export * from "./select/query_chain_abstract.ts";
 export * from "./select/TableQuery.ts";
 export * from "./util.ts";
 export * from "./your_table/mod.ts";

package/dist/mod.js

@@ -275,37 +275,30 @@ function handlerOrderValue(value) {
     }
 }
 
-var _SqlQueryStatement_sql;
-/**
- * 可选择项。可以是 table、查询结果等，它能被 select 语句选择
- * @example
- * ```ts
- * declare const item: SqlSelectable<any>
- * await query(`select * from ${item.toSelect()}`)
- *
- * ```
- * @public
- */
-class SqlSelectable {
+/** @public */
+class SqlStatement {
 }
-/**
- * SELECT 以及 UPDATE、DELETE、INSERT INTO 带结果的 SQL 语句
- * @public
- */
-class SqlQueryStatement extends SqlSelectable {
+/** @public */
+class SqlStatementDataset extends SqlStatement {
+    /**
+     * 转成子选择语句, 你可以使用 select form xxx 选择
+     * 如果是 table 则是 table name
+     * 如果是 选择语句，则是 (xxx)
+     */
+    toSelect() {
+        return "(" + this.toString() + ")";
+    }
+}
+/** @public */
+class SqlTextStatementDataset extends SqlStatementDataset {
     constructor(sql) {
         super();
-        _SqlQueryStatement_sql.set(this, void 0);
-        __classPrivateFieldSet(this, _SqlQueryStatement_sql, sql.toString(), "f");
+        this.sql = sql;
     }
     toString() {
-        return __classPrivateFieldGet(this, _SqlQueryStatement_sql, "f");
-    }
-    toSelect() {
-        return "(" + this.toString() + ")";
+        return this.sql;
     }
 }
-_SqlQueryStatement_sql = new WeakMap();
 
 var _YourValuesAs_asName, _YourValuesAs_valuesStr, _YourValuesAs_sql;
 /**
@@ -568,7 +561,7 @@ class SqlValuesCreator {
         return new YourValuesAs(insertKeys, asName, valuesStr.join(",\n"));
     }
 }
-class YourValuesAs extends SqlSelectable {
+class YourValuesAs extends SqlStatementDataset {
     constructor(columns, asName, valuesStr) {
         super();
         _YourValuesAs_asName.set(this, void 0);
@@ -646,12 +639,12 @@ const pgSqlTransformer = new Map([
 ]);
 
 var _Selection_instances, _a, _Selection_sql, _Selection_join;
-class AfterSelectImpl extends SqlQueryStatement {
-    constructor(sql) {
-        super(sql);
-    }
+/**
+ * @public ChainSelectWhere 的默认实现
+ */
+class SqlSelectChain extends SqlTextStatementDataset {
     where(param) {
-        return new AfterSelectImpl(this.toString() + where(param));
+        return new SqlSelectChain(this.toString() + where(param));
     }
     groupBy(columns) {
         let sql = this.toString();
@@ -659,13 +652,13 @@ class AfterSelectImpl extends SqlQueryStatement {
             sql += " GROUP BY " + columns;
         else
             sql += " GROUP BY " + columns.join(",");
-        return new AfterSelectImpl(sql);
+        return new SqlSelectChain(sql);
     }
     having(param) {
-        return new AfterSelectImpl(this.toString() + having(param));
+        return new SqlSelectChain(this.toString() + having(param));
     }
     orderBy(param) {
-        return new AfterSelectImpl(this.toString() + orderBy(param));
+        return new SqlSelectChain(this.toString() + orderBy(param));
     }
     limit(limit, offset) {
         let sql = this.toString();
@@ -684,7 +677,7 @@ class AfterSelectImpl extends SqlQueryStatement {
             else
                 throw new TypeError("offset 必须是个整数：" + limit);
         }
-        return new SqlQueryStatement(sql);
+        return new SqlTextStatementDataset(sql);
     }
 }
 function fromAs(selectable, as) {
@@ -734,7 +727,7 @@ class Selection {
             columnsIn = columnsIn();
         let sql = "SELECT " + selectColumns(columnsIn);
         sql += "\n" + this.toString();
-        return new AfterSelectImpl(sql);
+        return new SqlSelectChain(sql);
     }
 }
 _a = Selection, _Selection_sql = new WeakMap(), _Selection_instances = new WeakSet(), _Selection_join = function _Selection_join(type, selectable, as, on) {
@@ -745,8 +738,11 @@ _a = Selection, _Selection_sql = new WeakMap(), _Selection_instances = new WeakS
     return new _a(sql);
 };
 
-var _AfterInsert_sql;
-class AfterUpdateOrReturn extends SqlQueryStatement {
+class SqlChainModify extends SqlStatement {
+    constructor(sql) {
+        super();
+        this.sql = sql;
+    }
     returning(returns) {
         if (typeof returns === "function")
             returns = returns();
@@ -759,7 +755,7 @@ class AfterUpdateOrReturn extends SqlQueryStatement {
             columnsStr = res.sqlColumns;
         }
         let sql = this.toString() + "\nRETURNING " + columnsStr;
-        return new SqlQueryStatement(sql);
+        return new SqlTextStatementDataset(sql);
     }
     onConflict(onConflict) {
         if (typeof onConflict === "function")
@@ -767,22 +763,24 @@ class AfterUpdateOrReturn extends SqlQueryStatement {
         if (typeof onConflict !== "string")
             onConflict = onConflict.join(",");
         let sql = this.toString() + `\nON CONFLICT (${onConflict})`;
-        return new AfterInsert(sql);
+        return new SqlInsertConflictBranch(sql);
     }
     where(where$1) {
         const sql = where(where$1);
-        return new AfterUpdateOrReturn(this.toString() + sql);
+        return new SqlChainModify(this.toString() + sql);
+    }
+    toString() {
+        return this.sql;
     }
 }
-class AfterInsert {
+class SqlInsertConflictBranch {
     constructor(sql) {
-        _AfterInsert_sql.set(this, void 0);
-        __classPrivateFieldSet(this, _AfterInsert_sql, sql, "f");
+        this.sql = sql;
     }
     doUpdate(set) {
         if (typeof set === "function")
             set = set();
-        let sql = this.toString();
+        let sql = this.sql;
         if (typeof set === "object") {
             sql += "\nDO UPDATE ";
             sql += createUpdateSetFromObject(set);
@@ -791,24 +789,19 @@ class AfterInsert {
             sql += "DO UPDATE SET\n" + set;
         else
             sql += "DO NOTHING";
-        return new AfterUpdateOrReturn(sql);
+        return new SqlChainModify(sql);
     }
     doNotThing() {
-        return new AfterUpdateOrReturn(__classPrivateFieldGet(this, _AfterInsert_sql, "f") + " DO NOTHING");
-    }
-    toString() {
-        return __classPrivateFieldGet(this, _AfterInsert_sql, "f");
+        return new SqlChainModify(this.sql + " DO NOTHING");
     }
 }
-_AfterInsert_sql = new WeakMap();
 
 /**
  * 数据库表
  * @public
  */
-class DbTable extends SqlSelectable {
+class DbTable {
     constructor(name) {
-        super();
         this.name = name;
     }
     fromAs(as) {
@@ -832,7 +825,7 @@ class DbTable extends SqlSelectable {
         if (typeof values !== "string")
             throw new TypeError("values 必须是 string 或 function 类型");
         let sql = `INSERT INTO ${this.name}(${columns})\n${values}`;
-        return new AfterUpdateOrReturn(sql);
+        return new SqlChainModify(sql);
     }
     /**
      * UPDATE 语句，需要注意 SQL 注入
@@ -848,10 +841,10 @@ class DbTable extends SqlSelectable {
         switch (typeof values) {
             case "object": {
                 let sql = createUpdateSetFromObject(values);
-                return new AfterUpdateOrReturn("UPDATE " + this.name + " " + sql);
+                return new SqlChainModify("UPDATE " + this.name + " " + sql);
             }
             case "string":
-                return new AfterUpdateOrReturn("UPDATE " + this.name + " SET\n" + values);
+                return new SqlChainModify("UPDATE " + this.name + " SET\n" + values);
             default:
                 throw new TypeError("参数 values 错误");
         }
@@ -859,14 +852,11 @@ class DbTable extends SqlSelectable {
     delete(option = {}) {
         let sql = "DELETE FROM " + this.name;
         sql += where(option.where);
-        return new AfterUpdateOrReturn(sql);
+        return new SqlChainModify(sql);
     }
     toSelect() {
         return this.name;
     }
-    toString() {
-        return this.name;
-    }
 }
 
 /** @public */
@@ -899,7 +889,7 @@ class DbTableQuery extends DbTable {
             throw new Error("插入列不能为空");
         const columnStr = insertCol.join(",");
         let sql = `INSERT INTO ${this.name} (${columnStr})\n${valuesStr}`;
-        return new AfterUpdateOrReturn(sql);
+        return new SqlChainModify(sql);
     }
     /**
      * UPDATE 语句，与 update() 不同的是，它会将值进行安全转换
@@ -927,7 +917,7 @@ class DbTableQuery extends DbTable {
         if (!setStr)
             throw new Error("值不能为空");
         let sql = `UPDATE ${this.name} SET\n${setStr}`;
-        return new AfterUpdateOrReturn(sql);
+        return new SqlChainModify(sql);
     }
 }
 
@@ -1109,4 +1099,4 @@ class YourTable extends DbTableQuery {
  */
 const v = SqlValuesCreator.create(pgSqlTransformer);
 
-export { ColumnMeta, CustomDbType, DbTable, DbTableQuery, Selection, SqlQueryStatement, SqlRaw, SqlSelectable, SqlValuesCreator, TypeChecker, YourTable, YourTypeMap, getObjectListKeys, having, orderBy, pgSqlTransformer, selectColumns, v, where };
+export { ColumnMeta, CustomDbType, DbTable, DbTableQuery, Selection, SqlRaw, SqlSelectChain, SqlStatement, SqlStatementDataset, SqlTextStatementDataset, SqlValuesCreator, TypeChecker, YourTable, YourTypeMap, getObjectListKeys, having, orderBy, pgSqlTransformer, selectColumns, v, where };

package/dist/select/DbTable.d.ts

@@ -1,22 +1,23 @@
-import { SqlSelectable } from "./selectable.ts";
-import { ConditionParam, Constructable, SelectParam } from "../util.ts";
+import { ConditionParam, Constructable } from "../util.ts";
 import type { TableType } from "./type.ts";
-import { CurrentModifyWhere, CurrentOnConflict, CurrentWhere, Selection } from "./query_link.ts";
+import { Selection } from "./query_chain_select.ts";
+import { ChainModifyWhere, ChainOnConflict, ChainSelectWhere } from "./query_chain_abstract.ts";
 /**
  * 数据库表
  * @public
  */
-export declare class DbTable<T extends TableType> extends SqlSelectable<T> {
+export declare class DbTable<T extends TableType> {
     readonly name: string;
     constructor(name: string);
     fromAs(as?: string): Selection;
     /** 选择单表全部列 */
-    select(columns: "*", as?: string): CurrentWhere<T>;
+    select(columns: "*", as?: string): ChainSelectWhere<T>;
+    /** 选择单表  */
+    select(columns: Constructable<Record<string, boolean | string> | string>, as?: string): ChainSelectWhere<Record<string, any>>;
     /** 选择单表  */
     select<R extends {}>(columns: Constructable<{
         [key in keyof R]: boolean | string;
-    } | string>, as?: string): CurrentWhere<R>;
-    select<R extends {}>(columns: Constructable<SelectParam>): CurrentWhere<R>;
+    } | string>, as?: string): ChainSelectWhere<R>;
     /**
      * INSERT 语句，需要注意 SQL 注入
      * @example
@@ -24,7 +25,7 @@ export declare class DbTable<T extends TableType> extends SqlSelectable<T> {
      * 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>): CurrentOnConflict<T>;
+    insert(columns: string, values: Constructable<string>): ChainOnConflict<T>;
     /**
      * UPDATE 语句，需要注意 SQL 注入
      * @example
@@ -35,10 +36,9 @@ export declare class DbTable<T extends TableType> extends SqlSelectable<T> {
      */
     update(values: Constructable<{
         [key in keyof T]?: string;
-    } | string>): CurrentModifyWhere<T>;
-    delete(option?: DeleteOption): CurrentModifyWhere<T>;
+    } | string>): ChainModifyWhere<T>;
+    delete(option?: DeleteOption): ChainModifyWhere<T>;
     toSelect(): string;
-    toString(): string;
 }
 /** @public */
 export interface DeleteOption {

package/dist/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 type { CurrentModifyWhere, CurrentOnConflict } from "./query_link.ts";
+import { ChainModifyWhere, ChainOnConflict } from "./query_chain_abstract.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>[]>): CurrentOnConflict<T>;
-    insert(columns: string, values: Constructable<string>): CurrentOnConflict<T>;
+    insert(values: Constructable<UpdateRowValue<C> | UpdateRowValue<C>[]>): ChainOnConflict<T>;
+    insert(columns: string, values: Constructable<string>): ChainOnConflict<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>>): CurrentModifyWhere<T>;
+    updateFrom(values: Constructable<UpdateRowValue<T>>): ChainModifyWhere<T>;
 }
 //# sourceMappingURL=TableQuery.d.ts.map

package/dist/select/query_chain_abstract.d.ts

@@ -0,0 +1,91 @@
+import { ConditionParam, Constructable, OrderByParam } from "../util.ts";
+import { ColumnsSelected, 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<ColumnsSelected<T> | string>): SqlStatementDataset<Record<string, any>>;
+    returning<R extends TableType>(columns: Constructable<ColumnsSelected<R> | string>): 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

package/dist/select/query_chain_insert.d.ts

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

package/dist/select/query_chain_select.d.ts

@@ -0,0 +1,48 @@
+import { ChainSelectGroupBy, ChainSelectHaving, ChainSelectLimit, ChainSelectWhere, SqlSelectable, SqlStatementDataset, SqlTextStatementDataset } from "./query_chain_abstract.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>;
+}
+/** @public */
+export declare class Selection {
+    #private;
+    static from(selectable: Constructable<SqlSelectable | string>, as?: string): Selection;
+    constructor(selectable: Constructable<SqlSelectable | string>, as?: string);
+    toString(): string;
+    fullJoin(selectable: Constructable<SqlSelectable | string>, as: string | undefined, on: Constructable<ConditionParam>): Selection;
+    innerJoin(selectable: Constructable<SqlSelectable | string>, as: string | undefined, on: Constructable<ConditionParam>): Selection;
+    leftJoin(selectable: Constructable<SqlSelectable | string>, as: string | undefined, on: Constructable<ConditionParam>): Selection;
+    rightJoin(selectable: Constructable<SqlSelectable | string>, as: string | undefined, on: Constructable<ConditionParam>): Selection;
+    naturalJoin(selectable: Constructable<SqlSelectable | string>, as?: string | undefined): 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>;
+    /**
+     * 自定义SQL选择语句
+     * @example
+     * ```ts
+     * selection.select("t.age, count(*) AS c") // SELECT t.age,count(*) AS c FROM ...
+     * ```
+     */
+    select(columns: Constructable<SelectParam>): ChainSelectWhere<Record<string, any>>;
+    /**
+     * 通过 object 选择 列
+     * @example
+     * ```ts
+     * selection.select({"age":true, c:"count(*)"}) // SELECT age,count(*) AS c FROM ...
+     * ```
+     */
+    select<T extends TableType>(columns: Constructable<{
+        [key in keyof T]: string | boolean;
+    } | string>): ChainSelectWhere<T>;
+}
+//# sourceMappingURL=query_chain_select.d.ts.map

package/dist/sql_value/sql_value.d.ts

@@ -1,4 +1,4 @@
-import { SqlSelectable } from "../select/selectable.ts";
+import { SqlStatementDataset } from "../select/query_chain_abstract.ts";
 declare const SQL_RAW: unique symbol;
 /**
  * SQL 原始字符类。可以使用 String 类代替，这只是为了推断类型
@@ -96,7 +96,7 @@ export declare class SqlValuesCreator {
         sqlType: string;
         sqlDefault?: string;
         assertJsType?: AssertJsType;
-    }>): SqlSelectable<T>;
+    }>): SqlStatementDataset<T>;
 }
 /** @public */
 export type ColumnToValueConfig = {

package/package.json

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

package/dist/select/_update_impl.d.ts

@@ -1,19 +0,0 @@
-import { ConditionParam, Constructable } from "../util.ts";
-import { CurrentModifyWhere, CurrentOnConflict, CurrentOnConflictDo, CurrentReturn } from "./query_link.ts";
-import { SqlQueryStatement } from "./selectable.ts";
-import { ColumnsSelected, TableType } from "./type.ts";
-export declare class AfterUpdateOrReturn<T extends TableType = {}> extends SqlQueryStatement<{}> implements CurrentOnConflict<T>, CurrentModifyWhere<T> {
-    returning<R extends {}>(returns: Constructable<ColumnsSelected<any> | "*">): SqlQueryStatement<R>;
-    onConflict(onConflict: Constructable<readonly string[] | string>): CurrentOnConflictDo<T>;
-    where(where: Constructable<ConditionParam | void>): CurrentReturn<T>;
-}
-export declare class AfterInsert<T extends TableType = {}> implements CurrentOnConflictDo<T> {
-    #private;
-    constructor(sql: string);
-    doUpdate(set?: Constructable<string | {
-        [key: string]: string | undefined;
-    }>): CurrentModifyWhere<T>;
-    doNotThing(): CurrentReturn<T>;
-    toString(): string;
-}
-//# sourceMappingURL=_update_impl.d.ts.map

package/dist/select/query_link.d.ts

@@ -1,84 +0,0 @@
-import { SqlSelectable, SqlQueryStatement } from "./selectable.ts";
-import { OrderByParam, ConditionParam, SelectParam, Constructable } from "../util.ts";
-import type { ColumnsSelected, SelectColumns, TableType } from "./type.ts";
-/** @public */
-export interface CurrentLimit<T extends TableType> extends SqlQueryStatement<T> {
-    limit(limit?: number | bigint, offset?: number | bigint): SqlQueryStatement<T>;
-}
-/** @public */
-export interface CurrentOrderBy<T extends TableType> extends CurrentLimit<T> {
-    orderBy(param: Constructable<OrderByParam | void>): CurrentLimit<T>;
-}
-/** @public */
-export interface CurrentHaving<T extends TableType> extends CurrentOrderBy<T> {
-    having(param: Constructable<ConditionParam | void>): CurrentLimit<T>;
-}
-/** @public */
-export interface CurrentGroupBy<T extends TableType> extends CurrentOrderBy<T> {
-    groupBy(columns: string | string[]): CurrentHaving<T>;
-}
-/** @public */
-export interface CurrentWhere<T extends TableType> extends CurrentGroupBy<T> {
-    where(param: Constructable<ConditionParam | void>): CurrentGroupBy<T>;
-}
-/** @public */
-export declare class Selection {
-    #private;
-    static from(selectable: Constructable<SqlSelectable<any> | string>, as?: string): Selection;
-    constructor(selectable: Constructable<SqlSelectable<any> | string>, as?: string);
-    toString(): string;
-    fullJoin(selectable: Constructable<SqlSelectable<any> | string>, as: string | undefined, on: Constructable<ConditionParam>): Selection;
-    innerJoin(selectable: Constructable<SqlSelectable<any> | string>, as: string | undefined, on: Constructable<ConditionParam>): Selection;
-    leftJoin(selectable: Constructable<SqlSelectable<any> | string>, as: string | undefined, on: Constructable<ConditionParam>): Selection;
-    rightJoin(selectable: Constructable<SqlSelectable<any> | string>, as: string | undefined, on: Constructable<ConditionParam>): Selection;
-    naturalJoin(selectable: Constructable<SqlSelectable<any> | string>, as?: string | undefined): Selection;
-    crossJoin(selectable: Constructable<SqlSelectable<any> | string>, as?: string | undefined): Selection;
-    from(selectable: Constructable<SqlSelectable<any> | string>, as?: string): Selection;
-    /** 选择全部列 */
-    select<T extends TableType = TableType>(columns: "*"): CurrentWhere<T>;
-    /**
-     * 自定义SQL选择语句
-     * @example
-     * ```ts
-     * selection.select("t.age, count(*) AS c") // SELECT t.age,count(*) AS c FROM ...
-     * ```
-     */
-    select<T extends TableType = TableType>(columns: Constructable<string>): CurrentWhere<T>;
-    /**
-     * 通过 object 选择 列
-     * @example
-     * ```ts
-     * selection.select({"age":true, c:"count(*)"}) // SELECT age,count(*) AS c FROM ...
-     * ```
-     */
-    select<T extends TableType>(columns: Constructable<{
-        [key in keyof T]: string | boolean;
-    }>): CurrentWhere<T>;
-    select<R extends {}>(columns: Constructable<SelectParam>): CurrentWhere<R>;
-}
-/** @public */
-export interface CurrentReturn<T extends TableType = {}> extends SqlQueryStatement<{}> {
-    returning(columns: "*"): SqlQueryStatement<T>;
-    returning<R extends ColumnsSelected<T>>(columns: Constructable<R>): SqlQueryStatement<SelectColumns<T, R>>;
-    returning<R extends TableType>(columns: Constructable<R | string>): SqlQueryStatement<T>;
-}
-/** @public */
-export type CurrentModifyWhere<T extends TableType = {}> = CurrentReturn<T> & {
-    where(where: Constructable<ConditionParam | void>): CurrentReturn<T>;
-};
-/** @public */
-export type CurrentOnConflictDo<T extends TableType = {}> = {
-    doNotThing(): CurrentReturn<T>;
-    /**
-     * 需要注意 SQL 注入
-     */
-    doUpdate(set: Constructable<{
-        [key in keyof T]?: string;
-    }>): CurrentModifyWhere<T>;
-    toString(): string;
-};
-/** @public */
-export type CurrentOnConflict<T extends TableType = {}> = CurrentReturn<T> & {
-    onConflict(option: Constructable<readonly (keyof T)[] | string>): CurrentOnConflictDo<T>;
-};
-//# sourceMappingURL=query_link.d.ts.map

package/dist/select/selectable.d.ts

@@ -1,41 +0,0 @@
-import { TableType } from "./type.ts";
-declare const SQL_SELECTABLE: unique symbol;
-/**
- * 可选择项。可以是 table、查询结果等，它能被 select 语句选择
- * @example
- * ```ts
- * declare const item: SqlSelectable<any>
- * await query(`select * from ${item.toSelect()}`)
- *
- * ```
- * @public
- */
-export declare abstract class SqlSelectable<T extends TableType> {
-    /**
-     * 转成子选择语句, 你可以使用 select form xxx 选择
-     * 如果是 table 则是 table name
-     * 如果是 选择语句，则是 (xxx)
-     */
-    abstract toSelect(): string;
-    /** 获取 SQL 语句 */
-    abstract toString(): string;
-    /** 保留以推断类型 */
-    protected [SQL_SELECTABLE]: T;
-}
-/**
- * SELECT 以及 UPDATE、DELETE、INSERT INTO 带结果的 SQL 语句
- * @public
- */
-export declare class SqlQueryStatement<T extends TableType = TableType> extends SqlSelectable<T> {
-    #private;
-    constructor(sql: string | SqlQueryStatement);
-    toString(): string;
-    toSelect(): string;
-}
-/**
- * 推断查询结果的类型
- * @public
- */
-export type InferQueryResult<T> = T extends SqlSelectable<infer P> ? (P extends TableType ? P : never) : never;
-export {};
-//# sourceMappingURL=selectable.d.ts.map