@asla/yoursql 0.5.1 → 0.6.0

package/dist/mod.js

@@ -33,6 +33,53 @@ 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();
+    if (!conditions)
+        return;
+    if (typeof conditions === "string")
+        return conditions;
+    else {
+        if (conditions.length) {
+            let sql = "";
+            type = " " + type + " ";
+            sql += conditions[0];
+            for (let i = 1; i < conditions.length; i++)
+                sql += type + conditions[i];
+            return sql;
+        }
+        return;
+    }
+}
+
 /**
  * 获取对象数组中的 key 的集合
  * @public
@@ -58,8 +105,14 @@ function getObjectListKeys(objectList, keepUndefinedKey) {
 /**
  * 生成 WHERE 语句
  * @public
+ * @example
  * ```ts
- *
+ * where(['a=1','b=2']) // "\nWHERE a=1 AND b=2"
+ * where(['a=1','b=2'],"OR") // "\nWHERE a=1 OR b=2"
+ * where("a=1 OR b=2") // "\nWHERE a=1 OR b=2"
+ * where(()=>"a=1 OR b=2") // "\nWHERE a=1 AND b=2"
+ * where([]) // ""
+ * where(undefined) // ""
  * ```
  */
 function where(conditions, type) {
@@ -79,67 +132,50 @@ function having(conditions, type) {
         return "\nHAVING " + sql;
     return "";
 }
-function condition(conditions, type = "AND") {
-    if (typeof conditions === "function")
-        conditions = conditions();
-    if (!conditions)
-        return;
-    if (typeof conditions === "string")
-        return conditions;
-    else {
-        if (conditions.length) {
-            let sql = "";
-            type = " " + type + " ";
-            sql += conditions[0];
-            for (let i = 1; i < conditions.length; i++)
-                sql += type + conditions[i];
-            return sql;
-        }
-        return;
-    }
-}
 /**
  * @public
+ * @example
  * ```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"
+ * 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 columns === "function")
+        columns = columns();
+    switch (typeof 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 (typeof v === "string")
+                    sql += v + " AS " + k;
+                else
+                    sql += k;
+            }
+            return sql;
         }
+        default:
+            throw new TypeError("columns 应为 string 或 object 类型");
     }
-    return sql;
 }
 /**
  * 生成 ORDER BY 语句, d
  * @public
+ * @example
  * ```ts
  * // 以下生成 "\nORDER BY age DESC NULLS FIRST,num ASC"
  * orderBy("age DESC NULLS FIRST,num ASC");
@@ -174,14 +210,16 @@ function orderBy(by) {
         let keys = Object.keys(by);
         if (keys.length) {
             let key = keys[0];
-            sql += "\nORDER BY " + key + " " + by[key];
+            let value = by[key];
+            sql += "\nORDER BY " + key + " " + (typeof value === "string" ? value : value ? "ASC" : "DESC");
             for (let i = 1; i < keys.length; i++) {
                 key = keys[i];
+                value = by[key];
                 sql += "," + key + " ";
-                if (typeof by[key] === "string")
-                    sql += by[key];
+                if (typeof value === "string")
+                    sql += value;
                 else
-                    sql += by[key] ? "ASC" : "DESC";
+                    sql += value ? "ASC" : "DESC";
             }
         }
     }
@@ -210,41 +248,14 @@ var _SqlQueryStatement_sql;
  * @public
  */
 class SqlSelectable {
-    constructor(columns) {
-        // Reflect.set(this, SQL_SELECTABLE, undefined);
-        let readonlyColumns;
-        if (typeof columns[Symbol.iterator] === "function") {
-            let iterable = columns;
-            readonlyColumns = [];
-            let iter = iterable[Symbol.iterator]();
-            let i = 0;
-            let item = iter.next();
-            while (!item.done) {
-                readonlyColumns[i++] = item.value;
-                item = iter.next();
-            }
-            // readonlyColumns.length = i;
-        }
-        else {
-            let arrayLike = columns;
-            readonlyColumns = new Array(arrayLike.length);
-            // readonlyColumns.length = arrayLike.length;
-            for (let i = 0; i < arrayLike.length; i++) {
-                readonlyColumns[i] = arrayLike[i];
-            }
-        }
-        this.columns = readonlyColumns;
-    }
 }
 /**
  * 数据库表
  * @public
  */
 class DbTable extends SqlSelectable {
-    constructor(name, columns) {
-        if (!(columns instanceof Array))
-            columns = Object.keys(columns);
-        super(columns);
+    constructor(name) {
+        super();
         this.name = name;
     }
     toSelect() {
@@ -259,14 +270,10 @@ class DbTable extends SqlSelectable {
  * @public
  */
 class SqlQueryStatement extends SqlSelectable {
-    constructor(sql, columns) {
-        if (sql instanceof SqlQueryStatement) {
-            columns = sql.columns;
-            sql = __classPrivateFieldGet(sql, _SqlQueryStatement_sql, "f");
-        }
-        super(columns);
+    constructor(sql) {
+        super();
         _SqlQueryStatement_sql.set(this, void 0);
-        __classPrivateFieldSet(this, _SqlQueryStatement_sql, sql, "f");
+        __classPrivateFieldSet(this, _SqlQueryStatement_sql, sql.toString(), "f");
     }
     toString() {
         return __classPrivateFieldGet(this, _SqlQueryStatement_sql, "f");
@@ -487,13 +494,13 @@ class SqlValuesCreator {
 }
 class YourValuesAs extends SqlSelectable {
     constructor(columns, asName, valuesStr) {
-        super(columns);
+        super();
         _YourValuesAs_asName.set(this, void 0);
         _YourValuesAs_valuesStr.set(this, void 0);
         _YourValuesAs_sql.set(this, void 0);
         __classPrivateFieldSet(this, _YourValuesAs_asName, asName, "f");
         __classPrivateFieldSet(this, _YourValuesAs_valuesStr, valuesStr, "f");
-        __classPrivateFieldSet(this, _YourValuesAs_sql, `(VALUES\n${__classPrivateFieldGet(this, _YourValuesAs_valuesStr, "f")})\nAS ${__classPrivateFieldGet(this, _YourValuesAs_asName, "f")}(${this.columns.join(",")})`, "f");
+        __classPrivateFieldSet(this, _YourValuesAs_sql, `(VALUES\n${__classPrivateFieldGet(this, _YourValuesAs_valuesStr, "f")})\nAS ${__classPrivateFieldGet(this, _YourValuesAs_asName, "f")}(${columns.join(",")})`, "f");
     }
     toSelect() {
         return __classPrivateFieldGet(this, _YourValuesAs_sql, "f");
@@ -546,11 +553,11 @@ const pgSqlTransformer = new Map([
 
 var _Selection_instances, _a, _Selection_sql, _Selection_join;
 class AfterSelectImpl extends SqlQueryStatement {
-    constructor(sql, columns) {
-        super(sql, columns);
+    constructor(sql) {
+        super(sql);
     }
     where(param) {
-        return new AfterSelectImpl(this.toString() + where(param), this.columns);
+        return new AfterSelectImpl(this.toString() + where(param));
     }
     groupBy(columns) {
         let sql = this.toString();
@@ -558,13 +565,13 @@ class AfterSelectImpl extends SqlQueryStatement {
             sql += " GROUP BY " + columns;
         else
             sql += " GROUP BY " + columns.join(",");
-        return new AfterSelectImpl(sql, this.columns);
+        return new AfterSelectImpl(sql);
     }
     having(param) {
-        return new AfterSelectImpl(this.toString() + having(param), this.columns);
+        return new AfterSelectImpl(this.toString() + having(param));
     }
     orderBy(param) {
-        return new AfterSelectImpl(this.toString() + orderBy(param), this.columns);
+        return new AfterSelectImpl(this.toString() + orderBy(param));
     }
     limit(limit, offset) {
         let sql = this.toString();
@@ -572,10 +579,12 @@ class AfterSelectImpl extends SqlQueryStatement {
             sql += "\nLIMIT " + limit;
         if (offset)
             sql += "\nOFFSET " + offset;
-        return new SqlQueryStatement(sql, Array.from(this.columns));
+        return new SqlQueryStatement(sql);
     }
 }
 function fromAs(selectable, as) {
+    if (typeof selectable === "function")
+        selectable = selectable();
     let sql = typeof selectable === "string" ? selectable : selectable.toSelect();
     if (as)
         sql += " AS " + as;
@@ -616,59 +625,25 @@ class Selection {
         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);
-        }
+        if (typeof columnsIn === "function")
+            columnsIn = columnsIn();
+        let sql = "SELECT " + selectColumns(columnsIn);
         sql += "\n" + this.toString();
-        return new AfterSelectImpl(sql, columns);
+        return new AfterSelectImpl(sql);
     }
 }
 _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;
+    if (on) {
+        sql += " ON " + condition(on);
+    }
     return new _a(sql);
 };
 
-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(", ") };
-}
-
 /** @public */
 class DbTableQuery extends DbTable {
-    constructor(name, columns, statement) {
-        super(name, columns);
+    constructor(name, statement) {
+        super(name);
         this.statement = statement;
     }
     fromAs(as) {
@@ -677,89 +652,127 @@ class DbTableQuery extends DbTable {
     select(columns, as) {
         return this.fromAs(as).select(columns);
     }
-    insert(values, option) {
-        let insertCol;
+    insert(values, columns_option, option) {
+        if (typeof values === "function")
+            values = values();
+        let columnStr;
         let valuesStr;
-        if (values instanceof Array) {
-            if (values.length === 0)
-                throw new Error("值不能为空");
-            insertCol = Array.from(getObjectListKeys(values));
-            valuesStr = `VALUES\n${this.statement.objectListToValuesList(values, insertCol)}`;
+        if (typeof values === "string") {
+            valuesStr = values;
+            if (typeof columns_option === "string")
+                columnStr = columns_option;
+            else if (columns_option instanceof Array) {
+                if (columns_option.length === 0)
+                    throw new Error("插入列为空");
+                columnStr = columns_option.join(",");
+            }
+            else
+                throw new Error("当 values 为 string 类型时，必须指定 columns");
         }
-        else if (values instanceof SqlQueryStatement) {
-            // todo 验证 values.columns 和 this.columns 是否匹配
-            valuesStr = values.toString();
-            insertCol = values.columns;
+        else {
+            let insertCol;
+            option = columns_option;
+            if (typeof values === "object") {
+                if (values instanceof Array) {
+                    if (values.length === 0)
+                        throw new Error("值不能为空");
+                    insertCol = Array.from(getObjectListKeys(values));
+                    valuesStr = `VALUES\n${this.statement.objectListToValuesList(values, insertCol)}`;
+                }
+                else if (values instanceof SqlQueryStatement) {
+                    // todo 验证 values.columns 和 this.columns 是否匹配
+                    valuesStr = values.toString();
+                    insertCol = values.columns;
+                }
+                else {
+                    insertCol = Object.keys(values);
+                    valuesStr = `VALUES\n(${this.statement.objectToValues(values, insertCol)})`;
+                }
+            }
+            else
+                throw new Error("values 应该是 Array 或 TableQuery 类型");
+            if (insertCol.length === 0)
+                throw new Error("插入列不能为空");
+            columnStr = insertCol.join(",");
         }
-        else
-            throw new Error("values 应该是 Array 或 TableQuery 类型");
-        if (insertCol.length === 0)
-            throw new Error("插入列不能为空");
-        let sql = `INSERT INTO ${this.name} (${insertCol.join(",")})\n${valuesStr}`;
+        let sql = `INSERT INTO ${this.name} (${columnStr})\n${valuesStr}`;
         if (option) {
-            const { updateValues, conflict, where } = option;
+            let { updateValues, conflict, where: inputWhere } = option;
             if (conflict) {
-                sql += `\nON CONFLICT (${conflict.join(",")})`;
+                if (typeof conflict !== "string")
+                    conflict = conflict.join(",");
+                sql += `\nON CONFLICT (${conflict})`;
+                if (typeof updateValues === "function")
+                    updateValues = updateValues();
                 if (updateValues) {
                     const updateKey = Object.entries(updateValues);
                     sql += `\nDO UPDATE SET\n${updateKey.map(([key, v = "EXCLUDED." + key]) => key + " = " + v).join(",\n")}`;
                 }
                 else
                     sql += "DO NOTHING";
-                if (where)
-                    sql += "\nWHERE " + where;
+                sql += where(inputWhere);
             }
         }
         return sql;
     }
-    insertWithResult(values, returns, option) {
-        let sql = this.insert(values, option);
-        return genRetuningSql(sql, returns, values instanceof SqlQueryStatement ? values.columns : this.columns);
+    insertWithResult(values, returns, columns, option) {
+        let sql = this.insert(values, columns, option);
+        return genRetuningSql(sql, returns);
     }
+    /**
+     * @example
+     * ```ts
+     * table.update("age=3, name='hi'") // "UPDATE table SET age=3, name='hi'"
+     * table.update({age:3, name:"hi"}) // "UPDATE table SET age=3, name='hi'"
+     * ```
+     */
     update(values, option = {}) {
-        const updateKey = Object.entries(values);
-        if (updateKey.length === 0)
-            throw new Error("值不能为空");
-        let setList = [];
-        for (const [k, v] of updateKey) {
-            if (v === undefined)
-                continue;
-            setList.push(k + " = " + this.statement.toSqlStr(v));
+        if (typeof values === "function")
+            values = values();
+        let setStr;
+        if (typeof values === "string")
+            setStr = values;
+        else {
+            const updateKey = Object.entries(values);
+            let setList = [];
+            for (const [k, v] of updateKey) {
+                if (v === undefined)
+                    continue;
+                setList.push(k + " = " + this.statement.toSqlStr(v));
+            }
+            setStr = setList.join(",\n");
         }
-        let sql = `UPDATE ${this.name}\nSET ${setList.join(",\n")}`;
-        if (option.where)
-            sql += where(option.where);
+        if (!setStr)
+            throw new Error("值不能为空");
+        let sql = `UPDATE ${this.name}\nSET ${setStr}`;
+        sql += where(option.where);
         return sql;
     }
     updateWithResult(values, returns, option) {
         let sql = this.update(values, option);
-        return genRetuningSql(sql, returns, values instanceof SqlQueryStatement ? values.columns : this.columns);
+        return genRetuningSql(sql, returns);
     }
     delete(option = {}) {
         let sql = "DELETE FROM " + this.name;
-        if (option.where)
-            sql += where(option.where);
+        sql += where(option.where);
         return sql;
     }
     deleteWithResult(returns = "*", option) {
         let sql = this.delete(option);
-        return genRetuningSql(sql, returns, this.columns);
+        return genRetuningSql(sql, returns);
     }
 }
-function genRetuningSql(sql, returns, tableColumns) {
+function genRetuningSql(sql, returns) {
     let columnsStr;
-    let columns;
     if (returns === "*") {
-        columns = tableColumns;
         columnsStr = "*";
     }
     else {
         const res = selectColumnsOrTable(returns);
         columnsStr = res.sqlColumns;
-        columns = res.columns;
     }
     sql += "\nRETURNING " + columnsStr;
-    return new SqlQueryStatement(sql, columns);
+    return new SqlQueryStatement(sql);
 }
 
 /**
@@ -913,8 +926,9 @@ function getErrStr(expect, actual) {
  */
 class YourTable extends DbTableQuery {
     constructor(name, define, sqlValue) {
-        super(name, Object.keys(define), sqlValue);
+        super(name, sqlValue);
         this.define = define;
+        this.columns = Object.keys(define);
     }
     getColumnMeta(name) {
         return Reflect.get(this.define, name);

package/dist/select/TableQuery.d.ts

@@ -2,11 +2,11 @@ import { SqlValuesCreator, SqlRaw } from "../sql_value/sql_value.ts";
 import { ColumnsSelected, SelectColumns, UpdateRowValue, TableType } from "./type.ts";
 import { CurrentWhere, Selection } from "./select.ts";
 import { DbTable, SqlQueryStatement } from "./selectable.ts";
-import { ConditionParam } from "../util.ts";
+import { ConditionParam, Constructable } 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);
+    constructor(name: string, statement: SqlValuesCreator);
     fromAs(as?: string): Selection;
     /** 选择单表全部列 */
     select(columns: "*", as?: string): CurrentWhere<T>;
@@ -15,35 +15,57 @@ export declare class DbTableQuery<T extends TableType = Record<string, any>, C e
      * @param columns - 对象选择
      */
     select<R extends {
-        [key in keyof T]?: string | boolean;
-    } | Record<string, string>>(columns: R, as?: string): CurrentWhere<{
-        [key in keyof R]: R[key] extends boolean ? key extends keyof T ? T[key] : unknown : R[key] extends keyof T ? T[R[key]] : unknown;
+        [key in keyof T]?: boolean;
+    }>(columns: Constructable<R>, as?: string): CurrentWhere<{
+        [key in keyof R]: key extends keyof T ? T[key] : unknown;
     }>;
     /** 选择单表- 所有类型 */
-    select<R extends {}>(columns: "*" | string[] | {
+    select<R extends {}>(columns: Constructable<{
         [key in keyof R]?: key extends keyof T ? string | boolean : string;
-    }, as?: string): CurrentWhere<R>;
-    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;
-    updateWithResult<R extends ColumnsSelected<T>>(values: UpdateRowValue<T>, returns: R, option?: UpdateOption): SqlQueryStatement<SelectColumns<T, R>>;
+    } | string>, as?: string): CurrentWhere<R>;
+    /**
+     * @example
+     * ```ts
+     * table.insert({age:18, name:"hi"}) // INSERT INTO table(age,name) VALUES (18, 'hi')
+     * table.insert([{age:18, name:"hi"}, {age:17, name:"hh"}]) // INSERT INTO table(age,name) VALUES(18, 'hi'), (17, 'hh')
+     * ```
+     */
+    insert(values: Constructable<C | C[]>, option?: InsertOption<T>): string;
+    /**
+     * @example
+     * ```ts
+     * table.insert("VALUES (18, 'hi'), (17, 'hh')", ["age","name"]) // INSERT INTO table(age,name) VALUES(18, 'hi'), (17, 'hh')
+     * ```
+     */
+    insert(values: Constructable<string>, columns: string[], option?: InsertOption<T>): string;
+    insertWithResult<R extends ColumnsSelected<T>>(values: Constructable<C | C[]>, returns: R, option?: InsertOption<T>): SqlQueryStatement<SelectColumns<T, R>>;
+    insertWithResult<R extends ColumnsSelected<T>>(values: Constructable<string>, returns: R, columns: string | string[], option?: InsertOption<T>): SqlQueryStatement<SelectColumns<T, R>>;
+    /**
+     * @example
+     * ```ts
+     * table.update("age=3, name='hi'") // "UPDATE table SET age=3, name='hi'"
+     * table.update({age:3, name:"hi"}) // "UPDATE table SET age=3, name='hi'"
+     * ```
+     */
+    update(values: Constructable<UpdateRowValue<T> | string>, option?: UpdateOption): string;
+    updateWithResult<R extends ColumnsSelected<T>>(values: Constructable<UpdateRowValue<T>>, returns: R, option?: UpdateOption): SqlQueryStatement<SelectColumns<T, R>>;
     delete(option?: DeleteOption): string;
     deleteWithResult<R extends ColumnsSelected<T>>(returns?: ColumnsSelected<T> | "*", option?: DeleteOption): SqlQueryStatement<SelectColumns<T, R>>;
 }
 /** @public */
 export interface InsertOption<T extends object> {
-    conflict?: (keyof T)[];
-    updateValues?: {
+    conflict?: (keyof T)[] | string;
+    updateValues?: Constructable<{
         [key in keyof T]?: undefined | SqlRaw | T[key];
-    };
-    where?: ConditionParam;
+    } | string | void>;
+    where?: Constructable<ConditionParam | void>;
 }
 /** @public */
 export interface UpdateOption {
-    where?: ConditionParam;
+    where?: Constructable<ConditionParam | void>;
 }
 /** @public */
 export interface DeleteOption {
-    where?: ConditionParam;
+    where?: Constructable<ConditionParam | void>;
 }
 //# sourceMappingURL=TableQuery.d.ts.map

package/dist/select/_statement.d.ts

@@ -1,6 +1,12 @@
-import { ColumnsSelectAs } from "./type.ts";
-export declare function selectColumnsOrTable(columns: ColumnsSelectAs<any> | string[]): {
+import { Constructable } from "../util.ts";
+export declare function selectColumnsOrTable(columns: Record<string, boolean | string> | string[]): {
     columns: string[];
     sqlColumns: string;
 };
+type ConditionParam = string | string[];
+/**
+ * 生成条件语句
+ */
+export declare function condition(conditions?: Constructable<ConditionParam | void>, type?: "AND" | "OR"): string;
+export {};
 //# sourceMappingURL=_statement.d.ts.map

package/dist/select/select.d.ts

@@ -1,5 +1,5 @@
 import { SqlSelectable, SqlQueryStatement } from "./selectable.ts";
-import { OrderByParam, ConditionParam } from "../util.ts";
+import { OrderByParam, ConditionParam, SelectParam, Constructable } from "../util.ts";
 import type { TableType } from "./type.ts";
 /** @public */
 export interface CurrentLimit<T extends TableType> extends SqlQueryStatement<T> {
@@ -7,11 +7,11 @@ export interface CurrentLimit<T extends TableType> extends SqlQueryStatement<T>
 }
 /** @public */
 export interface CurrentOrderBy<T extends TableType> extends CurrentLimit<T> {
-    orderBy(param: OrderByParam | (() => OrderByParam | void)): CurrentLimit<T>;
+    orderBy(param: Constructable<OrderByParam | void>): CurrentLimit<T>;
 }
 /** @public */
 export interface CurrentHaving<T extends TableType> extends CurrentOrderBy<T> {
-    having(param: ConditionParam | (() => ConditionParam | void)): CurrentLimit<T>;
+    having(param: Constructable<ConditionParam | void>): CurrentLimit<T>;
 }
 /** @public */
 export interface CurrentGroupBy<T extends TableType> extends CurrentOrderBy<T> {
@@ -19,25 +19,41 @@ export interface CurrentGroupBy<T extends TableType> extends CurrentOrderBy<T> {
 }
 /** @public */
 export interface CurrentWhere<T extends TableType> extends CurrentGroupBy<T> {
-    where(param: ConditionParam | (() => ConditionParam | void)): CurrentGroupBy<T>;
+    where(param: Constructable<ConditionParam | void>): CurrentGroupBy<T>;
 }
 /** @public */
 export declare class Selection {
     #private;
-    static from(selectable: SqlSelectable<any> | string, as?: string): Selection;
-    constructor(selectable: SqlSelectable<any> | string, as?: string);
+    static from(selectable: Constructable<SqlSelectable<any> | string>, as?: string): Selection;
+    constructor(selectable: Constructable<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>(columns: {
+    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(columns: "*" | string[] | Record<string, string | boolean>): CurrentWhere<TableType>;
+    }>): CurrentWhere<T>;
+    select(columns: Constructable<SelectParam>): CurrentWhere<TableType>;
 }
 //# sourceMappingURL=select.d.ts.map

package/dist/select/selectable.d.ts

@@ -11,9 +11,6 @@ declare const SQL_SELECTABLE: unique symbol;
  * @public
  */
 export declare abstract class SqlSelectable<T extends TableType> {
-    constructor(columns: ArrayLike<string> | Iterable<string>);
-    /** 结果列 */
-    readonly columns: readonly string[];
     /**
      * 转成子选择语句, 你可以使用 select form xxx 选择
      * 如果是 table 则是 table name
@@ -31,7 +28,7 @@ export declare abstract class SqlSelectable<T extends TableType> {
  */
 export declare class DbTable<T extends TableType> extends SqlSelectable<T> {
     readonly name: string;
-    constructor(name: string, columns: readonly (keyof T)[]);
+    constructor(name: string);
     toSelect(): string;
     toString(): string;
 }
@@ -41,8 +38,7 @@ export declare class DbTable<T extends TableType> extends SqlSelectable<T> {
  */
 export declare class SqlQueryStatement<T extends TableType = TableType> extends SqlSelectable<T> {
     #private;
-    constructor(sql: string, columns: readonly string[]);
-    constructor(sql: SqlQueryStatement);
+    constructor(sql: string | SqlQueryStatement);
     toString(): string;
     toSelect(): string;
 }

package/dist/select/type.d.ts

@@ -18,25 +18,22 @@ export type PickColumn<T extends {
 export type UpdateRowValue<T extends object> = {
     [key in keyof T]?: T[key] | SqlRaw;
 };
-/**
- * 选择列并重命名
- * @public
- */
-export type ColumnsSelectAs<T extends TableType> = {
-    [key in keyof T]?: boolean | string;
-};
 /** @public */
 export type OrderValue = "ASC" | "DESC";
 /**
  * 表的选择参数
  * @public
  */
-export type ColumnsSelected<T extends TableType> = ColumnsSelectAs<T> | "*";
+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 "*" ? T : R extends ColumnsSelectAs<T> ? {
+export type SelectColumns<T extends TableType, R extends ColumnsSelected<T>> = R extends "*" ? 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;

package/dist/util.d.ts

@@ -6,29 +6,40 @@ import { OrderValue } from "./select/type.ts";
  */
 export declare function getObjectListKeys(objectList: any[], keepUndefinedKey?: boolean): Set<string>;
 /** @public */
+export type Constructable<T> = T | (() => T);
+/** @public */
 export type ConditionParam = string | string[];
 /**
  * 生成 WHERE 语句
  * @public
+ * @example
  * ```ts
- *
+ * where(['a=1','b=2']) // "\nWHERE a=1 AND b=2"
+ * where(['a=1','b=2'],"OR") // "\nWHERE a=1 OR b=2"
+ * where("a=1 OR b=2") // "\nWHERE a=1 OR b=2"
+ * where(()=>"a=1 OR b=2") // "\nWHERE a=1 AND b=2"
+ * where([]) // ""
+ * where(undefined) // ""
  * ```
  */
-export declare function where(conditions?: ConditionParam | (() => ConditionParam | void), type?: "AND" | "OR"): string;
+export declare function where(conditions?: Constructable<ConditionParam | void>, type?: "AND" | "OR"): string;
 /**
  *
  * 生成 HAVING 语句
  * @public
  */
-export declare function having(conditions?: ConditionParam | (() => ConditionParam | void), type?: "AND" | "OR"): string;
+export declare function having(conditions?: Constructable<ConditionParam | void>, type?: "AND" | "OR"): string;
+/** @public */
+export type SelectParam = string | Record<string, string | boolean>;
 /**
  * @public
+ * @example
  * ```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"
+ * 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;
+export declare function selectColumns(columns: Constructable<SelectParam>): string;
 /** @public */
 export type OrderBehavior = {
     key: string;
@@ -40,6 +51,7 @@ export type OrderByParam = string | (string | OrderBehavior)[] | Record<string,
 /**
  * 生成 ORDER BY 语句, d
  * @public
+ * @example
  * ```ts
  * // 以下生成 "\nORDER BY age DESC NULLS FIRST,num ASC"
  * orderBy("age DESC NULLS FIRST,num ASC");
@@ -54,5 +66,5 @@ export type OrderByParam = string | (string | OrderBehavior)[] | Record<string,
  * orderBy({}) // ""
  * ```
  */
-export declare function orderBy(by?: OrderByParam | void | (() => OrderByParam | void)): string;
+export declare function orderBy(by?: Constructable<OrderByParam | void>): string;
 //# sourceMappingURL=util.d.ts.map

package/dist/your_table/table.d.ts

@@ -10,6 +10,7 @@ import { TypeChecker } from "./checker.ts";
 export declare class YourTable<T extends TableType = TableType, C extends TableType = T> extends DbTableQuery<T, C> {
     private define;
     constructor(name: string, define: TableDefined, sqlValue: SqlValuesCreator);
+    readonly columns: readonly string[];
     getColumnMeta(name: keyof T): ColumnMeta<unknown>;
     createTypeChecker<T>(keys: readonly string[]): TypeChecker<T>;
 }

package/package.json

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