@asla/yoursql 0.9.2 → 0.10.0

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

@@ -0,0 +1,36 @@
+import { ConditionParam, Constructable, TableType } from "../util.ts";
+import { ChainModifyReturning } from "./_modify.ts";
+/** @public */
+export interface ChainUpdate<T extends TableType = TableType> {
+    set(value: Constructable<{
+        [key in keyof T]?: string;
+    } | string>): ChainUpdateAfterSet;
+}
+/** @public */
+export interface ChainUpdateAfterSet extends ChainUpdateAfterForm {
+    /**
+     * @example
+     * ```ts
+     *
+     * update({age: "3", name: "'hi'", count:"b.count"}, "a")
+     *  .from("table1 AS b", "(SELECT k FROM table2) AS c")
+     *  .where(...)
+     * // UPDATE table AS a
+     * // FROM table1 AS b, (SELECT k FROM table2) AS c
+     * // SET a.age=3, a.name='hi', a.count=b.count
+     * // WHERE ...
+     * ```
+     */
+    from(...table: (Constructable<string> | {
+        selectable: Constructable<string>;
+        as: string;
+    })[]): ChainUpdateAfterForm;
+}
+/** @public */
+export interface ChainUpdateAfterForm extends ChainUpdateReturning {
+    where(where: Constructable<ConditionParam | void>): ChainUpdateReturning;
+}
+/** @public */
+export interface ChainUpdateReturning extends ChainModifyReturning {
+}
+//# sourceMappingURL=update_chain.d.ts.map

package/dist/sql_gen/util.d.ts

@@ -1,34 +1,7 @@
-import { OrderValue } from "./select/type.ts";
-/**
- * 获取对象数组中的 key 的集合
- * @public
- * @param keepUndefinedKey - 是否保留值为 undefined 的 key
- */
-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?: Constructable<ConditionParam | void>, type?: "AND" | "OR"): string;
-/**
- *
- * 生成 HAVING 语句
- * @public
- */
-export declare function having(conditions?: Constructable<ConditionParam | void>, type?: "AND" | "OR"): string;
+/** @public */
+export type Constructable<T> = T | (() => T);
 /** @public */
 export type SelectParam = string | string[] | Record<string, string | boolean>;
 /**
@@ -40,31 +13,25 @@ export type SelectParam = string | string[] | Record<string, string | boolean>;
  * ```
  */
 export declare function selectColumns(columns: Constructable<SelectParam>): string;
-/** @public */
-export type OrderBehavior = {
-    key: string;
-    asc: boolean;
-    nullLast?: boolean;
-};
-/** @public */
-export type OrderByParam = string | (string | OrderBehavior)[] | Record<string, boolean | `${OrderValue} ${"NULLS FIRST" | "NULLS LAST"}`>;
 /**
- * 生成 ORDER BY 语句, d
+ * 推断表插入类型
  * @public
- * @example
- * ```ts
- * // 以下生成 "\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 },
- *  ]);
- * orderBy({ age: "DESC NULLS FIRST", num: true });
- *
- * orderBy([]) // ""
- * orderBy({}) // ""
- * ```
+ * @param T - 表格创建类型
+ * @param Pa - 可选列
  */
-export declare function orderBy(by?: Constructable<OrderByParam | void>): string;
+export type ToInsertType<T extends {
+    [key: string]: any;
+}, Pa extends keyof T = never> = {
+    [key in keyof T as key extends Pa ? never : null extends T[key] ? never : key]: T[key];
+} & {
+    [key in keyof T as null extends T[key] ? key : key extends Pa ? key : never]?: T[key];
+};
+/** @public */
+export type UpdateRowValue<T extends object> = {
+    [key in keyof T]?: T[key] | String;
+};
+/** @public */
+export type TableType = {
+    [key: string]: any;
+};
 //# sourceMappingURL=util.d.ts.map

package/dist/sql_gen/util.js

