@asla/yoursql 0.5.2 → 0.6.1

package/README.md

@@ -5,15 +5,75 @@
 
 [package]: https://img.shields.io/badge/package-ESM-ffe536.svg
 [package-url]: https://nodejs.org/api/esm.html
-[npm]: https://img.shields.io/npm/v/yoursql.svg
-[npm-url]: https://npmjs.com/package/yoursql
+[npm]: https://img.shields.io/npm/v/@asla/yoursql.svg
+[npm-url]: https://npmjs.com/package/@asla/yoursql
 [jsr]: https://jsr.io/badges/@asla/yoursql
 [jsr-url]: https://jsr.io/@asla/yoursql
-[node]: https://img.shields.io/node/v/yoursql.svg
+[node]: https://img.shields.io/node/v/@asla/yoursql.svg
 [node-url]: https://nodejs.org
-[size]: https://packagephobia.com/badge?p=yoursql
-[size-url]: https://packagephobia.com/result?p=yoursql
+[size]: https://packagephobia.com/badge?p=@asla%2Fyoursql
+[size-url]: https://packagephobia.com/result?p=@asla%2Fyoursql
 
 SQL 生成器
 
 [API 文档](https://jsr.io/@asla/yoursql/doc)
+
+### 安全转将 JS 值转换为 SQL 值，避免 SQL 注入
+
+导入
+
+```ts
+import { v } from "@asla/yoursql";
+```
+
+默认情况下，支持 PostgresSQL, 因为不同数据库的值转换有些差异，如果使用其他数据库，可能需要配置对象转换器
+
+```ts
+v(1); // "1"
+v(1n); // "1"
+v("te'xt"); // "'te''xt'"
+v(new Date()); // "'2024-11-30T05:08:33.112Z'"
+v([1, 2, 3]); // "ARRAY[1,2,3]"
+v({ id: "abc", size: 1 }); // "'{\"id\":\"abc\",\"size\":1}'"
+v(null); // "NULL"
+v(undefined); // "DEFAULT"
+```
+
+如果传入 String 对象，将保留其字符串值，不会进行任何转换
+
+```ts
+v(new String("1+1")); // "1+1"
+```
+
+你可以自定义对象到字符串的转换, 例如，你想将 Set 转换为 PostgresSql 的 ARRAY[] 输入格式
+
+```ts
+v.setTransformer(Set, function (value: Set) {
+  return this.v(Array.from(value));
+});
+```
+
+转换对象数组
+
+```ts
+const values = [{ a: 1, b: 2 }, { c: 3 }];
+
+// 这将自动选择数组中所有键的并集
+v.objectListToValuesList(values); // "(1,2,null),(null,null,3)"
+
+// 或者你可以指定选择键并指定顺序
+v.objectListToValuesList(values, ["c", "b"]); // "(null,2),(3,3)"
+```
+
+### 生成 SQL 语句
+
+```ts
+import { Selection, v } from "@asla/yoursql";
+
+const searchName = "Bob";
+const s = Selection.from("user", "u")
+  .innerJoin("role", "r", "u.id=r.user_id")
+  .select({ uid: "u.id", rid: "r.id", example: "u.id||r.id" }) // SELECT u.id AS uid, r.id AS rid u.id||u.id AS example
+  .where(`u.name LIKE %${v(searchName)}%`)
+  .toString();
+```

package/dist/mod.d.ts

@@ -6,4 +6,10 @@ export * from "./select/selectable.ts";
 export * from "./select/TableQuery.ts";
 export * from "./util.ts";
 export * from "./your_table/mod.ts";
+import { SqlValueFn } from "./sql_value/sql_value.ts";
+/**
+ * 默认的 SqlValuesCreator 实列
+ * @public
+ */
+export declare const v: SqlValueFn;
 //# sourceMappingURL=mod.d.ts.map

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");
@@ -310,21 +284,13 @@ class SqlQueryStatement extends SqlSelectable {
 }
 _SqlQueryStatement_sql = new WeakMap();
 
-var _SqlRaw_value, _YourValuesAs_asName, _YourValuesAs_valuesStr, _YourValuesAs_sql;
+var _SqlValuesCreator_map, _YourValuesAs_asName, _YourValuesAs_valuesStr, _YourValuesAs_sql;
 /**
- * SQL 原始字符对象
+ * SQL 原始字符类。可以使用 String 类代替，这只是为了推断类型
  * @public
  */
-class SqlRaw {
-    constructor(value) {
-        _SqlRaw_value.set(this, void 0);
-        __classPrivateFieldSet(this, _SqlRaw_value, value, "f");
-    }
-    toString() {
-        return __classPrivateFieldGet(this, _SqlRaw_value, "f");
-    }
+class SqlRaw extends String {
 }
-_SqlRaw_value = new WeakMap();
 /**
  * SQL value 生成器
  * @public
@@ -346,28 +312,43 @@ class SqlValuesCreator {
     /**
      * @param map - 自定义对象转换
      */
-    constructor(map = new Map()) {
-        this.map = map;
+    constructor(map) {
+        _SqlValuesCreator_map.set(this, void 0);
+        __classPrivateFieldSet(this, _SqlValuesCreator_map, new Map(map), "f");
     }
-    /** 设置转换器 */
-    setTransformer(type, transformer) {
-        if (!transformer)
-            this.map.delete(type);
-        else
-            this.map.set(type, transformer);
+    setTransformer(type_map, encoder) {
+        if (typeof type_map === "function") {
+            if (encoder)
+                __classPrivateFieldGet(this, _SqlValuesCreator_map, "f").set(type_map, encoder);
+            else
+                __classPrivateFieldGet(this, _SqlValuesCreator_map, "f").delete(type_map);
+        }
+        else {
+            for (const [type, encoder] of type_map) {
+                if (typeof type === "function" && typeof encoder === "function") {
+                    __classPrivateFieldGet(this, _SqlValuesCreator_map, "f").set(type, encoder);
+                }
+            }
+        }
     }
-    /** 将 JS 对象转为 SQL 的字符值的形式 。 undefined 将被转换为 DEFAULT */
-    toSqlStr(value, expectType) {
+    /**
+     * 将 JS 对象转为 SQL 的字符值的形式 。 undefined 将被转换为 DEFAULT
+     * ```ts
+     *  const v=SqlValuesCreator.create()
+     *  v() 和 v.toSqlStr() 是等价的
+     * ```
+     */
+    toSqlStr(value, assertType) {
         let basicType;
-        if (expectType) {
-            if (typeof expectType === "function") {
-                let type = this.map.get(expectType);
+        if (assertType) {
+            if (typeof assertType === "function") {
+                let type = __classPrivateFieldGet(this, _SqlValuesCreator_map, "f").get(assertType);
                 if (!type)
                     throw new Error("类型不存在");
                 return type.call(this, value);
             }
             else {
-                basicType = expectType;
+                basicType = assertType;
             }
         }
         else
@@ -384,7 +365,7 @@ class SqlValuesCreator {
             case "object": {
                 if (value === null)
                     return "NULL";
-                if (value instanceof SqlRaw)
+                if (value instanceof String)
                     return value.toString();
                 return this.getObjectType(value).call(this, value);
             }
@@ -398,9 +379,9 @@ class SqlValuesCreator {
     }
     /** 获取值对应的 SqlValueEncoder */
     getObjectType(value) {
-        for (const Class of this.map.keys()) {
+        for (const Class of __classPrivateFieldGet(this, _SqlValuesCreator_map, "f").keys()) {
             if (value instanceof Class)
-                return this.map.get(Class);
+                return __classPrivateFieldGet(this, _SqlValuesCreator_map, "f").get(Class);
         }
         return this.defaultObject;
     }
@@ -518,15 +499,16 @@ class SqlValuesCreator {
         return new YourValuesAs(insertKeys, asName, valuesStr.join(",\n"));
     }
 }
+_SqlValuesCreator_map = new WeakMap();
 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 +561,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 +573,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 +587,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 +633,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 +650,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 +660,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 +934,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);
@@ -935,4 +955,10 @@ class YourTable extends DbTableQuery {
     }
 }
 
-export { ColumnMeta, CustomDbType, DbTable, DbTableQuery, Selection, SqlQueryStatement, SqlRaw, SqlSelectable, SqlValuesCreator, TypeChecker, YourTable, YourTypeMap, getObjectListKeys, having, orderBy, pgSqlTransformer, selectColumns, where };
+/**
+ * 默认的 SqlValuesCreator 实列
+ * @public
+ */
+const v = SqlValuesCreator.create(pgSqlTransformer);
+
+export { ColumnMeta, CustomDbType, DbTable, DbTableQuery, Selection, SqlQueryStatement, SqlRaw, SqlSelectable, SqlValuesCreator, TypeChecker, YourTable, YourTypeMap, getObjectListKeys, having, orderBy, pgSqlTransformer, selectColumns, v, where };

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/sql_value/sql_value.d.ts

@@ -1,33 +1,34 @@
 import { SqlSelectable } from "../select/selectable.ts";
 declare const SQL_RAW: unique symbol;
 /**
- * SQL 原始字符对象
+ * SQL 原始字符类。可以使用 String 类代替，这只是为了推断类型
  * @public
  */
-export declare class SqlRaw<T = any> {
-    #private;
-    constructor(value: string);
-    toString(): string;
+export declare class SqlRaw<T = any> extends String {
     /** 保留以推断类型 */
     protected [SQL_RAW]: T;
 }
-/** @public */
+/** @public js 对象到编码函数的映射*/
 export type JsObjectMapSql = Map<new (...args: any[]) => any, SqlValueEncoder>;
-/** @public */
+/** @public 将 js 值转为 SQl 字符串的函数*/
 export type SqlValueEncoder<T = any> = (this: SqlValuesCreator, value: T) => string;
-/** @public */
+/** @public 断言类型 */
 export type ManualType = "bigint" | "number" | "string" | "boolean" | "object" | (new (...args: any[]) => any);
 /** @public */
-export interface SqlValueFn {
-    /** 将 JS 对象转为 SQL 的字符值的形式 。 undefined 将被转换为 DEFAULT */
-    (value: any, expectType?: ManualType): string;
-}
+export type SqlValueFn = SqlValuesCreator & {
+    /**
+     * 安全将 JS 对象转为 SQL 的字符值的形式，可避免 SQL 注入。
+     * undefined 将被转换为 DEFAULT
+     */
+    (value: any, assertType?: ManualType): string;
+};
 /**
  * SQL value 生成器
  * @public
  */
 export declare class SqlValuesCreator {
-    static create(map?: JsObjectMapSql): SqlValuesCreator & SqlValueFn;
+    #private;
+    static create(map?: JsObjectMapSql): SqlValueFn;
     /**
      * 将字符串转为 SQL 的字符串值的形式(单引号会被转义)。
      * @example 输入 a'b'c , 返回 a''b''c.
@@ -38,15 +39,21 @@ export declare class SqlValuesCreator {
      */
     constructor(map?: JsObjectMapSql);
     /** 设置转换器 */
-    setTransformer<T>(type: new (...args: any[]) => T, transformer?: SqlValueEncoder): void;
-    private readonly map;
-    /** 将 JS 对象转为 SQL 的字符值的形式 。 undefined 将被转换为 DEFAULT */
-    toSqlStr(value: any, expectType?: ManualType): string;
+    setTransformer(type: new (...args: any[]) => any, encoder?: SqlValueEncoder): void;
+    setTransformer(map: JsObjectMapSql): void;
+    /**
+     * 将 JS 对象转为 SQL 的字符值的形式 。 undefined 将被转换为 DEFAULT
+     * ```ts
+     *  const v=SqlValuesCreator.create()
+     *  v() 和 v.toSqlStr() 是等价的
+     * ```
+     */
+    toSqlStr(value: any, assertType?: ManualType): string;
     /** 获取值对应的 SqlValueEncoder */
     getObjectType(value: object): SqlValueEncoder;
     protected defaultObject(value: object): string;
     /**
-     * 将对象列表转为 SQL 的 VALUES
+     * 将对象列表转为 SQL 的 VALUES。
      * @example 返回示例： " (...),(...) "
      * @param keys - 选择的键。如果指定了 keys, 值为 undefined 的属性将自动填充为 null; 如果未指定 keys，将选择 objectList 所有不是 undefined 项的键的并集
      */

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.1",
   "description": "",
   "type": "module",
   "types": "./dist/mod.d.ts",