@asla/yoursql 0.10.2 → 0.11.1

package/dist/client/DbPoolConnection.d.ts

@@ -1,4 +1,4 @@
-import type { SqlStatementDataset } from "../sql_gen/mod.ts";
+import { SqlStatementDataset } from "./_type.ts";
 import { DbQuery } from "./DbQuery.ts";
 import type { MultipleQueryResult, QueryRowsResult, DbQueryBase } from "./DbQueryBase.ts";
 import type { SqlLike, TransactionMode } from "./interfaces.ts";

package/dist/client/DbPoolTransaction.d.ts

@@ -1,8 +1,8 @@
-import type { SqlStatementDataset } from "../sql_gen/mod.ts";
 import { DbQuery } from "./DbQuery.ts";
 import type { MultipleQueryResult, QueryRowsResult } from "./DbQueryBase.ts";
 import type { DbPoolConnection } from "./DbPoolConnection.ts";
 import type { DbTransaction, SqlLike, TransactionMode } from "./interfaces.ts";
+import { SqlStatementDataset } from "./_type.ts";
 /** @public */
 export type DbPoolTransactionOption = {
     errorRollback?: boolean;

package/dist/client/DbQuery.d.ts

@@ -1,6 +1,6 @@
-import type { SqlStatementDataset } from "../sql_gen/mod.ts";
 import { SqlLike } from "./interfaces.ts";
 import { MultipleQueryResult, DbQueryBase, QueryRowsResult } from "./DbQueryBase.ts";
+import { SqlStatementDataset } from "./_type.ts";
 /**
  * SQL 查询相关操作
  * @public

package/dist/client/DbQueryBase.d.ts

@@ -1,4 +1,4 @@
-import type { SqlStatementDataset } from "../sql_gen/mod.ts";
+import { SqlStatementDataset } from "./_type.ts";
 import { SqlLike } from "./interfaces.ts";
 /** @public */
 export interface SingleQueryResult {

package/dist/client/_type.d.ts

@@ -0,0 +1,2 @@
+export type { SqlStatementDataset } from "../sql_gen/mod.ts";
+//# sourceMappingURL=_type.d.ts.map

package/dist/client/interfaces.d.ts

@@ -1,7 +1,7 @@
-import type { SqlStatementDataset } from "../sql_gen/mod.ts";
 import { DbQuery } from "./DbQuery.ts";
 import { DbPoolConnection } from "./DbPoolConnection.ts";
 import { DbCursor, DbCursorOption } from "./DbCursor.ts";
+import { SqlStatementDataset } from "./_type.ts";
 /**
  * 数据库连接
  * @public

package/dist/sql_gen/mod.js

@@ -2,7 +2,7 @@ import { pgSqlTransformer } from './sql_value/db_type.js';
 import { SqlValuesCreator } from './sql_value/sql_value.js';
 export { SqlExplicitValuesStatement } from './sql_value/sql_value.js';
 export { SqlStatement, SqlStatementDataset, SqlTextStatementDataset } from './SqlStatement.js';
-export { orderBy, select } from './statement/select.js';
+export { select } from './statement/select.js';
 export { insertInto } from './statement/insert.js';
 export { update } from './statement/update.js';
 export { deleteFrom } from './statement/delete.js';
@@ -11,6 +11,7 @@ export { selectColumns } from './util.js';
 export { TypeChecker } from './your_table/checker.js';
 export { ColumnMeta, CustomDbType, YourTypeMap } from './your_table/infer_db_type.js';
 export { YourTable } from './your_table/table.js';
+export { orderBy } from './statement/select_impl.js';
 
 /**
  * 默认的 SqlValuesCreator 实列

package/dist/sql_gen/sql_value/sql_value.d.ts

@@ -1,5 +1,5 @@
-import { SqlStatementDataset, SqlTemplate } from "../SqlStatement.ts";
-import { AssertJsType, ColumnToValueConfig, ObjectToValueKeys } from "./type.ts";
+import { SqlTemplate } from "../SqlStatement.ts";
+import { AssertJsType, ObjectToValueKeys } from "./type.ts";
 /** @public js 对象到编码函数的映射*/
 export type JsObjectMapSql = Map<new (...args: any[]) => any, SqlValueEncoder>;
 /** @public 将 js 值转为 SQl 字符串的函数*/
@@ -45,10 +45,6 @@ export declare class SqlValuesCreator {
     /** 获取值对应已定义的类 */
     getClassType(value: object): undefined | (new (...args: unknown[]) => unknown);
     protected defaultObject(value: object): string;
-    /** @deprecated 改用 createImplicitValues */
-    objectListToValuesList<T extends object>(objectList: T[], keys?: ObjectToValueKeys<T>): string;
-    /** @deprecated 请使用 objectListToValues 代替 */
-    objectListToValues<T extends object>(objectList: T[], columns?: ObjectToValueKeys<T>): SqlValuesTextData;
     /**
      * 将对象列表转为 SQL 的 VALUES。如果 objectList 中有某个对象的属性值为 undefined，则会被转换为 "DEFAULT"
      * @example 返回的文本示例： " (...),(...) "
@@ -65,25 +61,6 @@ export declare class SqlValuesCreator {
     createExplicitValues<T extends object>(objectList: T[], columns?: ObjectToValueKeys<T>): SqlExplicitValuesStatement;
     private _objectListToValues;
     private _objectToValue;
-    /**
-     * @deprecated 请使用 objectToValue 代替
-     */
-    objectToValues<T extends object>(object: T, keys?: ObjectToValueKeys<T>): string;
-    /**
-     * @deprecated 请使用 createImplicitValues 代替
-     * 将对象转为 SQL 的 value
-     * @example
-     * ```ts
-     *  v.objectToValue({ a: 1, b: "2", c: null, d: undefined }).text // "('1', '2', NULL, DEFAULT)"
-     *  v.objectToValue({ a: 1, b: "2", c: null, d: undefined }, ["a", "b"]).text // "('1', '2')"
-     *  v.objectToValue(
-     *    { a: 1, b: "2", c: null, d: undefined },
-     *    { a: "INT", b: "TEXT", c: "JSONB", d: "TEXT" }
-     *  ).text // "('1'::INT, '2'::TEXT, NULL::JSONB, DEFAULT::TEXT)"
-     * ```
-     * @param keys - 如果指定了key, object undefined 的属性值将填充为 null，如果不指定，将自获取 object 所有非 undefined 的属性的key
-     */
-    objectToValue<T extends object>(object: T, keys?: ObjectToValueKeys<T>): SqlValuesTextData;
     private _getObjectValueInfo;
     private _internalObjectToValues;
     /**
@@ -94,22 +71,6 @@ export declare class SqlValuesCreator {
      * ```
      */
     toValues(values: readonly any[]): string;
-    /**
-     * @deprecated 请使用 objectListToValues 代替
-     * @public 创建 VALUES AS  语句
-     * @example
-     * ```ts
-     *  sqlValue.createValues(
-     *    "customName",
-     *    [{age:8, name:"hhh"}, {age:9, name:"row2"}],
-     *    {age:"INT", name:"TEXT"}
-     *  )
-     * // (VALUES (8:INT,'hhh':TEXT),(9,'row2')) AS customName(age, name)
-     * ```
-     */
-    createValues<T extends {}>(asName: string, values: T[], valuesTypes: Record<string, string | ({
-        sqlType: string;
-    } & Pick<ColumnToValueConfig, "assertJsType" | "sqlDefault">)>): SqlStatementDataset<T>;
 }
 /** @public */
 export type SqlValuesTextData = {

package/dist/sql_gen/sql_value/sql_value.js

@@ -1,4 +1,3 @@
-import { SqlTextStatementDataset } from '../SqlStatement.js';
 import { getObjectListKeys } from '../_statement.js';
 import { ValueSqlTemplate } from './ValueSqlTemplate.js';
 
@@ -115,14 +114,6 @@ class SqlValuesCreator {
     defaultObject(value) {
         return SqlValuesCreator.string(JSON.stringify(value));
     }
-    /** @deprecated 改用 createImplicitValues */
-    objectListToValuesList(objectList, keys) {
-        return this.objectListToValues(objectList, keys).text;
-    }
-    /** @deprecated 请使用 objectListToValues 代替 */
-    objectListToValues(objectList, columns) {
-        return this.createImplicitValues(objectList, columns);
-    }
     createImplicitValues(objectList, columns) {
         let res;
         if (objectList instanceof Array) {
@@ -191,27 +182,6 @@ class SqlValuesCreator {
         const text = this._internalObjectToValues(object, keys, type, undefinedDefault);
         return new SqlExplicitValuesStatement(keys, `(${text})`);
     }
-    objectToValues(object, keys_types) {
-        const { keys, type } = this._getObjectValueInfo(object, keys_types);
-        return this._internalObjectToValues(object, keys, type, "DEFAULT");
-    }
-    /**
-     * @deprecated 请使用 createImplicitValues 代替
-     * 将对象转为 SQL 的 value
-     * @example
-     * ```ts
-     *  v.objectToValue({ a: 1, b: "2", c: null, d: undefined }).text // "('1', '2', NULL, DEFAULT)"
-     *  v.objectToValue({ a: 1, b: "2", c: null, d: undefined }, ["a", "b"]).text // "('1', '2')"
-     *  v.objectToValue(
-     *    { a: 1, b: "2", c: null, d: undefined },
-     *    { a: "INT", b: "TEXT", c: "JSONB", d: "TEXT" }
-     *  ).text // "('1'::INT, '2'::TEXT, NULL::JSONB, DEFAULT::TEXT)"
-     * ```
-     * @param keys - 如果指定了key, object undefined 的属性值将填充为 null，如果不指定，将自获取 object 所有非 undefined 的属性的key
-     */
-    objectToValue(object, keys) {
-        return this.createImplicitValues(object, keys);
-    }
     _getObjectValueInfo(object, keys_types) {
         let type;
         let keys;
@@ -224,7 +194,7 @@ class SqlValuesCreator {
             type = initColumnAssert(keys, keys_types);
         }
         else {
-            keys = Object.keys(object);
+            keys = Object.keys(object).filter((k) => object[k] !== undefined);
             type = [];
         }
         return { keys, type };
@@ -272,12 +242,6 @@ class SqlValuesCreator {
             throw new Error("values 不能为空");
         return values.map((v) => this.toSqlStr(v)).join(",");
     }
-    createValues(asName, values, valuesTypes) {
-        if (values.length === 0)
-            throw new Error("values 不能为空");
-        const res = this.createExplicitValues(values, valuesTypes); // 预检数据
-        return new SqlTextStatementDataset(res.toSelect(asName));
-    }
 }
 class AssertError extends TypeError {
     constructor(assertType, actual) {

package/dist/sql_gen/statement/cte.d.ts

@@ -1,10 +1,18 @@
 import { Constructable } from "../util.ts";
+import { SelectSqlGenerator } from "./select_chain.ts";
+import { UpdateSqlGenerator } from "./update_chain.ts";
+import { DeleteFromSqlGenerator } from "./delete_chain.ts";
+import { InsertIntoSqlGenerator } from "./insert_chain.ts";
 /**
  * @public
  */
 export interface ChainCTE {
     as(statement: Constructable<string>): ChainCTE;
     as(name: string, statement: Constructable<string>): ChainCTE;
+    select: SelectSqlGenerator;
+    update: UpdateSqlGenerator;
+    deleteFrom: DeleteFromSqlGenerator;
+    insertInto: InsertIntoSqlGenerator;
     toString(): string;
 }
 /**

package/dist/sql_gen/statement/cte.js

@@ -1,3 +1,9 @@
+import { selectColumns } from '../util.js';
+import { SelectChainAfterSelect } from './select_impl.js';
+import { DeleteChain } from './delete_impl.js';
+import { UpdateChain } from './update_impl.js';
+import { InsertChain } from './insert_impl.js';
+
 function withAs(nameOrStatement, statement) {
     return new ChainCETImpl(`WITH \n${concat(nameOrStatement, statement)}`);
 }
@@ -10,11 +16,35 @@ class ChainCETImpl {
         this.sql = sql;
     }
     as(nameOrStatement, statement) {
-        if (statement) {
-            return new ChainCETImpl(`${this.sql}\n${concat(nameOrStatement, statement)}`);
+        return new ChainCETImpl(`${this.sql},\n${concat(nameOrStatement, statement)}`);
+    }
+    select(columns) {
+        if (!columns)
+            return new SelectChainAfterSelect("SELECT ");
+        if (typeof columns === "function")
+            columns = columns();
+        return new SelectChainAfterSelect("SELECT " + selectColumns(columns));
+    }
+    update(table, options) {
+        let sql = `${this.sql}\nUPDATE ${table}`;
+        if (options?.as) {
+            sql += ` AS ${options.as}`;
+        }
+        return new UpdateChain(sql);
+    }
+    deleteFrom(table, option) {
+        let sql = `${this.sql}\nDELETE FROM ${table}`;
+        if (option?.as) {
+            sql += ` AS ${option.as}`;
+        }
+        return new DeleteChain(sql);
+    }
+    insertInto(table, columns) {
+        if (columns) {
+            return new InsertChain(`INSERT INTO ${table}(${columns.join(",")})`);
         }
         else {
-            return new ChainCETImpl(concat(nameOrStatement, statement));
+            return new InsertChain(`INSERT INTO ${table}`);
         }
     }
     toString() {

package/dist/sql_gen/statement/delete.d.ts

@@ -1,15 +1,4 @@
-import { ChainDelete } from "./delete_chain.ts";
+import { DeleteFromSqlGenerator } from "./delete_chain.ts";
 /** @public */
-export interface DeleteOption {
-    as?: string;
-}
-/**
- * @public
- * @example
- * ```ts
- * deleteFrom("table1").where("id = 1") // DELETE FROM table1 WHERE id = 1
- * deleteFrom("table1 AS t").where("t.id = 1") // DELETE FROM table1 AS t WHERE t.id = 1
- * ```
- */
-export declare function deleteFrom(table: string, option?: DeleteOption): ChainDelete;
+export declare const deleteFrom: DeleteFromSqlGenerator;
 //# sourceMappingURL=delete.d.ts.map

package/dist/sql_gen/statement/delete.js

@@ -1,46 +1,12 @@
-import { SqlStatement, SqlTextStatementDataset } from '../SqlStatement.js';
-import { returningToString, whereToString } from '../_statement.js';
+import { DeleteChain } from './delete_impl.js';
 
-/**
- * @public
- * @example
- * ```ts
- * deleteFrom("table1").where("id = 1") // DELETE FROM table1 WHERE id = 1
- * deleteFrom("table1 AS t").where("t.id = 1") // DELETE FROM table1 AS t WHERE t.id = 1
- * ```
- */
-function deleteFrom(table, option) {
+/** @public */
+const deleteFrom = function deleteFrom(table, option) {
     let sql = `DELETE FROM ${table}`;
     if (option?.as) {
         sql += ` AS ${option.as}`;
     }
     return new DeleteChain(sql);
-}
-class DeleteChain extends SqlStatement {
-    sql;
-    constructor(sql) {
-        super();
-        this.sql = sql;
-    }
-    using(...from) {
-        const textList = from.map((f, i) => {
-            if (typeof f === "function")
-                return f();
-            return f;
-        });
-        const sql = this.genSql() + `\nUSING ${textList.join(", ")}`;
-        return new DeleteChain(sql);
-    }
-    returning(returns) {
-        return new SqlTextStatementDataset(this.genSql() + returningToString(returns));
-    }
-    where(where) {
-        const sql = whereToString(where);
-        return new DeleteChain(this.genSql() + sql);
-    }
-    genSql() {
-        return this.sql;
-    }
-}
+};
 
 export { deleteFrom };

package/dist/sql_gen/statement/delete_chain.d.ts

@@ -1,6 +1,21 @@
 import { ConditionParam, Constructable } from "../util.ts";
 import { ChainModifyReturning } from "./_modify.ts";
 /** @public */
+export interface DeleteOption {
+    as?: string;
+}
+/**
+ * @public
+ * @example
+ * ```ts
+ * deleteFrom("table1").where("id = 1") // DELETE FROM table1 WHERE id = 1
+ * deleteFrom("table1 AS t").where("t.id = 1") // DELETE FROM table1 AS t WHERE t.id = 1
+ * ```
+ */
+export interface DeleteFromSqlGenerator {
+    (table: string, option?: DeleteOption): ChainDelete;
+}
+/** @public */
 export interface ChainDelete extends ChainDeleteAfterUsing {
     /**
      * @example

package/dist/sql_gen/statement/delete_impl.d.ts

@@ -0,0 +1,12 @@
+import { ConditionParam, Constructable, SelectParam } from "../util.ts";
+import { SqlStatementDataset, SqlStatement } from "../SqlStatement.ts";
+import { ChainDelete, ChainDeleteAfterUsing, ChainDeleteReturning } from "./delete_chain.ts";
+export declare class DeleteChain extends SqlStatement implements ChainDelete {
+    readonly sql: string;
+    constructor(sql: string);
+    using(...from: Constructable<string>[]): ChainDeleteAfterUsing;
+    returning<R extends {}>(returns: Constructable<SelectParam | "*">): SqlStatementDataset<R>;
+    where(where: Constructable<ConditionParam | void>): ChainDeleteReturning;
+    genSql(): string;
+}
+//# sourceMappingURL=delete_impl.d.ts.map

package/dist/sql_gen/statement/delete_impl.js

@@ -0,0 +1,31 @@
+import { SqlStatement, SqlTextStatementDataset } from '../SqlStatement.js';
+import { returningToString, whereToString } from '../_statement.js';
+
+class DeleteChain extends SqlStatement {
+    sql;
+    constructor(sql) {
+        super();
+        this.sql = sql;
+    }
+    using(...from) {
+        const textList = from.map((f, i) => {
+            if (typeof f === "function")
+                return f();
+            return f;
+        });
+        const sql = this.genSql() + `\nUSING ${textList.join(", ")}`;
+        return new DeleteChain(sql);
+    }
+    returning(returns) {
+        return new SqlTextStatementDataset(this.genSql() + returningToString(returns));
+    }
+    where(where) {
+        const sql = whereToString(where);
+        return new DeleteChain(this.genSql() + sql);
+    }
+    genSql() {
+        return this.sql;
+    }
+}
+
+export { DeleteChain };

package/dist/sql_gen/statement/insert.d.ts

@@ -1,6 +1,4 @@
-import { ChainInsert } from "./insert_chain.ts";
+import { InsertIntoSqlGenerator } from "./insert_chain.ts";
 /** @public */
-export declare function insertInto(target: string): ChainInsert;
-/** @public */
-export declare function insertInto(table: string, columns: readonly string[]): ChainInsert;
+export declare const insertInto: InsertIntoSqlGenerator;
 //# sourceMappingURL=insert.d.ts.map

package/dist/sql_gen/statement/insert.js

@@ -1,107 +1,13 @@
-import { selectColumns } from '../util.js';
-import { whereToString, createUpdateSetFromObject } from '../_statement.js';
-import { SqlStatement, SqlTextStatementDataset } from '../SqlStatement.js';
+import { InsertChain } from './insert_impl.js';
 
-function insertInto(table, columns) {
+/** @public */
+const insertInto = function insertInto(table, columns) {
     if (columns) {
         return new InsertChain(`INSERT INTO ${table}(${columns.join(",")})`);
     }
     else {
         return new InsertChain(`INSERT INTO ${table}`);
     }
-}
-class InsertChain extends SqlStatement {
-    sql;
-    constructor(sql) {
-        super();
-        this.sql = sql;
-    }
-    values(statement) {
-        if (typeof statement === "function")
-            statement = statement();
-        switch (typeof statement) {
-            case "object":
-                if (statement instanceof Array) {
-                    statement = statement.join(",\n");
-                }
-                else {
-                    throw new TypeError("参数 statement 类型错误");
-                }
-                break;
-            case "string":
-                break;
-            default:
-                throw new TypeError("参数 statement 类型错误");
-        }
-        return new InsertChain(this.sql + `\nVALUES\n${statement}`);
-    }
-    select(statement) {
-        if (typeof statement === "function")
-            statement = statement();
-        return new InsertChain(this.sql + `\n${statement}`);
-    }
-    returning(returns) {
-        if (typeof returns === "function")
-            returns = returns();
-        let columnsStr;
-        if (returns === "*") {
-            columnsStr = "*";
-        }
-        else {
-            columnsStr = selectColumns(returns);
-        }
-        let sql = this.genSql() + "\nRETURNING " + columnsStr;
-        return new SqlTextStatementDataset(sql);
-    }
-    onConflict(onConflict) {
-        if (typeof onConflict === "function")
-            onConflict = onConflict();
-        if (typeof onConflict !== "string")
-            onConflict = onConflict.join(",");
-        let sql = this.genSql() + `\nON CONFLICT (${onConflict})`;
-        return new InsertAfterOnConflict(sql);
-    }
-    where(where) {
-        const sql = whereToString(where);
-        return new InsertChain(this.genSql() + sql);
-    }
-    genSql() {
-        return this.sql;
-    }
-}
-class InsertAfterOnConflict {
-    sql;
-    constructor(sql) {
-        this.sql = sql;
-    }
-    doUpdate(set) {
-        if (typeof set === "function")
-            set = set();
-        let sql;
-        switch (typeof set) {
-            case "object": {
-                if (set instanceof Array) {
-                    sql = "\nDO UPDATE SET " + set.join(", ");
-                }
-                else {
-                    sql = "\nDO UPDATE " + createUpdateSetFromObject(set);
-                }
-                break;
-            }
-            case "string":
-                sql = "\nDO UPDATE " + set;
-                break;
-            default:
-                throw new TypeError("参数 set 类型错误");
-        }
-        return new InsertChain(this.sql + sql);
-    }
-    doNotThing() {
-        return new InsertChain(this.sql + " DO NOTHING");
-    }
-    toString() {
-        return this.sql;
-    }
-}
+};
 
 export { insertInto };

package/dist/sql_gen/statement/insert_chain.d.ts

@@ -1,6 +1,11 @@
 import { Constructable } from "../util.ts";
 import { ChainModifyReturning } from "./_modify.ts";
 /** @public */
+export interface InsertIntoSqlGenerator {
+    (target: string): ChainInsert;
+    (table: string, columns: readonly string[]): ChainInsert;
+}
+/** @public */
 export interface ChainAfterConflict {
     doNotThing(): ChainInsertReturning;
     doUpdate(set: Constructable<string | readonly string[] | Record<string, string>>): ChainInsertReturning;

package/dist/sql_gen/statement/insert_impl.d.ts

@@ -0,0 +1,14 @@
+import { ConditionParam, Constructable, SelectParam } from "../util.ts";
+import { SqlStatementDataset, SqlStatement } from "../SqlStatement.ts";
+import { ChainAfterConflict, ChainInsert, ChainInsertAfterValues, ChainInsertReturning } from "./insert_chain.ts";
+export declare class InsertChain extends SqlStatement implements ChainInsert {
+    private sql;
+    constructor(sql: string);
+    values(statement: Constructable<string | readonly string[]>): ChainInsertAfterValues;
+    select(statement: Constructable<string>): ChainInsertAfterValues;
+    returning<R extends {}>(returns: Constructable<SelectParam | "*">): SqlStatementDataset<R>;
+    onConflict(onConflict: Constructable<readonly string[] | string>): ChainAfterConflict;
+    where(where: Constructable<ConditionParam | void>): ChainInsertReturning;
+    genSql(): string;
+}
+//# sourceMappingURL=insert_impl.d.ts.map

package/dist/sql_gen/statement/insert_impl.js

@@ -0,0 +1,99 @@
+import { selectColumns } from '../util.js';
+import { whereToString, createUpdateSetFromObject } from '../_statement.js';
+import { SqlStatement, SqlTextStatementDataset } from '../SqlStatement.js';
+
+class InsertChain extends SqlStatement {
+    sql;
+    constructor(sql) {
+        super();
+        this.sql = sql;
+    }
+    values(statement) {
+        if (typeof statement === "function")
+            statement = statement();
+        switch (typeof statement) {
+            case "object":
+                if (statement instanceof Array) {
+                    statement = statement.join(",\n");
+                }
+                else {
+                    throw new TypeError("参数 statement 类型错误");
+                }
+                break;
+            case "string":
+                break;
+            default:
+                throw new TypeError("参数 statement 类型错误");
+        }
+        return new InsertChain(this.sql + `\nVALUES\n${statement}`);
+    }
+    select(statement) {
+        if (typeof statement === "function")
+            statement = statement();
+        return new InsertChain(this.sql + `\n${statement}`);
+    }
+    returning(returns) {
+        if (typeof returns === "function")
+            returns = returns();
+        let columnsStr;
+        if (returns === "*") {
+            columnsStr = "*";
+        }
+        else {
+            columnsStr = selectColumns(returns);
+        }
+        let sql = this.genSql() + "\nRETURNING " + columnsStr;
+        return new SqlTextStatementDataset(sql);
+    }
+    onConflict(onConflict) {
+        if (typeof onConflict === "function")
+            onConflict = onConflict();
+        if (typeof onConflict !== "string")
+            onConflict = onConflict.join(",");
+        let sql = this.genSql() + `\nON CONFLICT (${onConflict})`;
+        return new InsertAfterOnConflict(sql);
+    }
+    where(where) {
+        const sql = whereToString(where);
+        return new InsertChain(this.genSql() + sql);
+    }
+    genSql() {
+        return this.sql;
+    }
+}
+class InsertAfterOnConflict {
+    sql;
+    constructor(sql) {
+        this.sql = sql;
+    }
+    doUpdate(set) {
+        if (typeof set === "function")
+            set = set();
+        let sql;
+        switch (typeof set) {
+            case "object": {
+                if (set instanceof Array) {
+                    sql = "\nDO UPDATE SET " + set.join(", ");
+                }
+                else {
+                    sql = "\nDO UPDATE " + createUpdateSetFromObject(set);
+                }
+                break;
+            }
+            case "string":
+                sql = "\nDO UPDATE " + set;
+                break;
+            default:
+                throw new TypeError("参数 set 类型错误");
+        }
+        return new InsertChain(this.sql + sql);
+    }
+    doNotThing() {
+        return new InsertChain(this.sql + " DO NOTHING");
+    }
+    toString() {
+        return this.sql;
+    }
+}
+
+export { InsertChain };

package/dist/sql_gen/statement/select.d.ts

@@ -1,38 +1,5 @@
-import { Constructable, TableType } from "../util.ts";
-import { ChainSelect, OrderByParam } from "./select_chain.ts";
+import { SelectSqlGenerator } from "./select_chain.ts";
 /** @public */
-export declare function select(columns?: undefined | ""): ChainSelect<{}>;
-/** @public */
-export declare function select<T extends TableType>(columns: "*"): ChainSelect<T>;
-/** @public */
-export declare function select<T extends TableType>(columns: Constructable<{
-    [key in keyof T]: string | boolean;
-}>): ChainSelect<T>;
-/** @public */
-export declare function select<T extends TableType>(columns: Constructable<string | string[]>): ChainSelect<T>;
-/** @public */
-export declare function select<T extends TableType>(columns: Constructable<string | readonly string[] | {
-    readonly [key in keyof T]: string | boolean;
-}>): ChainSelect<T>;
-/**
- * 生成 ORDER BY 语句
- * @public
- * @example
- * ```ts
- *
- * orderBy([]) // ""
- * orderBy({}) // ""
- * orderBy() // ""
- *
- * // 以下生成 "\nORDER BY age DESC NULLS FIRST,num ASC"
- * orderBy("age DESC NULLS FIRST,num ASC");
- * orderBy(["age DESC NULLS FIRST", "num ASC"]);
- * orderBy([
- *    { key: "age", asc: false, nullLast: false },
- *    { key: "num", asc: true },
- *  ]);
- *
- * ```
- */
-export declare function orderBy(by?: Constructable<OrderByParam | void>): string;
+export declare const select: SelectSqlGenerator;
+export { orderBy } from "./select_impl.ts";
 //# sourceMappingURL=select.d.ts.map

package/dist/sql_gen/statement/select.js

@@ -1,154 +1,14 @@
 import { selectColumns } from '../util.js';
-import { selectableToString, whereToString, condition } from '../_statement.js';
-import { SqlTextStatementDataset } from '../SqlStatement.js';
+import { SelectChainAfterSelect } from './select_impl.js';
+export { orderBy } from './select_impl.js';
 
-function select(columns) {
+/** @public */
+const select = function select(columns) {
     if (!columns)
         return new SelectChainAfterSelect("SELECT ");
     if (typeof columns === "function")
         columns = columns();
     return new SelectChainAfterSelect("SELECT " + selectColumns(columns));
-}
-class SelectChainAfterSelect {
-    constructor(sql) {
-        this.#sql = sql;
-    }
-    #sql;
-    from(selectable, option = {}) {
-        let sql = this.#sql + "\nFROM " + selectableToString(selectable, option.as);
-        return new SelectChain(sql);
-    }
-    toString() {
-        return this.#sql;
-    }
-}
-class SelectChain extends SqlTextStatementDataset {
-    constructor(sql) {
-        super(sql);
-    }
-    from(selectable, option = {}) {
-        let sql = this.genSql() + ", " + selectableToString(selectable, option.as);
-        return new SelectChain(sql);
-    }
-    fullJoin(selectable, options) {
-        return joinToString(this.genSql() + "\nFULL JOIN ", selectable, options);
-    }
-    innerJoin(selectable, options) {
-        return joinToString(this.genSql() + "\nINNER JOIN ", selectable, options);
-    }
-    leftJoin(selectable, options) {
-        return joinToString(this.genSql() + "\nLEFT JOIN ", selectable, options);
-    }
-    rightJoin(selectable, options) {
-        return joinToString(this.genSql() + "\nRIGHT JOIN ", selectable, options);
-    }
-    naturalJoin(selectable, options) {
-        return joinToString(this.genSql() + "\nNATURAL JOIN ", selectable, options);
-    }
-    crossJoin(selectable, options) {
-        return joinToString(this.genSql() + "\nCROSS JOIN ", selectable, options);
-    }
-    where(param) {
-        return new SelectChain(this.genSql() + whereToString(param));
-    }
-    groupBy(columns) {
-        let add;
-        if (typeof columns === "string")
-            add = columns;
-        else if (columns)
-            add = columns.join(",");
-        if (!add)
-            return new SelectChain(this.genSql());
-        return new SelectChain(this.genSql() + "\nGROUP BY " + add);
-    }
-    having(param) {
-        return new SelectChain(this.genSql() + havingToString(param));
-    }
-    orderBy(param) {
-        return new SelectChain(this.genSql() + orderBy(param));
-    }
-    limit(limit, offset) {
-        let sql = this.genSql();
-        let type;
-        type = typeof limit;
-        if (type === "number" || type === "bigint")
-            sql += "\nLIMIT " + limit;
-        type = typeof offset;
-        if (type === "number" || type === "bigint")
-            sql += "\nOFFSET " + offset;
-        return new SqlTextStatementDataset(sql);
-    }
-}
-function joinToString(sql, selectable, options = {}) {
-    sql += selectableToString(selectable, options.as);
-    if (options.on) {
-        let on = options.on;
-        if (typeof on === "function")
-            on = on();
-        sql += " ON " + condition(on);
-    }
-    return new SelectChain(sql);
-}
-function havingToString(conditions, type) {
-    const sql = condition(conditions, type);
-    if (sql)
-        return "\nHAVING " + sql;
-    return "";
-}
-/**
- * 生成 ORDER BY 语句
- * @public
- * @example
- * ```ts
- *
- * orderBy([]) // ""
- * orderBy({}) // ""
- * orderBy() // ""
- *
- * // 以下生成 "\nORDER BY age DESC NULLS FIRST,num ASC"
- * orderBy("age DESC NULLS FIRST,num ASC");
- * orderBy(["age DESC NULLS FIRST", "num ASC"]);
- * orderBy([
- *    { key: "age", asc: false, nullLast: false },
- *    { key: "num", asc: true },
- *  ]);
- *
- * ```
- */
-function orderBy(by) {
-    if (typeof by === "function")
-        by = by();
-    let sql = "";
-    if (!by)
-        return sql;
-    if (typeof by === "string") {
-        sql += "\nORDER BY " + by;
-    }
-    else if (by instanceof Array) {
-        if (by.length) {
-            sql += "\nORDER BY " + handlerOrderValue(by[0]);
-            for (let i = 1; i < by.length; i++)
-                sql += "," + handlerOrderValue(by[i]);
-        }
-    }
-    else {
-        sql += "\nORDER BY " + handlerOrderValue(by);
-    }
-    return sql;
-}
-function handlerOrderValue(value) {
-    if (typeof value === "string")
-        return value;
-    let target;
-    if (value.target) {
-        target = value.target;
-    }
-    else {
-        target = value.asc ? "ASC" : "DESC";
-        if (value.nullLast !== undefined)
-            target += value.nullLast ? " NULLS LAST" : " NULLS FIRST";
-    }
-    return value.key + " " + target;
-}
+};
 
-export { orderBy, select };
+export { select };

package/dist/sql_gen/statement/select_chain.d.ts

@@ -1,6 +1,18 @@
 import { ConditionParam, Constructable, TableType } from "../util.ts";
 import { SqlSelectable, SqlStatementDataset } from "../SqlStatement.ts";
 /** @public */
+export interface SelectSqlGenerator {
+    (columns?: undefined | ""): ChainSelect<{}>;
+    <T extends TableType>(columns: "*"): ChainSelect<T>;
+    <T extends TableType>(columns: Constructable<{
+        [key in keyof T]: string | boolean;
+    }>): ChainSelect<T>;
+    <T extends TableType>(columns: Constructable<string | string[]>): ChainSelect<T>;
+    <T extends TableType>(columns: Constructable<string | readonly string[] | {
+        readonly [key in keyof T]: string | boolean;
+    }>): ChainSelect<T>;
+}
+/** @public */
 export type SelectAsNameOption = {
     as?: string;
 };

package/dist/sql_gen/statement/select_impl.d.ts

@@ -0,0 +1,31 @@
+import { Constructable, TableType } from "../util.ts";
+import { SqlSelectable } from "../SqlStatement.ts";
+import { ChainSelectAfterFirstFrom, ChainSelect, SelectAsNameOption, OrderByParam } from "./select_chain.ts";
+export declare class SelectChainAfterSelect<T extends TableType> implements ChainSelect<T> {
+    #private;
+    constructor(sql: string);
+    from(selectable: Constructable<SqlSelectable | string>, option?: SelectAsNameOption): ChainSelectAfterFirstFrom<T>;
+    toString(): string;
+}
+/**
+ * 生成 ORDER BY 语句
+ * @public
+ * @example
+ * ```ts
+ *
+ * orderBy([]) // ""
+ * orderBy({}) // ""
+ * orderBy() // ""
+ *
+ * // 以下生成 "\nORDER BY age DESC NULLS FIRST,num ASC"
+ * orderBy("age DESC NULLS FIRST,num ASC");
+ * orderBy(["age DESC NULLS FIRST", "num ASC"]);
+ * orderBy([
+ *    { key: "age", asc: false, nullLast: false },
+ *    { key: "num", asc: true },
+ *  ]);
+ *
+ * ```
+ */
+export declare function orderBy(by?: Constructable<OrderByParam | void>): string;
+//# sourceMappingURL=select_impl.d.ts.map

package/dist/sql_gen/statement/select_impl.js

@@ -0,0 +1,146 @@
+import { selectableToString, whereToString, condition } from '../_statement.js';
+import { SqlTextStatementDataset } from '../SqlStatement.js';
+
+class SelectChainAfterSelect {
+    constructor(sql) {
+        this.#sql = sql;
+    }
+    #sql;
+    from(selectable, option = {}) {
+        let sql = this.#sql + "\nFROM " + selectableToString(selectable, option.as);
+        return new SelectChain(sql);
+    }
+    toString() {
+        return this.#sql;
+    }
+}
+class SelectChain extends SqlTextStatementDataset {
+    constructor(sql) {
+        super(sql);
+    }
+    from(selectable, option = {}) {
+        let sql = this.genSql() + ", " + selectableToString(selectable, option.as);
+        return new SelectChain(sql);
+    }
+    fullJoin(selectable, options) {
+        return joinToString(this.genSql() + "\nFULL JOIN ", selectable, options);
+    }
+    innerJoin(selectable, options) {
+        return joinToString(this.genSql() + "\nINNER JOIN ", selectable, options);
+    }
+    leftJoin(selectable, options) {
+        return joinToString(this.genSql() + "\nLEFT JOIN ", selectable, options);
+    }
+    rightJoin(selectable, options) {
+        return joinToString(this.genSql() + "\nRIGHT JOIN ", selectable, options);
+    }
+    naturalJoin(selectable, options) {
+        return joinToString(this.genSql() + "\nNATURAL JOIN ", selectable, options);
+    }
+    crossJoin(selectable, options) {
+        return joinToString(this.genSql() + "\nCROSS JOIN ", selectable, options);
+    }
+    where(param) {
+        return new SelectChain(this.genSql() + whereToString(param));
+    }
+    groupBy(columns) {
+        let add;
+        if (typeof columns === "string")
+            add = columns;
+        else if (columns)
+            add = columns.join(",");
+        if (!add)
+            return new SelectChain(this.genSql());
+        return new SelectChain(this.genSql() + "\nGROUP BY " + add);
+    }
+    having(param) {
+        return new SelectChain(this.genSql() + havingToString(param));
+    }
+    orderBy(param) {
+        return new SelectChain(this.genSql() + orderBy(param));
+    }
+    limit(limit, offset) {
+        let sql = this.genSql();
+        let type;
+        type = typeof limit;
+        if (type === "number" || type === "bigint")
+            sql += "\nLIMIT " + limit;
+        type = typeof offset;
+        if (type === "number" || type === "bigint")
+            sql += "\nOFFSET " + offset;
+        return new SqlTextStatementDataset(sql);
+    }
+}
+function joinToString(sql, selectable, options = {}) {
+    sql += selectableToString(selectable, options.as);
+    if (options.on) {
+        let on = options.on;
+        if (typeof on === "function")
+            on = on();
+        sql += " ON " + condition(on);
+    }
+    return new SelectChain(sql);
+}
+function havingToString(conditions, type) {
+    const sql = condition(conditions, type);
+    if (sql)
+        return "\nHAVING " + sql;
+    return "";
+}
+/**
+ * 生成 ORDER BY 语句
+ * @public
+ * @example
+ * ```ts
+ *
+ * orderBy([]) // ""
+ * orderBy({}) // ""
+ * orderBy() // ""
+ *
+ * // 以下生成 "\nORDER BY age DESC NULLS FIRST,num ASC"
+ * orderBy("age DESC NULLS FIRST,num ASC");
+ * orderBy(["age DESC NULLS FIRST", "num ASC"]);
+ * orderBy([
+ *    { key: "age", asc: false, nullLast: false },
+ *    { key: "num", asc: true },
+ *  ]);
+ *
+ * ```
+ */
+function orderBy(by) {
+    if (typeof by === "function")
+        by = by();
+    let sql = "";
+    if (!by)
+        return sql;
+    if (typeof by === "string") {
+        sql += "\nORDER BY " + by;
+    }
+    else if (by instanceof Array) {
+        if (by.length) {
+            sql += "\nORDER BY " + handlerOrderValue(by[0]);
+            for (let i = 1; i < by.length; i++)
+                sql += "," + handlerOrderValue(by[i]);
+        }
+    }
+    else {
+        sql += "\nORDER BY " + handlerOrderValue(by);
+    }
+    return sql;
+}
+function handlerOrderValue(value) {
+    if (typeof value === "string")
+        return value;
+    let target;
+    if (value.target) {
+        target = value.target;
+    }
+    else {
+        target = value.asc ? "ASC" : "DESC";
+        if (value.nullLast !== undefined)
+            target += value.nullLast ? " NULLS LAST" : " NULLS FIRST";
+    }
+    return value.key + " " + target;
+}
+
+export { SelectChainAfterSelect, orderBy };

package/dist/sql_gen/statement/update.d.ts

@@ -1,17 +1,4 @@
-import { TableType } from "../util.ts";
-import { ChainUpdate } from "./update_chain.ts";
+import { UpdateSqlGenerator } from "./update_chain.ts";
 /** @public */
-export interface UpdateOption {
-    as?: string;
-}
-/**
- * @public
- * @example
- * ```ts
- *  update("table1 AS t").where("t.id = b.id") // UPDATE table1 AS t WHERE t.id = b.id
- *  update("table1",{ as: "t" }).set({ k:"'v'"}) // UPDATE table1 AS t SET t.k = 'v'
- *  update("table1").where("id = 1") // UPDATE table1 AS t WHERE id = 1
- * ```
- */
-export declare function update<T extends TableType>(table: string, options?: UpdateOption): ChainUpdate<T>;
+export declare const update: UpdateSqlGenerator;
 //# sourceMappingURL=update.d.ts.map

package/dist/sql_gen/statement/update.js

@@ -1,88 +1,12 @@
-import { selectColumns } from '../util.js';
-import { SqlStatement, SqlTextStatementDataset } from '../SqlStatement.js';
-import { createUpdateSetFromObject, whereToString } from '../_statement.js';
+import { UpdateChain } from './update_impl.js';
 
-/**
- * @public
- * @example
- * ```ts
- *  update("table1 AS t").where("t.id = b.id") // UPDATE table1 AS t WHERE t.id = b.id
- *  update("table1",{ as: "t" }).set({ k:"'v'"}) // UPDATE table1 AS t SET t.k = 'v'
- *  update("table1").where("id = 1") // UPDATE table1 AS t WHERE id = 1
- * ```
- */
-function update(table, options) {
+/** @public */
+const update = function update(table, options) {
     let sql = `UPDATE ${table}`;
     if (options?.as) {
         sql += ` AS ${options.as}`;
     }
     return new UpdateChain(sql);
-}
-class UpdateChain extends SqlStatement {
-    sql;
-    constructor(sql) {
-        super();
-        this.sql = sql;
-    }
-    from(...from) {
-        const textList = from.map((f, i) => {
-            if (typeof f === "function")
-                return f();
-            return f;
-        });
-        const sql = this.genSql() + `\nFROM ${textList.join(", ")}`;
-        return new UpdateChain(sql);
-    }
-    /**
-     * @example
-     * ```ts
-     * // SET age=3, name='hi', count=b.count
-     * set({age: "3", name: "'hi'", count:"b.count"})
-     * set(["age = 3", "name = 'hi'", "count = b.count"])
-     * set("age = 3, name = 'hi', count = b.count")
-     *
-     * ```
-     */
-    set(values) {
-        if (typeof values === "function")
-            values = values();
-        switch (typeof values) {
-            case "object": {
-                if (values instanceof Array) {
-                    let sql = values.join(", ");
-                    return new UpdateChain(this.sql + " " + sql);
-                }
-                else {
-                    let sql = createUpdateSetFromObject(values);
-                    return new UpdateChain(this.sql + " " + sql);
-                }
-            }
-            case "string":
-                return new UpdateChain(this.sql + " SET\n" + values);
-            default:
-                throw new TypeError("参数 values 类型错误");
-        }
-    }
-    returning(returns) {
-        if (typeof returns === "function")
-            returns = returns();
-        let columnsStr;
-        if (returns === "*") {
-            columnsStr = "*";
-        }
-        else {
-            columnsStr = selectColumns(returns);
-        }
-        let sql = this.genSql() + "\nRETURNING " + columnsStr;
-        return new SqlTextStatementDataset(sql);
-    }
-    where(where) {
-        const sql = whereToString(where);
-        return new UpdateChain(this.genSql() + sql);
-    }
-    genSql() {
-        return this.sql;
-    }
-}
+};
 
 export { update };

package/dist/sql_gen/statement/update_chain.d.ts

@@ -1,6 +1,22 @@
 import { ConditionParam, Constructable, TableType } from "../util.ts";
 import { ChainModifyReturning } from "./_modify.ts";
 /** @public */
+export interface UpdateOption {
+    as?: string;
+}
+/**
+ * @public
+ * @example
+ * ```ts
+ *  update("table1 AS t").where("t.id = b.id") // UPDATE table1 AS t WHERE t.id = b.id
+ *  update("table1",{ as: "t" }).set({ k:"'v'"}) // UPDATE table1 AS t SET t.k = 'v'
+ *  update("table1").where("id = 1") // UPDATE table1 AS t WHERE id = 1
+ * ```
+ */
+export interface UpdateSqlGenerator {
+    <T extends TableType>(table: string, options?: UpdateOption): ChainUpdate<T>;
+}
+/** @public */
 export interface ChainUpdate<T extends TableType = TableType> {
     set(value: Constructable<{
         [key in keyof T]?: string;

package/dist/sql_gen/statement/update_impl.d.ts

@@ -0,0 +1,23 @@
+import { ConditionParam, Constructable, SelectParam } from "../util.ts";
+import { SqlStatementDataset, SqlStatement } from "../SqlStatement.ts";
+import { ChainUpdate, ChainUpdateAfterForm, ChainUpdateAfterSet, ChainUpdateReturning } from "./update_chain.ts";
+export declare class UpdateChain extends SqlStatement implements ChainUpdate {
+    private sql;
+    constructor(sql: string);
+    from(...from: Constructable<string>[]): ChainUpdateAfterForm;
+    /**
+     * @example
+     * ```ts
+     * // SET age=3, name='hi', count=b.count
+     * set({age: "3", name: "'hi'", count:"b.count"})
+     * set(["age = 3", "name = 'hi'", "count = b.count"])
+     * set("age = 3, name = 'hi', count = b.count")
+     *
+     * ```
+     */
+    set(values: Constructable<Record<string, string | undefined> | string[] | string>): ChainUpdateAfterSet;
+    returning<R extends {}>(returns: Constructable<SelectParam | "*">): SqlStatementDataset<R>;
+    where(where: Constructable<ConditionParam | void>): ChainUpdateReturning;
+    genSql(): string;
+}
+//# sourceMappingURL=update_impl.d.ts.map

package/dist/sql_gen/statement/update_impl.js

@@ -0,0 +1,72 @@
+import { selectColumns } from '../util.js';
+import { SqlStatement, SqlTextStatementDataset } from '../SqlStatement.js';
+import { createUpdateSetFromObject, whereToString } from '../_statement.js';
+
+class UpdateChain extends SqlStatement {
+    sql;
+    constructor(sql) {
+        super();
+        this.sql = sql;
+    }
+    from(...from) {
+        const textList = from.map((f, i) => {
+            if (typeof f === "function")
+                return f();
+            return f;
+        });
+        const sql = this.genSql() + `\nFROM ${textList.join(", ")}`;
+        return new UpdateChain(sql);
+    }
+    /**
+     * @example
+     * ```ts
+     * // SET age=3, name='hi', count=b.count
+     * set({age: "3", name: "'hi'", count:"b.count"})
+     * set(["age = 3", "name = 'hi'", "count = b.count"])
+     * set("age = 3, name = 'hi', count = b.count")
+     *
+     * ```
+     */
+    set(values) {
+        if (typeof values === "function")
+            values = values();
+        switch (typeof values) {
+            case "object": {
+                if (values instanceof Array) {
+                    let sql = values.join(", ");
+                    return new UpdateChain(this.sql + " " + sql);
+                }
+                else {
+                    let sql = createUpdateSetFromObject(values);
+                    return new UpdateChain(this.sql + " " + sql);
+                }
+            }
+            case "string":
+                return new UpdateChain(this.sql + " SET\n" + values);
+            default:
+                throw new TypeError("参数 values 类型错误");
+        }
+    }
+    returning(returns) {
+        if (typeof returns === "function")
+            returns = returns();
+        let columnsStr;
+        if (returns === "*") {
+            columnsStr = "*";
+        }
+        else {
+            columnsStr = selectColumns(returns);
+        }
+        let sql = this.genSql() + "\nRETURNING " + columnsStr;
+        return new SqlTextStatementDataset(sql);
+    }
+    where(where) {
+        const sql = whereToString(where);
+        return new UpdateChain(this.genSql() + sql);
+    }
+    genSql() {
+        return this.sql;
+    }
+}
+
+export { UpdateChain };

package/package.json

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