@@ -1,57 +1,3 @@
-import { condition } from './select/_statement.js';
-
-/**
- * 获取对象数组中的 key 的集合
- * @public
- * @param keepUndefinedKey - 是否保留值为 undefined 的 key
- */
-function getObjectListKeys(objectList, keepUndefinedKey) {
-    let keys = new Set();
-    for (let i = 0; i < objectList.length; i++) {
-        let obj = objectList[i];
-        let hasKeys = Object.keys(obj);
-        let k;
-        for (let j = 0; j < hasKeys.length; j++) {
-            k = hasKeys[j];
-            if (typeof k !== "string")
-                continue;
-            if (!keepUndefinedKey && obj[k] === undefined)
-                continue;
-            keys.add(k);
-        }
-    }
-    return keys;
-}
-/**
- * 生成 WHERE 语句
- * @public
- * @example
- * ```ts
- * where(['a=1','b=2']) // "\nWHERE a=1 AND b=2"
- * where(['a=1','b=2'],"OR") // "\nWHERE a=1 OR b=2"
- * where("a=1 OR b=2") // "\nWHERE a=1 OR b=2"
- * where(()=>"a=1 OR b=2") // "\nWHERE a=1 AND b=2"
- * where([]) // ""
- * where(undefined) // ""
- * ```
- */
-function where(conditions, type) {
-    const sql = condition(conditions, type);
-    if (sql)
-        return "\nWHERE " + sql;
-    return "";
-}
-/**
- *
- * 生成 HAVING 语句
- * @public
- */
-function having(conditions, type) {
-    const sql = condition(conditions, type);
-    if (sql)
-        return "\nHAVING " + sql;
-    return "";
-}
 /**
  * @public
  * @example
@@ -99,68 +45,5 @@ function selectColumns(columns) {
             throw new TypeError("columns 应为 string 或 object 类型");
     }
 }
-/**
- * 生成 ORDER BY 语句, d
- * @public
- * @example
- * ```ts
- * // 以下生成 "\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 },
- *  ]);
- * orderBy({ age: "DESC NULLS FIRST", num: true });
- *
- * orderBy([]) // ""
- * orderBy({}) // ""
- * ```
- */
-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 {
-        let keys = Object.keys(by);
-        if (keys.length) {
-            let key = keys[0];
-            let value = by[key];
-            sql += "\nORDER BY " + key + " " + (typeof value === "string" ? value : value ? "ASC" : "DESC");
-            for (let i = 1; i < keys.length; i++) {
-                key = keys[i];
-                value = by[key];
-                sql += "," + key + " ";
-                if (typeof value === "string")
-                    sql += value;
-                else
-                    sql += value ? "ASC" : "DESC";
-            }
-        }
-    }
-    return sql;
-}
-function handlerOrderValue(value) {
-    if (typeof value === "string")
-        return value;
-    else {
-        let str = value.key + " " + (value.asc ? "ASC" : "DESC");
-        if (value.nullLast !== undefined)
-            str += value.nullLast ? " NULLS LAST" : " NULLS FIRST";
-        return str;
-    }
-}
 
-export { getObjectListKeys, having, orderBy, selectColumns, where };
+export { selectColumns };

package/dist/sql_gen/your_table/table.d.ts

@@ -1,15 +1,14 @@
-import { DbTableQuery } from "../select/TableQuery.ts";
-import type { TableType } from "../select/type.ts";
-import type { SqlValuesCreator } from "../sql_value/sql_value.ts";
 import type { ColumnMeta, TableDefined } from "./infer_db_type.ts";
 import { TypeChecker } from "./checker.ts";
+import { TableType } from "../util.ts";
 /**
  * 完整数据库表数据
  * @public
  */
