@asla/yoursql 0.3.1 → 0.4.0

package/dist/mod.js

@@ -54,7 +54,91 @@ function getObjectListKeys(objectList, keepUndefinedKey) {
     }
     return Array.from(keys);
 }
+/** @public */
+function genWhere(where, type = "AND") {
+    return genWhereHaving(where, "WHERE", type);
+}
+/** @public */
+function genHaving(having, type = "AND") {
+    return genWhereHaving(having, "HAVING", type);
+}
+/**
+ * @public
+ * ```ts
+ * genSelect({c1: true, c2: "count(*)", c3: "column"})  //  "c1,count(*) AS c2,column as c3"
+ * genSelect(["c1", "count(*) AS c2", "column as c3"])  //  "c1,count(*) AS c2,column as c3"
+ * ```
+ */
+function genSelect(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;
+}
+/** @public */
+function genOderBy(orderBy) {
+    if (typeof orderBy === "function")
+        orderBy = orderBy();
+    let sql = "";
+    if (typeof orderBy === "string")
+        sql += "\nORDER BY " + orderBy;
+    else if (orderBy instanceof Array) {
+        if (orderBy.length)
+            sql += "\nORDER BY " + orderBy.join(",");
+    }
+    else {
+        let keys = Object.keys(orderBy);
+        if (keys.length)
+            sql += "\nORDER BY " + keys[0] + " " + orderBy[keys[0]];
+        for (let i = 1; i < keys.length; i++) {
+            sql += "," + orderBy[keys[i]] + " " + orderBy[keys[i]];
+        }
+    }
+    return sql;
+}
+function genWhereHaving(where, statement, type = "AND") {
+    if (typeof where === "function")
+        where = where();
+    type = " " + type + " ";
+    let sql = "";
+    if (typeof where === "string")
+        sql += "\n" + statement + " " + where;
+    else {
+        if (where.length)
+            sql += "\n" + statement + " " + +where[0];
+        for (let i = 1; i < where.length; i++)
+            sql += type + where[i];
+    }
+    return sql;
+}
 
+var _SqlQueryStatement_sql;
 /**
  * 可选择项。可以是 table、查询结果等，它能被 select 语句选择
  * @example
@@ -116,16 +200,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;
 /**
@@ -394,35 +484,98 @@ 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 _SelectImpl_instances, _a, _SelectImpl_join;
+class FinalSelectImpl extends SqlQueryStatement {
+    constructor(statement) {
+        super(statement);
     }
-    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;
+    filter(option) {
+        let { orderBy } = option;
+        let sql = this.toString();
+        if (orderBy)
+            sql += genOderBy(orderBy);
+        if (option.limit)
+            sql += "\nLIMIT " + option.limit;
+        if (option.offset)
+            sql += "\nOFFSET " + option.offset;
+        return new SqlQueryStatement(sql, Array.from(this.columns));
     }
+}
+/** @public */
+function createSelect(selectable, as) {
+    return new SelectImpl("FROM " + fromAs(selectable, as));
+}
+function fromAs(selectable, as) {
+    let sql = typeof selectable === "string" ? selectable : selectable.toSelect();
+    if (as)
+        sql += " AS " + as;
     return sql;
 }
