@asla/yoursql 0.7.1 → 0.8.1

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

@@ -33,33 +33,6 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-function selectColumnsOrTable(columns) {
-    let sqlSelect;
-    let select;
-    if (columns instanceof Array) {
-        sqlSelect = columns;
-        select = columns;
-    }
-    else {
-        sqlSelect = [];
-        select = [];
-        let c;
-        for (const key of Object.keys(columns)) {
-            c = columns[key];
-            if (typeof c === "string" && c !== key) {
-                sqlSelect.push(key + " AS " + c);
-                select.push(c);
-            }
-            else if (c) {
-                sqlSelect.push(key);
-                select.push(key);
-            }
-        }
-    }
-    if (select.length === 0)
-        throw new Error("选择列为空");
-    return { columns: select, sqlColumns: sqlSelect.join(", ") };
-}
 function condition(conditions, type = "AND") {
     if (typeof conditions === "function")
         conditions = conditions();
@@ -186,26 +159,33 @@ function selectColumns(columns) {
         case "string":
             return columns;
         case "object": {
-            let sql = "";
-            const keys = Object.keys(columns);
-            if (keys.length === 0)
-                throw new Error("没有选择任何列");
-            let k = keys[0];
-            let v = columns[k];
-            if (typeof v === "string")
-                sql += v + " AS " + k;
-            else
-                sql += k;
-            for (let i = 1; i < keys.length; i++) {
-                k = keys[i];
-                v = columns[k];
-                sql += ",";
+            if (columns instanceof Array) {
+                if (columns.length === 0)
+                    throw new Error("没有选择任何列");
+                return columns.join(",");
+            }
+            else {
+                let sql = "";
+                const keys = Object.keys(columns);
+                if (keys.length === 0)
+                    throw new Error("没有选择任何列");
+                let k = keys[0];
+                let v = columns[k];
                 if (typeof v === "string")
                     sql += v + " AS " + k;
                 else
                     sql += k;
+                for (let i = 1; i < keys.length; i++) {
+                    k = keys[i];
+                    v = columns[k];
+                    sql += ",";
+                    if (typeof v === "string")
+                        sql += v + " AS " + k;
+                    else
+                        sql += k;
+                }
+                return sql;
             }
-            return sql;
         }
         default:
             throw new TypeError("columns 应为 string 或 object 类型");
@@ -275,37 +255,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 +541,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 +619,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 +632,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 +657,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 +707,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 +718,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();
@@ -755,11 +731,10 @@ class AfterUpdateOrReturn extends SqlQueryStatement {
             columnsStr = "*";
         }
         else {
-            const res = selectColumnsOrTable(returns);
-            columnsStr = res.sqlColumns;
+            columnsStr = selectColumns(returns);
         }
         let sql = this.toString() + "\nRETURNING " + columnsStr;
-        return new SqlQueryStatement(sql);
+        return new SqlTextStatementDataset(sql);
     }
     onConflict(onConflict) {
         if (typeof onConflict === "function")
@@ -767,22 +742,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 +768,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 +804,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 +820,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 +831,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 +868,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 +896,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 +1078,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,23 +1,23 @@
-import { SqlSelectable } from "./selectable.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): CurrentWhere<Record<string, any>>;
+    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>;
+    } | string>, as?: string): ChainSelectWhere<R>;
     /**
      * INSERT 语句，需要注意 SQL 注入
      * @example
@@ -25,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
@@ -36,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/_statement.d.ts

@@ -1,8 +1,4 @@
 import { Constructable } from "../util.ts";
-export declare function selectColumnsOrTable(columns: Record<string, boolean | string> | string[]): {
-    columns: string[];
-    sqlColumns: string;
-};
 type ConditionParam = string | string[];
 /**
  * 生成条件语句

package/dist/select/query_chain_abstract.d.ts

@@ -0,0 +1,91 @@
+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

package/dist/select/query_chain_insert.d.ts

@@ -0,0 +1,20 @@
+import { ConditionParam, Constructable, SelectParam } from "../util.ts";
+import { SqlStatementDataset, SqlStatement, ChainModifyWhere, ChainOnConflict, ChainConflictDo, ChainModifyReturning } from "./query_chain_abstract.ts";
+import { 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<SelectParam | "*">): 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/select/type.d.ts

@@ -20,26 +20,8 @@ export type UpdateRowValue<T extends object> = {
 };
 /** @public */
 export type OrderValue = "ASC" | "DESC";
-/**
- * 表的选择参数
- * @public
- */
-export type ColumnsSelected<T extends TableType> = {
-    [key in keyof T]?: boolean | string;
-};
-/**
- * 从一个表格选择列，生成新的表格类型
- * @public
- */
-export type SelectColumns<T extends TableType, R extends ColumnsSelected<T>> = R extends {
-    [key in keyof T]?: boolean | string;
-} ? {
-    [key in keyof T as R[key] extends true ? key : StringOnly<R[key]>]: T[key];
-} : never;
-type StringOnly<T> = T extends string ? T : never;
 /** @public */
 export type TableType = {
     [key: string]: any;
 };
-export {};
 //# sourceMappingURL=type.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/dist/util.d.ts

@@ -30,7 +30,7 @@ export declare function where(conditions?: Constructable<ConditionParam | void>,
  */
 export declare function having(conditions?: Constructable<ConditionParam | void>, type?: "AND" | "OR"): string;
 /** @public */
-export type SelectParam = string | Record<string, string | boolean>;
+export type SelectParam = string | string[] | Record<string, string | boolean>;
 /**
  * @public
  * @example

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asla/yoursql",
-  "version": "0.7.1",
+  "version": "0.8.1",
   "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,83 +0,0 @@
-import { SqlSelectable, SqlQueryStatement } from "./selectable.ts";
-import { OrderByParam, ConditionParam, SelectParam, Constructable } from "../util.ts";
-import type { ColumnsSelected, 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 = Record<string, any>>(columns: "*"): CurrentWhere<T>;
-    /**
-     * 自定义SQL选择语句
-     * @example
-     * ```ts
-     * selection.select("t.age, count(*) AS c") // SELECT t.age,count(*) AS c FROM ...
-     * ```
-     */
-    select(columns: Constructable<SelectParam>): CurrentWhere<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>): CurrentWhere<T>;
-}
-/** @public */
-export interface CurrentReturn<T extends TableType = {}> extends SqlQueryStatement<{}> {
-    returning(columns: "*"): SqlQueryStatement<T>;
-    returning(columns: Constructable<ColumnsSelected<T> | string>): SqlQueryStatement<Record<string, any>>;
-    returning<R extends TableType>(columns: Constructable<ColumnsSelected<R> | string>): SqlQueryStatement<R>;
-}
-/** @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<string | {
-        [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