-export declare class YourTable<T extends TableType = TableType, C extends TableType = T> extends DbTableQuery<T, C> {
+export declare class YourTable<T extends TableType = TableType> {
+    readonly name: string;
     private define;
-    constructor(name: string, define: TableDefined, sqlValue: SqlValuesCreator);
+    constructor(name: string, define: TableDefined);
     readonly columns: readonly string[];
     getColumnMeta(name: keyof T): ColumnMeta<unknown>;
     createTypeChecker<T>(keys: readonly string[]): TypeChecker<T>;

package/dist/sql_gen/your_table/table.js

@@ -1,14 +1,14 @@
-import { DbTableQuery } from '../select/TableQuery.js';
 import { TypeChecker } from './checker.js';
 
 /**
  * 完整数据库表数据
  * @public
  */
-class YourTable extends DbTableQuery {
+class YourTable {
+    name;
     define;
-    constructor(name, define, sqlValue) {
-        super(name, sqlValue);
+    constructor(name, define) {
+        this.name = name;
         this.define = define;
         this.columns = Object.keys(define);
     }

package/package.json

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

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

@@ -1,54 +0,0 @@
-import { ConditionParam, Constructable } from "../util.ts";
-import type { TableType } from "./type.ts";
-import { Selection } from "./query_chain_select.ts";
-import { ChainDelete, ChainInsert, ChainUpdate } from "./chain_modify.ts";
-import { ChainSelect } from "./chain_select.ts";
-/**
- * 数据库表
- * @public
- */
-export declare class DbTable<T extends TableType> {
-    readonly name: string;
-    constructor(name: string);
-    fromAs(as?: string): Selection;
-    /** 选择单表全部列 */
-    select(columns: "*", as?: string): ChainSelect<T>;
-    /** 选择单表，带提示  */
-    select(columns: Constructable<{
-        [key in keyof T]?: string | boolean;
-    } & {
-        [key: string]: string | boolean;
-    }>, as?: string): ChainSelect<Record<string, any>>;
-    /** 选择单表  */
-    select<R extends {} = Record<string, any>>(columns: Constructable<string | string[]>, as?: string): ChainSelect<R>;
-    /** 选择单表  */
-    select<R extends {}>(columns: Constructable<{
-        [key in keyof R]: boolean | string;
-    } | string | string[]>, as?: string): ChainSelect<R>;
-    /**
-     * INSERT 语句，需要注意 SQL 注入
-     * @example
-     * ```ts
-     * table.insert(["age","name"], "VALUES (18, 'hi'), (17, 'hh')") // INSERT INTO table(age,name) VALUES(18, 'hi'), (17, 'hh')
-     * ```
-     */
-    insert(columns: string, values: Constructable<string>): ChainInsert<T>;
-    /**
-     * UPDATE 语句，需要注意 SQL 注入
-     * @example
-     * ```ts
-     * table.update("age=3, name='hi'") // "UPDATE table SET age=3, name='hi'"
-     * table.update({age: "3", name: "'hi'", k1: undefined, k2: ""}) // "UPDATE table SET age=3, name='hi'"
-     * ```
-     */
-    update(values: Constructable<{
-        [key in keyof T]?: string;
-    } | string>): ChainUpdate<T>;
-    delete(option?: DeleteOption): ChainDelete<T>;
-    toSelect(): string;
-}
-/** @public */
-export interface DeleteOption {
-    where?: Constructable<ConditionParam | void>;
-}
-//# sourceMappingURL=DbTable.d.ts.map

package/dist/sql_gen/select/DbTable.js

@@ -1,70 +0,0 @@
-import { where } from '../util.js';
-import { Selection } from './query_chain_select.js';
-import { SqlChainModify } from './query_chain_insert.js';
-import { createUpdateSetFromObject } from './_statement.js';
-
-/**
- * 数据库表
- * @public
- */
-class DbTable {
-    name;
-    constructor(name) {
-        this.name = name;
-    }
-    fromAs(as) {
-        return new Selection(this.name, as);
-    }
-    select(columns, as) {
-        return this.fromAs(as).select(columns);
-    }
-    /**
-     * INSERT 语句，需要注意 SQL 注入
-     * @example
-     * ```ts
-     * table.insert(["age","name"], "VALUES (18, 'hi'), (17, 'hh')") // INSERT INTO table(age,name) VALUES(18, 'hi'), (17, 'hh')
-     * ```
-     */
-    insert(columns, values) {
-        if (typeof columns !== "string" || !columns)
-            throw new TypeError("columns 必须是有效的 string 类型");
-        if (typeof values === "function")
-            values = values();
-        if (typeof values !== "string")
-            throw new TypeError("values 必须是 string 或 function 类型");
-        let sql = `INSERT INTO ${this.name}(${columns})\n${values}`;
-        return new SqlChainModify(sql);
-    }
-    /**
-     * UPDATE 语句，需要注意 SQL 注入
-     * @example
-     * ```ts
-     * table.update("age=3, name='hi'") // "UPDATE table SET age=3, name='hi'"
-     * table.update({age: "3", name: "'hi'", k1: undefined, k2: ""}) // "UPDATE table SET age=3, name='hi'"
-     * ```
-     */
-    update(values) {
-        if (typeof values === "function")
-            values = values();
-        switch (typeof values) {
-            case "object": {
-                let sql = createUpdateSetFromObject(values);
-                return new SqlChainModify("UPDATE " + this.name + " " + sql);
-            }
-            case "string":
-                return new SqlChainModify("UPDATE " + this.name + " SET\n" + values);
-            default:
-                throw new TypeError("参数 values 错误");
-        }
-    }
-    delete(option = {}) {
-        let sql = "DELETE FROM " + this.name;
-        sql += where(option.where);
-        return new SqlChainModify(sql);
-    }
-    toSelect() {
-        return this.name;
-    }
-}
-
-export { DbTable };

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

@@ -1,28 +0,0 @@
-import { SqlValuesCreator } from "../sql_value/sql_value.ts";
-import { UpdateRowValue, TableType } from "./type.ts";
-import { Constructable } from "../util.ts";
-import { DbTable } from "./DbTable.ts";
-import { ChainInsert, ChainUpdate } from "./chain_modify.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, statement: SqlValuesCreator);
-    /**
-     * @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<UpdateRowValue<C> | UpdateRowValue<C>[]>): ChainInsert<T>;
-    insert(columns: string, values: Constructable<string>): ChainInsert<T>;
-    /**
-     * UPDATE 语句，与 update() 不同的是，它会将值进行安全转换
-     * @example
-     * ```ts
-     * table.update({age:3, name:"hi"}, true) // "UPDATE table SET age=3, name='hi'"
-     * ```
-     */
-    updateFrom(values: Constructable<UpdateRowValue<T>>): ChainUpdate<T>;
-}
-//# sourceMappingURL=TableQuery.d.ts.map

package/dist/sql_gen/select/TableQuery.js

@@ -1,68 +0,0 @@
-import { getObjectListKeys } from '../util.js';
-import { SqlChainModify } from './query_chain_insert.js';
-import { DbTable } from './DbTable.js';
-
-/** @public */
-class DbTableQuery extends DbTable {
-    statement;
-    constructor(name, statement) {
-        super(name);
-        this.statement = statement;
-    }
-    insert(values_column, _values) {
-        if (_values)
-            return super.insert(values_column, _values);
-        let values = values_column;
-        if (typeof values === "function")
-            values = values();
-        if (typeof values !== "object")
-            throw new TypeError("values 类型错误");
-        let valuesStr;
-        let insertCol;
-        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 {
-            insertCol = Object.keys(values);
-            valuesStr = `VALUES\n(${this.statement.objectToValues(values, insertCol)})`;
-        }
-        if (insertCol.length === 0)
-            throw new Error("插入列不能为空");
-        const columnStr = insertCol.join(",");
-        let sql = `INSERT INTO ${this.name} (${columnStr})\n${valuesStr}`;
-        return new SqlChainModify(sql);
-    }
-    /**
-     * UPDATE 语句，与 update() 不同的是，它会将值进行安全转换
-     * @example
-     * ```ts
-     * table.update({age:3, name:"hi"}, true) // "UPDATE table SET age=3, name='hi'"
-     * ```
-     */
-    updateFrom(values) {
-        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");
-        }
-        if (!setStr)
-            throw new Error("值不能为空");
-        let sql = `UPDATE ${this.name} SET\n${setStr}`;
-        return new SqlChainModify(sql);
-    }
-}
-
-export { DbTableQuery };

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

@@ -1,9 +0,0 @@
-import { Constructable } from "../util.ts";
-type ConditionParam = string | string[];
-/**
- * 生成条件语句
- */
-export declare function condition(conditions?: Constructable<ConditionParam | void>, type?: "AND" | "OR"): string;
-export declare function createUpdateSetFromObject(set: Record<string, string | undefined>): string;
-export {};
-//# sourceMappingURL=_statement.d.ts.map

package/dist/sql_gen/select/_statement.js

@@ -1,60 +0,0 @@
-function condition(conditions, type = "AND") {
-    if (typeof conditions === "function")
-        conditions = conditions();
-    if (!conditions)
-        return;
-    if (typeof conditions === "string")
-        return conditions;
-    else {
-        if (conditions.length) {
-            let sql = "";
-            type = " " + type + " ";
-            sql += conditions[0];
-            for (let i = 1; i < conditions.length; i++)
-                sql += type + conditions[i];
-            return sql;
-        }
-        return;
-    }
-}
-function createUpdateSetFromObject(set) {
-    const updateKey = Object.keys(set);
-    let i = 0;
-    let key;
-    let value;
-    let sql;
-    for (; i < updateKey.length; i++) {
-        key = updateKey[i];
-        value = set[key];
-        if (value === undefined)
-            continue;
-        if (typeof value === "string") {
-            if (value) {
-                sql = "SET\n" + key + "= " + value;
-                break;
-            }
-        }
-        else
-            throw new TypeError(`key ${key} 类型错误(${typeof value})`);
-    }
-    if (sql) {
-        i++;
-        for (; i < updateKey.length; i++) {
-            key = updateKey[i];
-            value = set[key];
-            if (value === undefined)
-                continue;
-            if (typeof value === "string") {
-                if (value)
-                    sql += "," + key + "= " + value;
-            }
-            else
-                throw new TypeError(`key ${key} 类型错误(${typeof value})`);
-        }
-        return sql;
-    }
-    else
-        throw new Error("值不能为空");
-}
-
-export { condition, createUpdateSetFromObject };

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

@@ -1,33 +0,0 @@
-import { ConditionParam, Constructable, SelectParam } from "../util.ts";
-import { TableType } from "./type.ts";
-import { SqlStatement, SqlStatementDataset } from "./chain_base.ts";
-/** @public */
-export interface ChainModifyReturning<T extends TableType = {}> extends SqlStatement {
-    returning(columns: "*"): SqlStatementDataset<T>;
-    returning(columns: Constructable<SelectParam>): SqlStatementDataset<Record<string, any>>;
-    returning<R extends TableType>(columns: Constructable<SelectParam>): SqlStatementDataset<R>;
-}
-/** @public */
-export interface ChainAfterConflictDo<T extends TableType = {}> {
-    doNotThing(): ChainModifyReturning<T>;
-    /**
-     * 需要注意 SQL 注入
-     */
-    doUpdate(set: Constructable<string | {
-        [key in keyof T]?: string;
-    }>): ChainModifyReturning<T>;
-    toString(): string;
-}
-/** @public */
-export interface ChainInsert<T extends TableType = {}> extends ChainModifyReturning<T> {
-    onConflict(option: Constructable<readonly (keyof T)[] | string>): ChainAfterConflictDo<T>;
-}
-/** @public */
-export interface ChainUpdate<T extends TableType = {}> extends ChainModifyReturning<T> {
-    where(where: Constructable<ConditionParam | void>): ChainModifyReturning<T>;
-}
-/** @public */
-export interface ChainDelete<T extends TableType = {}> extends ChainModifyReturning<T> {
-    where(where: Constructable<ConditionParam | void>): ChainModifyReturning<T>;
-}
-//# sourceMappingURL=chain_modify.d.ts.map

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

@@ -1,28 +0,0 @@
-import { ConditionParam, Constructable, OrderByParam } from "../util.ts";
-import { SqlStatementDataset } from "./chain_base.ts";
-import { TableType } from "./type.ts";
-/** @public */
-export interface ChainSelect<T extends TableType> extends ChainSelectAfterWhere<T> {
-    where(param: Constructable<ConditionParam | void>): ChainSelectAfterWhere<T>;
-}
-/** @public */
-export interface ChainSelectAfterWhere<T extends TableType> extends ChainSelectAfterHaving<T> {
-    groupBy(columns: string | string[]): ChainSelectAfterGroupBy<T>;
-}
-/** @public */
-export interface ChainSelectAfterGroupBy<T extends TableType> extends ChainSelectAfterHaving<T> {
-    orderBy(param: Constructable<OrderByParam | void>): ChainSelectAfterOrderBy<T>;
-    having(param: Constructable<ConditionParam | void>): ChainSelectAfterHaving<T>;
-}
-/** @public */
-export interface ChainSelectAfterHaving<T extends TableType> extends ChainSelectAfterOrderBy<T> {
-    orderBy(param: Constructable<OrderByParam | void>): ChainSelectAfterOrderBy<T>;
-}
-/** @public */
-export interface ChainSelectAfterOrderBy<T extends TableType> extends SqlStatementDataset<T> {
-    limit(limit?: number | bigint, offset?: number | bigint): ChainSelectAfterLimit<T>;
-}
-/** @public */
-export interface ChainSelectAfterLimit<T extends TableType> extends SqlStatementDataset<T> {
-}
-//# sourceMappingURL=chain_select.d.ts.map

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

@@ -1,22 +0,0 @@
-import { ConditionParam, Constructable, SelectParam } from "../util.ts";
-import { SqlStatementDataset, SqlStatement } from "./chain_base.ts";
-import { ChainAfterConflictDo, ChainModifyReturning, ChainInsert, ChainDelete, ChainUpdate } from "./chain_modify.ts";
-import { TableType } from "./type.ts";
-export declare class SqlChainModify<T extends TableType = {}> extends SqlStatement implements ChainInsert<T>, ChainUpdate<T>, ChainDelete<T> {
-    readonly sql: string;
-    constructor(sql: string);
-    returning<R extends {}>(returns: Constructable<SelectParam | "*">): SqlStatementDataset<R>;
-    onConflict(onConflict: Constructable<readonly string[] | string>): ChainAfterConflictDo<T>;
-    where(where: Constructable<ConditionParam | void>): ChainModifyReturning<T>;
-    genSql(): string;
-}
-export declare class SqlInsertConflictBranch<T extends TableType = {}> implements ChainAfterConflictDo<T> {
-    readonly sql: string;
-    constructor(sql: string);
-    doUpdate(set?: Constructable<string | {
-        [key: string]: string | undefined;
-    }>): ChainModifyReturning<T>;
-    doNotThing(): ChainModifyReturning<T>;
-    toString(): string;
-}
-//# sourceMappingURL=query_chain_insert.d.ts.map