+class SelectImpl {
+    constructor(str) {
+        _SelectImpl_instances.add(this);
+        this.str = str;
+    }
+    toString() {
+        return this.str;
+    }
+    fullJoin(selectable, as, on) {
+        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "FULL JOIN", selectable, as, on);
+    }
+    innerJoin(selectable, as, on) {
+        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "INNER JOIN", selectable, as, on);
+    }
+    leftJoin(selectable, as, on) {
+        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "LEFT JOIN", selectable, as, on);
+    }
+    rightJoin(selectable, as, on) {
+        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "RIGHT JOIN", selectable, as, on);
+    }
+    naturalJoin(selectable, as) {
+        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "NATURAL JOIN", selectable, as);
+    }
+    crossJoin(selectable, as) {
+        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "CROSS JOIN", selectable, as);
+    }
+    from(selectable, as) {
+        return new _a(this.str + "," + fromAs(selectable, as));
+    }
+    select(columnsIn) {
+        let sql = "SELECT ";
+        let columns = [];
+        if (typeof columnsIn === "string")
+            sql += columnsIn;
+        else {
+            sql += genSelect(columnsIn);
+            if (columnsIn instanceof Array) ;
+            else
+                columns = Object.keys(columnsIn);
+        }
+        sql += "\n" + this.str;
+        return new FinalSelectImpl(new SqlQueryStatement(sql, columns));
+    }
+    groupBy(columns) {
+        let sql = this.str;
+        if (typeof columns === "string")
+            sql += " GROUP BY " + columns;
+        else
+            sql += " GROUP BY " + columns.join(",");
+        return new _a(sql);
+    }
+    having(param) {
+        return new _a(this.str + genWhere(param));
+    }
+    where(param) {
+        return new _a(this.str + genWhere(param));
+    }
+}
+_a = SelectImpl, _SelectImpl_instances = new WeakSet(), _SelectImpl_join = function _SelectImpl_join(type, selectable, as, on) {
+    let sql = this.str + "\n" + type + " " + fromAs(selectable, as);
+    if (on)
+        sql += " ON " + on;
+    return new _a(sql);
+};
+
 function selectColumnsOrTable(columns) {
     let sqlSelect;
     let select;
@@ -450,226 +603,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 +610,8 @@ class DbTableQuery extends DbTable {
         super(name, columns);
         this.statement = statement;
     }
-    select(columns, option) {
-        return createSelect(this, columns, option);
+    fromAs(as) {
+        return createSelect(this, as);
     }
     insert(values, option) {
         let insertCol;
@@ -765,9 +698,6 @@ function genRetuningSql(sql, returns, tableColumns) {
     sql += "\nRETURNING " + columnsStr;
     return new SqlQueryStatement(sql, columns);
 }
-function genWhere(where) {
-    return "\nWHERE " + where;
-}
 
 /**
  * 表格列的信息
@@ -940,4 +870,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, SqlQueryStatement, SqlRaw, SqlSelectable, SqlValuesCreator, TypeChecker, YourTable, YourTypeMap, createSelect, genHaving, genOderBy, genSelect, genWhere, getObjectListKeys, pgSqlTransformer };

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 { JoinSelect } 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): JoinSelect;
     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,44 @@
-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;
+    orderBy?: string | OrderByParam<T> | (() => string | OrderByParam<T>);
     offset?: number;
     limit?: number;
 }
 /** @public */
 export interface FinalSelect<T extends TableType> extends SqlSelectable<T> {
-    toQuery(option?: SelectFilterOption<T & {
-        [key: string]: OrderValue;
-    }>): SqlQueryStatement<T>;
+    filter(option: SelectFilterOption<T>): SqlQueryStatement<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 type LastSelect = {
+    select<T extends TableType = TableType>(columns: "*" | string[] | {
+        [key in keyof T]: string | boolean;
+    }): FinalSelect<T>;
+};
 /** @public */
-export interface Select<T extends TableType> extends JoinSelect<T> {
-    /** 选择表 */
-    select: AddTableFn<T>;
-}
+export type AfterGroup = LastSelect & {
+    having(param: WhereParam | (() => WhereParam)): LastSelect;
+};
+/** @public */
+export type AfterWhere = AfterGroup & {
+    groupBy(columns: string | string[]): AfterGroup;
+};
 /** @public */
-export declare const createSelect: AddTableFn<{}>;
+export type AfterJoin = AfterWhere & {
+    where(param: WhereParam | (() => WhereParam)): AfterWhere;
+};
 /** @public */
-export interface SelectTableOption {
-    tableAs?: string;
+export interface JoinSelect extends AfterJoin {
+    from(selectable: SqlSelectable<any> | string, as?: string): JoinSelect;
+    crossJoin(selectable: SqlSelectable<any> | string, as?: string): JoinSelect;
+    naturalJoin(selectable: SqlSelectable<any> | string, as?: string): JoinSelect;
+    innerJoin(selectable: SqlSelectable<any> | string, as: string | undefined, on: string): JoinSelect;
+    leftJoin(selectable: SqlSelectable<any> | string, as: string | undefined, on: string): JoinSelect;
+    rightJoin(selectable: SqlSelectable<any> | string, as: string | undefined, on: string): JoinSelect;
+    fullJoin(selectable: SqlSelectable<any> | string, as: string | undefined, on: string): JoinSelect;
 }
-export {};
+/** @public */
+export declare function createSelect(selectable: SqlSelectable<any> | string, as?: string): JoinSelect;
 //# 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,27 @@
+import { OrderValue } from "./select/type.ts";
 /**
  * @public
  * @param keepUndefinedKey - 是否保留值为 undefined 的 key
  */
 export declare function getObjectListKeys(objectList: any[], keepUndefinedKey?: boolean): string[];
+/** @public */
+export type WhereParam = string | string[];
+/** @public */
+export declare function genWhere(where: WhereParam | (() => WhereParam), type?: "AND" | "OR"): string;
+/** @public */
+export declare function genHaving(having: WhereParam | (() => WhereParam), type?: "AND" | "OR"): string;
+/**
+ * @public
+ * ```ts
+ * genSelect({c1: true, c2: "count(*)", c3: "column"})  //  "c1,count(*) AS c2,column as c3"
+ * genSelect(["c1", "count(*) AS c2", "column as c3"])  //  "c1,count(*) AS c2,column as c3"
+ * ```
+ */
+export declare function genSelect(columns: string[] | Record<string, string | boolean>): string;
+/** @public */
+export type OrderByParam<T extends {} = {}> = string | string[] | ({
+    [key in keyof T]: OrderValue;
+} & Record<string, OrderValue>);
+/** @public */
+export declare function genOderBy<T extends {} = {}>(orderBy: OrderByParam<T> | (() => OrderByParam<T>)): string;
 //# sourceMappingURL=util.d.ts.map

package/package.json

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