@asla/yoursql 0.5.2 → 0.6.0

package/dist/mod.js

@@ -107,7 +107,12 @@ function getObjectListKeys(objectList, keepUndefinedKey) {
  * @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) {
@@ -243,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() {
@@ -292,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");
@@ -520,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");
@@ -579,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();
@@ -591,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();
@@ -605,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;
@@ -649,14 +625,11 @@ class Selection {
         return new _a(__classPrivateFieldGet(this, _Selection_sql, "f") + "," + fromAs(selectable, as));
     }
     select(columnsIn) {
-        let columns = [];
         if (typeof columnsIn === "function")
             columnsIn = columnsIn();
-        if (typeof columnsIn === "object")
-            columns = Object.keys(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) {
@@ -669,8 +642,8 @@ _a = Selection, _Selection_sql = new WeakMap(), _Selection_instances = new WeakS
 
 /** @public */
 class DbTableQuery extends DbTable {
-    constructor(name, columns, statement) {
-        super(name, columns);
+    constructor(name, statement) {
+        super(name);
         this.statement = statement;
     }
     fromAs(as) {
@@ -679,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);
 }
 
 /**
@@ -915,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,37 +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 | (() => 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;
-    } | (() => string | {
-        [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,5 +1,5 @@
-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;
 };
@@ -7,6 +7,6 @@ type ConditionParam = string | string[];
 /**
  * 生成条件语句
  */
-export declare function condition(conditions?: ConditionParam | (() => ConditionParam | void), type?: "AND" | "OR"): 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, SelectParam } 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,21 +19,21 @@ 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: ConditionParam | (() => ConditionParam)): Selection;
-    innerJoin(selectable: SqlSelectable<any>, as: string | undefined, on: ConditionParam | (() => ConditionParam)): Selection;
-    leftJoin(selectable: SqlSelectable<any>, as: string | undefined, on: ConditionParam | (() => ConditionParam)): Selection;
-    rightJoin(selectable: SqlSelectable<any>, as: string | undefined, on: ConditionParam | (() => ConditionParam)): 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;
+    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>;
     /**
@@ -43,7 +43,7 @@ export declare class Selection {
      * selection.select("t.age, count(*) AS c") // SELECT t.age,count(*) AS c FROM ...
      * ```
      */
-    select<T extends TableType = TableType>(columns: string): CurrentWhere<T>;
+    select<T extends TableType = TableType>(columns: Constructable<string>): CurrentWhere<T>;
     /**
      * 通过 object 选择 列
      * @example
@@ -51,11 +51,9 @@ export declare class Selection {
      * selection.select({"age":true, c:"count(*)"}) // SELECT age,count(*) AS c FROM ...
      * ```
      */
-    select<T extends TableType>(columns: {
+    select<T extends TableType>(columns: Constructable<{
         [key in keyof T]: string | boolean;
-    } | (() => {
-        [key in keyof T]: string | boolean;
-    })): CurrentWhere<T>;
-    select(columns: SelectParam | (() => SelectParam)): 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,22 +6,29 @@ 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>;
 /**
@@ -32,7 +39,7 @@ export type SelectParam = string | Record<string, string | boolean>;
  * selectColumns("c1,count(*) AS c2,column as c3")  //  "c1,count(*) AS c2,column as c3"
  * ```
  */
-export declare function selectColumns(columns: SelectParam | (() => SelectParam)): string;
+export declare function selectColumns(columns: Constructable<SelectParam>): string;
 /** @public */
 export type OrderBehavior = {
     key: string;
@@ -59,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.2",
+  "version": "0.6.0",
   "description": "",
   "type": "module",
   "types": "./dist/mod.d.ts",