@asla/yoursql 0.3.1 → 0.5.0

package/dist/mod.js

@@ -34,6 +34,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 };
 
 /**
+ * 获取对象数组中的 key 的集合
  * @public
  * @param keepUndefinedKey - 是否保留值为 undefined 的 key
  */
@@ -52,9 +53,146 @@ function getObjectListKeys(objectList, keepUndefinedKey) {
             keys.add(k);
         }
     }
-    return Array.from(keys);
+    return keys;
+}
+/**
+ * 生成 WHERE 语句
+ * @public
+ * ```ts
+ *
+ * ```
+ */
+function where(condition, type = "AND") {
+    if (!condition)
+        return "";
+    return genCondition(condition, "WHERE", type);
+}
+/**
+ *
+ * 生成 HAVING 语句
+ * @public
+ */
+function having(condition, type = "AND") {
+    if (!condition)
+        return "";
+    return genCondition(condition, "HAVING", type);
+}
+function genCondition(condition, statement, type = "AND") {
+    if (typeof condition === "function")
+        condition = condition();
+    type = " " + type + " ";
+    let sql = "";
+    if (typeof condition === "string")
+        sql += "\n" + statement + " " + condition;
+    else {
+        if (condition.length)
+            sql += "\n" + statement + " " + condition[0];
+        for (let i = 1; i < condition.length; i++)
+            sql += type + condition[i];
+    }
+    return sql;
+}
+/**
+ * @public
+ * ```ts
+ * selectColumns({c1: true, c2: "count(*)", c3: "column"})  //  "c1,count(*) AS c2,column as c3"
+ * selectColumns(["c1", "count(*) AS c2", "column as c3"])  //  "c1,count(*) AS c2,column as c3"
+ * ```
+ */
+function selectColumns(columns) {
+    let sql = "";
+    if (columns instanceof Array) {
+        if (columns.length)
+            sql += columns[0];
+        else
+            throw new Error("没有选择任何列");
+        for (let i = 1; i < columns.length; i++)
+            sql += "," + columns[i];
+    }
+    else {
+        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;
+}
+/**
+ * 生成 ORDER BY 语句, d
+ * @public
+ * ```ts
+ * // 以下生成 "\nORDER BY age DESC NULLS FIRST,num ASC"
+ * orderBy("age DESC NULLS FIRST,num ASC");
+ * orderBy(["age DESC NULLS FIRST", "num ASC"]);
+ * orderBy([
+ *    { key: "age", asc: false, nullLast: false },
+ *    { key: "num", asc: true },
+ *  ]);
+ * orderBy({ age: "DESC NULLS FIRST", num: true });
+ *
+ * orderBy([]) // ""
+ * orderBy({}) // ""
+ * ```
+ */
+function orderBy(by) {
+    if (typeof by === "function")
+        by = by();
+    let sql = "";
+    if (typeof by === "string") {
+        if (!by)
+            return sql;
+        sql += "\nORDER BY " + by;
+    }
+    else if (by instanceof Array) {
+        if (by.length) {
+            sql += "\nORDER BY " + handlerOrderValue(by[0]);
+            for (let i = 1; i < by.length; i++)
+                sql += "," + handlerOrderValue(by[i]);
+        }
+    }
+    else {
+        let keys = Object.keys(by);
+        if (keys.length) {
+            let key = keys[0];
+            sql += "\nORDER BY " + key + " " + by[key];
+            for (let i = 1; i < keys.length; i++) {
+                key = keys[i];
+                sql += "," + key + " ";
+                if (typeof by[key] === "string")
+                    sql += by[key];
+                else
+                    sql += by[key] ? "ASC" : "DESC";
+            }
+        }
+    }
+    return sql;
+}
+function handlerOrderValue(value) {
+    if (typeof value === "string")
+        return value;
+    else {
+        let str = value.key + " " + (value.asc ? "ASC" : "DESC");
+        if (value.nullLast !== undefined)
+            str += value.nullLast ? " NULLS LAST" : " NULLS FIRST";
+        return str;
+    }
 }
 
+var _SqlQueryStatement_sql;
 /**
  * 可选择项。可以是 table、查询结果等，它能被 select 语句选择
  * @example
@@ -116,16 +254,22 @@ class DbTable extends SqlSelectable {
  */
 class SqlQueryStatement extends SqlSelectable {
     constructor(sql, columns) {
+        if (sql instanceof SqlQueryStatement) {
+            columns = sql.columns;
+            sql = __classPrivateFieldGet(sql, _SqlQueryStatement_sql, "f");
+        }
         super(columns);
-        this.sql = sql;
+        _SqlQueryStatement_sql.set(this, void 0);
+        __classPrivateFieldSet(this, _SqlQueryStatement_sql, sql, "f");
     }
     toString() {
-        return this.sql;
+        return __classPrivateFieldGet(this, _SqlQueryStatement_sql, "f");
     }
     toSelect() {
         return "(" + this.toString() + ")";
     }
 }
+_SqlQueryStatement_sql = new WeakMap();
 
 var _SqlRaw_value, _YourValuesAs_asName, _YourValuesAs_valuesStr, _YourValuesAs_sql;
 /**
@@ -229,7 +373,7 @@ class SqlValuesCreator {
             throw new Error("objectList 不能是空数组");
         let keys;
         if (!keys_types) {
-            keys = getObjectListKeys(objectList, keepUndefinedKey);
+            keys = Array.from(getObjectListKeys(objectList, keepUndefinedKey));
         }
         else if (keys_types instanceof Array) {
             keys = keys_types;
@@ -394,35 +538,99 @@ const pgSqlTransformer = new Map([
     [Date, (value) => SqlValuesCreator.string(value.toISOString())],
 ]);
 
-function genOderBy(orderBy, orderNullRule) {
-    let select = [];
-    let v;
-    for (const key of Object.keys(orderBy)) {
-        v = orderBy[key];
-        switch (v) {
-            case "ASC":
-                break;
-            case "DESC":
-                break;
-            default:
-                throw new Error("orderBy 只能是 ASE 或 DESC. 当前值：" + String(v));
-        }
-        select.push(key + " " + v);
+var _Selection_instances, _a, _Selection_sql, _Selection_join;
+class AfterSelectImpl extends SqlQueryStatement {
+    constructor(sql, columns) {
+        super(sql, columns);
     }
-    let sql = "\nORDER BY " + select.join(", ");
-    if (orderNullRule) {
-        switch (orderNullRule) {
-            case "FIRST":
-                break;
-            case "LAST":
-                break;
-            default:
-                throw new Error("orderNullRule 只能是 FIRST 或 LAST. 当前值：" + String(orderNullRule));
-        }
-        sql += "NULLS " + orderNullRule;
+    where(param) {
+        return new AfterSelectImpl(this.toString() + where(param), this.columns);
+    }
+    groupBy(columns) {
+        let sql = this.toString();
+        if (typeof columns === "string")
+            sql += " GROUP BY " + columns;
+        else
+            sql += " GROUP BY " + columns.join(",");
+        return new AfterSelectImpl(sql, this.columns);
+    }
+    having(param) {
+        return new AfterSelectImpl(this.toString() + having(param), this.columns);
     }
+    orderBy(param) {
+        return new AfterSelectImpl(this.toString() + orderBy(param), this.columns);
+    }
+    limit(limit, offset) {
+        let sql = this.toString();
+        if (limit)
+            sql += "\nLIMIT " + limit;
+        if (offset)
+            sql += "\nOFFSET " + offset;
+        return new SqlQueryStatement(sql, Array.from(this.columns));
+    }
+}
+function fromAs(selectable, as) {
+    let sql = typeof selectable === "string" ? selectable : selectable.toSelect();
+    if (as)
+        sql += " AS " + as;
     return sql;
 }
+/** @public */
+class Selection {
+    static from(selectable, as) {
+        return new this(selectable, as);
+    }
+    constructor(selectable, as) {
+        _Selection_instances.add(this);
+        _Selection_sql.set(this, void 0);
+        __classPrivateFieldSet(this, _Selection_sql, fromAs(selectable, as), "f");
+    }
+    toString() {
+        return "FROM " + __classPrivateFieldGet(this, _Selection_sql, "f");
+    }
+    fullJoin(selectable, as, on) {
+        return __classPrivateFieldGet(this, _Selection_instances, "m", _Selection_join).call(this, "FULL JOIN", selectable, as, on);
+    }
+    innerJoin(selectable, as, on) {
+        return __classPrivateFieldGet(this, _Selection_instances, "m", _Selection_join).call(this, "INNER JOIN", selectable, as, on);
+    }
+    leftJoin(selectable, as, on) {
+        return __classPrivateFieldGet(this, _Selection_instances, "m", _Selection_join).call(this, "LEFT JOIN", selectable, as, on);
+    }
+    rightJoin(selectable, as, on) {
+        return __classPrivateFieldGet(this, _Selection_instances, "m", _Selection_join).call(this, "RIGHT JOIN", selectable, as, on);
+    }
+    naturalJoin(selectable, as) {
+        return __classPrivateFieldGet(this, _Selection_instances, "m", _Selection_join).call(this, "NATURAL JOIN", selectable, as);
+    }
+    crossJoin(selectable, as) {
+        return __classPrivateFieldGet(this, _Selection_instances, "m", _Selection_join).call(this, "CROSS JOIN", selectable, as);
+    }
+    from(selectable, as) {
+        return new _a(__classPrivateFieldGet(this, _Selection_sql, "f") + "," + fromAs(selectable, as));
+    }
+    select(columnsIn) {
+        let sql = "SELECT ";
+        let columns = [];
+        if (typeof columnsIn === "string")
+            sql += columnsIn;
+        else {
+            sql += selectColumns(columnsIn);
+            if (columnsIn instanceof Array) ;
+            else
+                columns = Object.keys(columnsIn);
+        }
+        sql += "\n" + this.toString();
+        return new AfterSelectImpl(sql, columns);
+    }
+}
+_a = Selection, _Selection_sql = new WeakMap(), _Selection_instances = new WeakSet(), _Selection_join = function _Selection_join(type, selectable, as, on) {
+    let sql = __classPrivateFieldGet(this, _Selection_sql, "f") + "\n" + type + " " + fromAs(selectable, as);
+    if (on)
+        sql += " ON " + on;
+    return new _a(sql);
+};
+
 function selectColumnsOrTable(columns) {
     let sqlSelect;
     let select;
@@ -450,226 +658,6 @@ function selectColumnsOrTable(columns) {
         throw new Error("选择列为空");
     return { columns: select, sqlColumns: sqlSelect.join(", ") };
 }
-/**
- * @param select  选择的行
- * @param tableColumns 全部行
- * @param push 要讲选择的行加入到集合中。
- */
-function genNewColumns(select, tableColumns, 
-/** newName -> oldName */
-push = new Map()) {
-    if (select === "*") {
-        for (const key of tableColumns) {
-            if (push.has(key))
-                throw new ColumnRepeatError(key);
-            push.set(key, null);
-        }
-    }
-    else {
-        genSelectAsColumns(select, push);
-    }
-    return push;
-}
-function genSelectAsColumns(select, 
-/** newName -> oldName */
-push = new Map()) {
-    if (select instanceof Array) {
-        for (const key of select) {
-            if (push.has(key))
-                throw new ColumnRepeatError(key);
-            push.set(key, null);
-        }
-    }
-    else {
-        let finalName;
-        for (const oldName of Object.keys(select)) {
-            if (typeof select[oldName] === "string")
-                finalName = select[oldName];
-            else if (select[oldName])
-                finalName = oldName;
-            else
-                continue;
-            if (push.has(finalName))
-                throw new ColumnRepeatError(finalName);
-            push.set(finalName, oldName);
-        }
-    }
-    return push;
-}
-class ColumnRepeatError extends Error {
-    constructor(columnName) {
-        super("Column name '" + columnName + "' repeated");
-    }
-}
-
-var _SelectImpl_instances, _a, _SelectImpl_joinOn, _SelectImpl_join;
-/** @public */
-const createSelect = function createSelect(tb, columns, option) {
-    let select = createSelectMap(tb, columns, option).selects;
-    return new SelectImpl(select);
-};
-function* mergeColumns(a, b) {
-    for (const { columns } of a)
-        yield* columns.keys();
-    yield* b;
-}
-class SelectImpl extends SqlSelectable {
-    constructor(tableList, addedColumns) {
-        super(addedColumns ? mergeColumns(tableList.values(), addedColumns.keys()) : tableList.keys());
-        _SelectImpl_instances.add(this);
-        this.tableList = tableList;
-        this.addedColumns = addedColumns;
-    }
-    toSelect() {
-        return "(" + this.toString() + ")";
-    }
-    toString() {
-        let tables = [];
-        let join = "";
-        let selectColumns = [];
-        const size = this.tableList.size;
-        for (const [tableAs, { columns, from, on, type }] of this.tableList) {
-            let tableStr = tableAs === from ? from : from + " AS " + tableAs;
-            if (type) {
-                join += "\n" + type + " " + tableStr;
-                if (on)
-                    join += " ON " + on;
-            }
-            else {
-                tables.push(tableStr);
-            }
-            if (size === 1 && tableAs === from) {
-                for (const [column, oldName] of columns) {
-                    if (!oldName || oldName == column)
-                        selectColumns.push(column);
-                    else
-                        selectColumns.push(oldName + " AS " + column);
-                }
-            }
-            else {
-                for (const [column, oldName] of columns) {
-                    if (!oldName || oldName === column)
-                        selectColumns.push(tableAs + "." + column);
-                    else
-                        selectColumns.push(tableAs + "." + oldName + " AS " + column);
-                }
-            }
-        }
-        if (this.addedColumns) {
-            for (const [asName, columnStr] of this.addedColumns) {
-                if (asName === columnStr)
-                    selectColumns.push(asName);
-                else
-                    selectColumns.push(columnStr + " AS " + asName);
-            }
-        }
-        if (selectColumns.length === 0)
-            throw new Error("Columns 为空");
-        let sql = `SELECT ${selectColumns.join(", ")}\nFROM ${tables.join(", ")}` + join;
-        return sql;
-    }
-    fullJoin(tb, columns, option) {
-        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_joinOn).call(this, "FULL JOIN", tb, columns, option);
-    }
-    innerJoin(tb, columns, option) {
-        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_joinOn).call(this, "INNER JOIN", tb, columns, option);
-    }
-    leftJoin(tb, columns, option) {
-        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_joinOn).call(this, "LEFT JOIN", tb, columns, option);
-    }
-    rightJoin(tb, columns, option) {
-        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_joinOn).call(this, "RIGHT JOIN", tb, columns, option);
-    }
-    naturalJoin(tb, columns, option) {
-        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "NATURAL JOIN", tb, columns, option);
-    }
-    crossJoin(tb, columns, option) {
-        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "CROSS JOIN", tb, columns, option);
-    }
-    select(tb, columns, option) {
-        let select = createSelectMap(tb, columns, option, this.tableList).selects;
-        const obj = new _a(select, new Map(this.addedColumns));
-        return obj;
-    }
-    addColumns(add) {
-        let addedColumns = this.addedColumns ? new Map(this.addedColumns) : new Map();
-        for (const [asNewName, columnStr] of Object.entries(add)) {
-            if (addedColumns.has(asNewName))
-                throw new Error(`The column ${asNewName} already exists`);
-            addedColumns.set(asNewName, columnStr);
-        }
-        return new _a(this.tableList, addedColumns);
-    }
-    toQuery(option = {}) {
-        const { where, orderNullRule } = option;
-        let sql = this.toString();
-        if (where)
-            sql += "\nWHERE " + where;
-        const orderBy = option.orderBy;
-        if (orderBy)
-            sql += genOderBy(orderBy, orderNullRule);
-        if (option.limit)
-            sql += "\nLIMIT " + option.limit;
-        if (option.offset)
-            sql += "\nOFFSET " + option.offset;
-        return new SqlQueryStatement(sql, Array.from(this.columns));
-    }
-}
-_a = SelectImpl, _SelectImpl_instances = new WeakSet(), _SelectImpl_joinOn = function _SelectImpl_joinOn(type, tb, columns, option) {
-    let { selects, tbInfo } = createSelectMap(tb, columns, option, this.tableList);
-    tbInfo.type = type;
-    tbInfo.on = option.on;
-    const next = new _a(selects, new Map(this.addedColumns));
-    Object.defineProperty(next, "select", { value: undefined, configurable: false, enumerable: false });
-    return next;
-}, _SelectImpl_join = function _SelectImpl_join(type, tb, columns, option) {
-    let { selects, tbInfo } = createSelectMap(tb, columns, option, this.tableList);
-    tbInfo.type = type;
-    const next = new _a(selects, new Map(this.addedColumns));
-    Object.defineProperty(next, "select", { value: undefined, configurable: false, enumerable: false });
-    return next;
-};
-function createSelectMap(tb, columns, option = {}, selects) {
-    let select = new Map(selects);
-    let tableAs;
-    let tbInfo;
-    if (typeof tb === "string") {
-        throw new Error("tb 应是 SqlSelectable 类型");
-        // if (typeof columns !== "object") throw new Error("缺少 option.columns");
-        // const newColumns = genSelectAsColumns(columns);
-        // tableAs = option.tableAs ?? tb;
-        // tbInfo = { table: tb, columns: newColumns };
-    }
-    else {
-        const from = tb.toSelect();
-        if (tb instanceof DbTable) {
-            tableAs = option.tableAs ?? from;
-        }
-        else {
-            tableAs = option.tableAs ?? "t" + select.size;
-        }
-        if (columns) {
-            const newColumns = genNewColumns(columns, tb.columns);
-            tbInfo = { from, columns: newColumns };
-        }
-        else
-            tbInfo = { from, columns: new Map() };
-    }
-    if (select.has(tableAs))
-        throw new TableRepeatError(tableAs);
-    select.set(tableAs, tbInfo);
-    return { selects: select, tbInfo: tbInfo };
-}
-class TableRepeatError extends Error {
-    constructor(tableName) {
-        super("Table name '" + tableName + "' repeated");
-    }
-}
-// interface SqlFrom<T extends object> {
-//   from<A extends object>(table: SqlSelectable<A>): SqlFrom<T & A>;
-// }
-// declare function from<T extends SqlSelectable<any>[]>(...table: T): Select<MergeSelectable<T>>;
-// type MergeSelectable<T extends any[]> = T extends [SqlSelectable<infer P>, ...infer Q] ? P & MergeSelectable<Q> : {};
 
 /** @public */
 class DbTableQuery extends DbTable {
@@ -677,8 +665,8 @@ class DbTableQuery extends DbTable {
         super(name, columns);
         this.statement = statement;
     }
-    select(columns, option) {
-        return createSelect(this, columns, option);
+    fromAs(as) {
+        return new Selection(this, as);
     }
     insert(values, option) {
         let insertCol;
@@ -686,7 +674,7 @@ class DbTableQuery extends DbTable {
         if (values instanceof Array) {
             if (values.length === 0)
                 throw new Error("值不能为空");
-            insertCol = getObjectListKeys(values);
+            insertCol = Array.from(getObjectListKeys(values));
             valuesStr = `VALUES\n${this.statement.objectListToValuesList(values, insertCol)}`;
         }
         else if (values instanceof SqlQueryStatement) {
@@ -720,7 +708,6 @@ class DbTableQuery extends DbTable {
         return genRetuningSql(sql, returns, values instanceof SqlQueryStatement ? values.columns : this.columns);
     }
     update(values, option = {}) {
-        const { where } = option;
         const updateKey = Object.entries(values);
         if (updateKey.length === 0)
             throw new Error("值不能为空");
@@ -731,8 +718,8 @@ class DbTableQuery extends DbTable {
             setList.push(k + " = " + this.statement.toSqlStr(v));
         }
         let sql = `UPDATE ${this.name}\nSET ${setList.join(",\n")}`;
-        if (where)
-            sql += genWhere(where);
+        if (option.where)
+            sql += where(option.where);
         return sql;
     }
     updateWithResult(values, returns, option) {
@@ -742,7 +729,7 @@ class DbTableQuery extends DbTable {
     delete(option = {}) {
         let sql = "DELETE FROM " + this.name;
         if (option.where)
-            sql += genWhere(option.where);
+            sql += where(option.where);
         return sql;
     }
     deleteWithResult(returns = "*", option) {
@@ -765,9 +752,6 @@ function genRetuningSql(sql, returns, tableColumns) {
     sql += "\nRETURNING " + columnsStr;
     return new SqlQueryStatement(sql, columns);
 }
-function genWhere(where) {
-    return "\nWHERE " + where;
-}
 
 /**
  * 表格列的信息
@@ -940,4 +924,4 @@ class YourTable extends DbTableQuery {
     }
 }
 
-export { ColumnMeta, CustomDbType, DbTable, DbTableQuery, SqlQueryStatement, SqlRaw, SqlSelectable, SqlValuesCreator, TypeChecker, YourTable, YourTypeMap, createSelect, getObjectListKeys, pgSqlTransformer };
+export { ColumnMeta, CustomDbType, DbTable, DbTableQuery, Selection, SqlQueryStatement, SqlRaw, SqlSelectable, SqlValuesCreator, TypeChecker, YourTable, YourTypeMap, getObjectListKeys, having, orderBy, pgSqlTransformer, selectColumns, where };

package/dist/select/TableQuery.d.ts

@@ -1,17 +1,13 @@
 import { SqlValuesCreator, SqlRaw } from "../sql_value/sql_value.ts";
-import { ColumnsSelected, ColumnsSelectAs, SelectColumns, UpdateRowValue, TableType } from "./type.ts";
-import { Select, SelectTableOption } from "./select.ts";
+import { ColumnsSelected, SelectColumns, UpdateRowValue, TableType } from "./type.ts";
+import { Selection } from "./select.ts";
 import { DbTable, SqlQueryStatement } from "./selectable.ts";
+import { WhereParam } from "../util.ts";
 /** @public */
 export declare class DbTableQuery<T extends TableType = Record<string, any>, C extends TableType = Partial<T>> extends DbTable<T> {
     private statement;
     constructor(name: string, columns: readonly string[], statement: SqlValuesCreator);
-    /** 选择全部列 */
-    select(columns?: undefined, option?: SelectTableOption): Select<{}>;
-    /** 选择全部列 */
-    select(columns: "*", option?: SelectTableOption): Select<T>;
-    /** 选择表中的列并重命名 */
-    select<R extends ColumnsSelectAs<T>>(columns: R, option?: SelectTableOption): Select<SelectColumns<T, R>>;
+    fromAs(as?: string): Selection;
     insert(values: C[] | SqlQueryStatement<C>, option?: InsertOption<T>): string;
     insertWithResult<R extends ColumnsSelected<T>>(values: C[] | SqlQueryStatement<C>, returns: R, option?: InsertOption<T>): SqlQueryStatement<SelectColumns<T, R>>;
     update(values: UpdateRowValue<T>, option?: UpdateOption): string;
@@ -25,14 +21,14 @@ export interface InsertOption<T extends object> {
     updateValues?: {
         [key in keyof T]?: undefined | SqlRaw | T[key];
     };
-    where?: string;
+    where?: WhereParam;
 }
 /** @public */
 export interface UpdateOption {
-    where?: string;
+    where?: WhereParam;
 }
 /** @public */
 export interface DeleteOption {
-    where?: string;
+    where?: WhereParam;
 }
 //# sourceMappingURL=TableQuery.d.ts.map

package/dist/select/_statement.d.ts

@@ -1,15 +1,6 @@
-import { ColumnsSelectAs, ColumnsSelected, RowsOrder } from "./type.ts";
-export declare function genOderBy(orderBy: RowsOrder<any>, orderNullRule?: "FIRST" | "LAST"): string;
+import { ColumnsSelectAs } from "./type.ts";
 export declare function selectColumnsOrTable(columns: ColumnsSelectAs<any> | string[]): {
     columns: string[];
     sqlColumns: string;
 };
-/**
- * @param select  选择的行
- * @param tableColumns 全部行
- * @param push 要讲选择的行加入到集合中。
- */
-export declare function genNewColumns(select: ColumnsSelected<any>, tableColumns: Iterable<string | number | symbol>, 
-/** newName -> oldName */
-push?: Map<string, string | null>): Map<string, string | null>;
 //# sourceMappingURL=_statement.d.ts.map

package/dist/select/select.d.ts

@@ -1,57 +1,43 @@
-import { SqlSelectable, InferQueryResult, SqlQueryStatement } from "./selectable.ts";
-import type { ColumnsSelected, OrderValue, RowsOrder, SelectColumns, TableType } from "./type.ts";
-interface AddTableFn<T extends TableType> {
-    <Q extends SqlSelectable<any>, A extends InferQueryResult<Q>>(tb: Q, columns?: undefined, option?: SelectTableOption): Select<T>;
-    <Q extends SqlSelectable<any>, A extends InferQueryResult<Q>, C extends ColumnsSelected<A>>(tb: Q, columns: C, option?: SelectTableOption): Select<T & SelectColumns<A, C>>;
-}
-interface JoinTableFn<T extends TableType, ExtraOption extends object = {}> {
-    <Q extends SqlSelectable<any>, A extends InferQueryResult<Q>>(tb: Q, columns: undefined, option: ExtraOption & SelectTableOption): JoinSelect<T>;
-    <Q extends SqlSelectable<any>, A extends InferQueryResult<Q>, C extends ColumnsSelected<A>>(tb: Q, columns: C, option: ExtraOption & SelectTableOption): JoinSelect<T & SelectColumns<A, C>>;
-}
+import { SqlSelectable, SqlQueryStatement } from "./selectable.ts";
+import { OrderByParam, WhereParam } from "../util.ts";
+import type { TableType } from "./type.ts";
 /** @public */
-export interface SelectFilterOption<T extends object> {
-    orderBy?: RowsOrder<T>;
-    orderNullRule?: "FIRST" | "LAST";
-    where?: string;
-    offset?: number;
-    limit?: number;
+export interface CurrentLimit<T extends TableType> extends SqlQueryStatement<T> {
+    limit(limit?: number, offset?: number): SqlQueryStatement<T>;
 }
 /** @public */
-export interface FinalSelect<T extends TableType> extends SqlSelectable<T> {
-    toQuery(option?: SelectFilterOption<T & {
-        [key: string]: OrderValue;
-    }>): SqlQueryStatement<T>;
+export interface CurrentOrderBy<T extends TableType> extends CurrentLimit<T> {
+    orderBy(param: OrderByParam): CurrentLimit<T>;
 }
 /** @public */
-export interface JoinSelect<T extends TableType> extends FinalSelect<T> {
-    addColumns<A extends TableType>(add: {
-        [key in keyof A]: string;
-    }): FinalSelect<T & A>;
-    crossJoin: JoinTableFn<T>;
-    naturalJoin: JoinTableFn<T>;
-    innerJoin: JoinTableFn<T, {
-        on: string;
-    }>;
-    leftJoin: JoinTableFn<T, {
-        on: string;
-    }>;
-    rightJoin: JoinTableFn<T, {
-        on: string;
-    }>;
-    fullJoin: JoinTableFn<T, {
-        on: string;
-    }>;
+export interface CurrentHaving<T extends TableType> extends CurrentOrderBy<T> {
+    having(param: WhereParam | (() => WhereParam)): CurrentLimit<T>;
 }
 /** @public */
-export interface Select<T extends TableType> extends JoinSelect<T> {
-    /** 选择表 */
-    select: AddTableFn<T>;
+export interface CurrentGroupBy<T extends TableType> extends CurrentOrderBy<T> {
+    groupBy(columns: string | string[]): CurrentHaving<T>;
 }
 /** @public */
-export declare const createSelect: AddTableFn<{}>;
+export interface CurrentWhere<T extends TableType> extends CurrentGroupBy<T> {
+    where(param: WhereParam | (() => WhereParam)): CurrentGroupBy<T>;
+}
 /** @public */
-export interface SelectTableOption {
-    tableAs?: string;
+export declare class Selection {
+    #private;
+    static from(selectable: SqlSelectable<any> | string, as?: string): Selection;
+    constructor(selectable: SqlSelectable<any> | string, as?: string);
+    toString(): string;
+    fullJoin(selectable: SqlSelectable<any>, as: string | undefined, on: string): Selection;
+    innerJoin(selectable: SqlSelectable<any>, as: string | undefined, on: string): Selection;
+    leftJoin(selectable: SqlSelectable<any>, as: string | undefined, on: string): Selection;
+    rightJoin(selectable: SqlSelectable<any>, as: string | undefined, on: string): Selection;
+    naturalJoin(selectable: SqlSelectable<any>, as?: string | undefined): Selection;
+    crossJoin(selectable: SqlSelectable<any>, as?: string | undefined): Selection;
+    from(selectable: SqlSelectable<any> | string, as?: string): Selection;
+    select<T extends TableType = TableType>(columns: "*" | string[]): CurrentWhere<T>;
+    select<T extends TableType = TableType>(columns: {
+        [key in keyof T]: string | boolean;
+    }): CurrentWhere<T>;
+    select<T extends TableType = TableType>(columns: "*" | string[] | TableType): CurrentWhere<T>;
 }
-export {};
 //# sourceMappingURL=select.d.ts.map

package/dist/select/selectable.d.ts

@@ -23,7 +23,7 @@ export declare abstract class SqlSelectable<T extends TableType> {
     /** 获取 SQL 语句 */
     abstract toString(): string;
     /** 保留以推断类型 */
-    private [SQL_SELECTABLE];
+    protected [SQL_SELECTABLE]: T;
 }
 /**
  * 数据库表
@@ -40,8 +40,9 @@ export declare class DbTable<T extends TableType> extends SqlSelectable<T> {
  * @public
  */
 export declare class SqlQueryStatement<T extends TableType = TableType> extends SqlSelectable<T> {
-    private sql;
+    #private;
     constructor(sql: string, columns: readonly string[]);
+    constructor(sql: SqlQueryStatement);
     toString(): string;
     toSelect(): string;
 }

package/dist/select/type.d.ts

@@ -14,13 +14,6 @@ export type PickColumn<T extends {
 } & {
     [key in Pa]?: T[key];
 };
-/**
- * 定义行的排序
- * @public
- */
-export type RowsOrder<T extends object> = {
-    [key in keyof T]?: OrderValue;
-};
 /** @public */
 export type UpdateRowValue<T extends object> = {
     [key in keyof T]?: T[key] | SqlRaw;

package/dist/sql_value/sql_value.d.ts

@@ -9,7 +9,7 @@ export declare class SqlRaw<T = any> {
     constructor(value: string);
     toString(): string;
     /** 保留以推断类型 */
-    private [SQL_RAW];
+    protected [SQL_RAW]: T;
 }
 /** @public */
 export type JsObjectMapSql = Map<new (...args: any[]) => any, SqlValueEncoder>;

package/dist/util.d.ts

@@ -1,6 +1,58 @@
+import { OrderValue } from "./select/type.ts";
 /**
+ * 获取对象数组中的 key 的集合
  * @public
  * @param keepUndefinedKey - 是否保留值为 undefined 的 key
  */
-export declare function getObjectListKeys(objectList: any[], keepUndefinedKey?: boolean): string[];
+export declare function getObjectListKeys(objectList: any[], keepUndefinedKey?: boolean): Set<string>;
+/** @public */
+export type WhereParam = string | string[];
+/**
+ * 生成 WHERE 语句
+ * @public
+ * ```ts
+ *
+ * ```
+ */
+export declare function where(condition?: WhereParam | (() => WhereParam), type?: "AND" | "OR"): string;
+/**
+ *
+ * 生成 HAVING 语句
+ * @public
+ */
+export declare function having(condition?: WhereParam | (() => WhereParam), type?: "AND" | "OR"): string;
+/**
+ * @public
+ * ```ts
+ * selectColumns({c1: true, c2: "count(*)", c3: "column"})  //  "c1,count(*) AS c2,column as c3"
+ * selectColumns(["c1", "count(*) AS c2", "column as c3"])  //  "c1,count(*) AS c2,column as c3"
+ * ```
+ */
+export declare function selectColumns(columns: string[] | Record<string, string | boolean>): string;
+/** @public */
+export type OrderBehavior = {
+    key: string;
+    asc: boolean;
+    nullLast?: boolean;
+};
+/** @public */
+export type OrderByParam = string | (string | OrderBehavior)[] | Record<string, boolean | `${OrderValue} ${"NULLS FIRST" | "NULLS LAST"}`>;
+/**
+ * 生成 ORDER BY 语句, d
+ * @public
+ * ```ts
+ * // 以下生成 "\nORDER BY age DESC NULLS FIRST,num ASC"
+ * orderBy("age DESC NULLS FIRST,num ASC");
+ * orderBy(["age DESC NULLS FIRST", "num ASC"]);
+ * orderBy([
+ *    { key: "age", asc: false, nullLast: false },
+ *    { key: "num", asc: true },
+ *  ]);
+ * orderBy({ age: "DESC NULLS FIRST", num: true });
+ *
+ * orderBy([]) // ""
+ * orderBy({}) // ""
+ * ```
+ */
+export declare function orderBy(by: OrderByParam | (() => OrderByParam)): string;
 //# sourceMappingURL=util.d.ts.map

package/package.json

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