@asla/yoursql 0.9.3 → 0.10.1

package/README.md

@@ -70,19 +70,19 @@ import { v } from "@asla/yoursql";
 v.toValues([1, "abc", null, undefined, { key: "value" }]); // `1,'abc',NULL,DEFAULT,'{"key":"value"}'`
 ```
 
-#### v.objectToValues()
+#### v.objectToValue()
 
 转换对象为 values 的单个值
 
 ```ts
 import { v } from "@asla/yoursql";
 const obj = { a: "a1", b: "b1", c: undefined, d: "d1" };
-v.objectToValues(obj); // "'a1','b1',DEFAULT,'d1'"
-v.objectToValues(obj, ["b", "a"]); // "'b1','a1'"
-v.objectToValues(obj, [{ a: "TEXT", b: {} }]); // 'a1'::TEXT,'b1'"
+v.objectToValue(obj); // "'a1','b1',DEFAULT,'d1'"
+v.objectToValue(obj, ["b", "a"]); // "'b1','a1'"
+v.objectToValue(obj, [{ a: "TEXT", b: {} }]); // 'a1'::TEXT,'b1'"
 ```
 
-#### v.objectListToValuesList()
+#### v.objectListToValues()
 
 转换对象数组为 values
 
@@ -92,10 +92,10 @@ import { v } from "@asla/yoursql";
 const values = [{ a: 1, b: 2 }, { c: 3 }];
 
 // 这将自动选择数组中所有键的并集
-v.objectListToValuesList(values); // "(1,2,null),(null,null,3)"
+v.objectListToValues(values); // "(1,2,null),(null,null,3)"
 
 // 或者你可以指定选择键并指定顺序
-const valueStr = v.objectListToValuesList(values, ["c", "b"]); // "(null,2),(3,3)"
+const valueStr = v.objectListToValues(values, ["c", "b"]); // "(null,2),(3,3)"
 
 const sql = `INSERT INTO user(name, role) VALUES ${valueStr}`;
 ```
@@ -121,12 +121,12 @@ v.createValues("customName", objectList, {
 ### 生成 SQL 语句
 
 ```ts
-import { Selection, v } from "@asla/yoursql";
+import { select, 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
+const s = select({ uid: "u.id", rid: "r.id", example: "u.id||r.id" })
+  .from("user AS u")
+  .innerJoin("role", { as: "r", on: "u.id=r.user_id" })
   .where(`u.name LIKE %${v(searchName)}%`)
   .toString();
 ```

package/dist/sql_gen/{select/chain_base.d.ts → SqlStatement.d.ts}

@@ -21,7 +21,7 @@ export interface SqlSelectable {
      * 如果是 table 则是 table name
      * 如果是 选择语句，则是 (xxx)
      */
-    toSelect(): string;
+    toSelect(asName?: string): string;
 }
 /** @public */
 export declare abstract class SqlStatementDataset<T> extends SqlStatement implements SqlSelectable {
@@ -30,7 +30,7 @@ export declare abstract class SqlStatementDataset<T> extends SqlStatement implem
      * 如果是 table 则是 table name
      * 如果是 选择语句，则是 (xxx)
      */
-    toSelect(): string;
+    toSelect(asName?: string): string;
 }
 /** @public */
 export declare class SqlTextStatementDataset<T> extends SqlStatementDataset<T> {
@@ -43,4 +43,14 @@ export declare class SqlTextStatementDataset<T> extends SqlStatementDataset<T> {
  * @public
  */
 export type InferQueryResult<T> = T extends SqlStatementDataset<infer P> ? P : never;
-//# sourceMappingURL=chain_base.d.ts.map
+/** @public */
+export interface SqlTemplate {
+    readonly templates: readonly string[];
+    readonly args: readonly unknown[];
+    toTextTemplate(): {
+        text: string;
+        args: string[];
+    };
+    genSql(): string;
+}
+//# sourceMappingURL=SqlStatement.d.ts.map

package/dist/sql_gen/{select/chain_base.js → SqlStatement.js}

@@ -12,8 +12,11 @@ class SqlStatementDataset extends SqlStatement {
      * 如果是 table 则是 table name
      * 如果是 选择语句，则是 (xxx)
      */
-    toSelect() {
-        return "(" + this.genSql() + ")";
+    toSelect(asName) {
+        let result = "(" + this.genSql() + ")";
+        if (asName)
+            result += " AS " + asName;
+        return result;
     }
 }
 /** @public */

package/dist/sql_gen/_statement.d.ts

@@ -0,0 +1,29 @@
+import { ConditionParam, Constructable, SelectParam } from "./util.ts";
+import { SqlSelectable } from "./SqlStatement.ts";
+/**
+ * 获取对象数组中的 key 的集合
+ * @param keepUndefinedKey - 是否保留值为 undefined 的 key
+ */
+export declare function getObjectListKeys(objectList: any[], keepUndefinedKey?: boolean): Set<string>;
+/**
+ * 生成条件语句
+ */
+export declare function condition(conditions?: Constructable<ConditionParam | void>, type?: "AND" | "OR"): 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 whereToString(conditions?: Constructable<ConditionParam | void>, type?: "AND" | "OR"): string;
+export declare function createUpdateSetFromObject(set: Record<string, string | undefined>, prefix?: string): string;
+export declare function selectableToString(selectable: Constructable<SqlSelectable | string>, as?: string): string;
+export declare function returningToString(returns: Constructable<SelectParam | "*">): string;
+//# sourceMappingURL=_statement.d.ts.map

package/dist/sql_gen/_statement.js

@@ -0,0 +1,127 @@
+import { selectColumns } from './util.js';
+
+/**
+ * 获取对象数组中的 key 的集合
+ * @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;
+}
+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;
+    }
+}
+/**
+ * 生成 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 whereToString(conditions, type) {
+    const sql = condition(conditions, type);
+    if (sql)
+        return "\nWHERE " + sql;
+    return "";
+}
+function createUpdateSetFromObject(set, prefix) {
+    const updateKey = Object.keys(set);
+    let i = 0;
+    let key;
+    let sqlKey;
+    let value;
+    let sql;
+    for (; i < updateKey.length; i++) {
+        key = updateKey[i];
+        sqlKey = key;
+        value = set[key];
+        if (value === undefined)
+            continue;
+        if (typeof value === "string") {
+            if (value) {
+                sql = "SET\n" + sqlKey + "= " + value;
+                break;
+            }
+        }
+        else
+            throw new TypeError(`key ${key} 类型错误(${typeof value})`);
+    }
+    if (sql) {
+        i++;
+        for (; i < updateKey.length; i++) {
+            key = updateKey[i];
+            sqlKey = key;
+            value = set[key];
+            if (value === undefined)
+                continue;
+            if (typeof value === "string") {
+                if (value)
+                    sql += "," + sqlKey + "= " + value;
+            }
+            else
+                throw new TypeError(`key ${key} 类型错误(${typeof value})`);
+        }
+        return sql;
+    }
+    else
+        throw new Error("值不能为空");
+}
+function selectableToString(selectable, as) {
+    if (typeof selectable === "function")
+        selectable = selectable();
+    let sql = typeof selectable === "string" ? selectable : selectable.toSelect();
+    if (!sql)
+        throw new Error("selectable can not be empty");
+    if (as)
+        sql += " AS " + as;
+    return sql;
+}
+function returningToString(returns) {
+    if (typeof returns === "function")
+        returns = returns();
+    let columnsStr;
+    if (returns === "*") {
+        columnsStr = "*";
+    }
+    else {
+        columnsStr = selectColumns(returns);
+    }
+    return "\nRETURNING " + columnsStr;
+}
+
+export { condition, createUpdateSetFromObject, getObjectListKeys, returningToString, selectableToString, whereToString };

package/dist/sql_gen/mod.d.ts

@@ -1,13 +1,8 @@
 export * from "./sql_value/db_type.ts";
 export * from "./sql_value/sql_value.ts";
-export * from "./select/type.ts";
-export * from "./select/DbTable.ts";
-export * from "./select/query_chain_select.ts";
-export * from "./select/chain_base.ts";
-export * from "./select/chain_modify.ts";
-export * from "./select/chain_select.ts";
-export * from "./select/TableQuery.ts";
-export * from "./select/cte.ts";
+export * from "./sql_value/type.ts";
+export * from "./SqlStatement.ts";
+export * from "./statement/mod.ts";
 export * from "./util.ts";
 export * from "./your_table/mod.ts";
 import { SqlValueFn } from "./sql_value/sql_value.ts";

package/dist/sql_gen/mod.js

@@ -1,11 +1,12 @@
 import { pgSqlTransformer } from './sql_value/db_type.js';
 import { SqlValuesCreator } from './sql_value/sql_value.js';
-export { DbTable } from './select/DbTable.js';
-export { Selection, SqlSelectChain } from './select/query_chain_select.js';
-export { SqlStatement, SqlStatementDataset, SqlTextStatementDataset } from './select/chain_base.js';
-export { DbTableQuery } from './select/TableQuery.js';
-export { withAs, withRecursiveAs } from './select/cte.js';
-export { getObjectListKeys, having, orderBy, selectColumns, where } from './util.js';
+export { SqlStatement, SqlStatementDataset, SqlTextStatementDataset } from './SqlStatement.js';
+export { orderBy, select } from './statement/select.js';
+export { insertInto } from './statement/insert.js';
+export { update } from './statement/update.js';
+export { deleteFrom } from './statement/delete.js';
+export { withAs, withRecursiveAs } from './statement/cte.js';
+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';

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

@@ -0,0 +1,13 @@
+import { SqlTemplate } from "../SqlStatement.ts";
+export declare class ValueSqlTemplate implements SqlTemplate {
+    private v;
+    readonly templates: readonly string[];
+    readonly args: readonly unknown[];
+    constructor(v: (value: unknown) => string, templates: readonly string[], values: readonly unknown[]);
+    toTextTemplate(): {
+        text: string;
+        args: string[];
+    };
+    genSql(): string;
+}
+//# sourceMappingURL=ValueSqlTemplate.d.ts.map

package/dist/sql_gen/sql_value/ValueSqlTemplate.js

@@ -0,0 +1,30 @@
+class ValueSqlTemplate {
+    v;
+    templates;
+    args;
+    constructor(v, templates, values) {
+        this.v = v;
+        this.templates = templates;
+        this.args = values;
+    }
+    toTextTemplate() {
+        const { templates, args } = this;
+        let text = templates[0];
+        for (let i = 1; i < templates.length; i++) {
+            text += "$" + i;
+            text += templates[i];
+        }
+        const values = args.map((value) => this.v(value));
+        return { text, args: values };
+    }
+    genSql() {
+        const { templates, args } = this;
+        let sql = this.templates[0];
+        for (let i = 1; i < templates.length; i++) {
+            sql += this.v(args[i - 1]) + templates[i];
+        }
+        return sql;
+    }
+}
+
+export { ValueSqlTemplate };

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

@@ -0,0 +1,11 @@
+import { SqlStatementDataset } from "../SqlStatement.ts";
+import { TableType } from "../util.ts";
+import { ColumnToValueConfig } from "./type.ts";
+export declare class YourValuesAs<T extends TableType> extends SqlStatementDataset<T> {
+    #private;
+    constructor(columns: readonly string[], asName: string, valuesStr: string);
+    toSelect(): string;
+    genSql(): string;
+}
+export declare function initColumnAssert(keys: readonly string[], keys_types: Record<string, string | undefined | ColumnToValueConfig>): any[];
+//# sourceMappingURL=_utils.d.ts.map

package/dist/sql_gen/sql_value/_utils.js

@@ -0,0 +1,37 @@
+import { SqlStatementDataset } from '../SqlStatement.js';
+
+class YourValuesAs extends SqlStatementDataset {
+    constructor(columns, asName, valuesStr) {
+        super();
+        this.#asName = asName;
+        this.#valuesStr = valuesStr;
+        this.#sql = `(VALUES\n${this.#valuesStr})\nAS ${this.#asName}(${columns.join(",")})`;
+    }
+    #asName;
+    #valuesStr;
+    #sql;
+    toSelect() {
+        return this.#sql;
+    }
+    genSql() {
+        return this.#sql;
+    }
+}
+function initColumnAssert(keys, keys_types) {
+    let key;
+    let value;
+    let type = new Array(keys.length);
+    for (let i = 0; i < keys.length; i++) {
+        key = keys[i];
+        value = keys_types[key];
+        if (typeof value === "string") {
+            type[i] = { sqlType: value };
+        }
+        else {
+            type[i] = value;
+        }
+    }
+    return type;
+}
+
+export { YourValuesAs, initColumnAssert };

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

@@ -1,10 +1,9 @@
-import { SqlStatementDataset } from "../select/chain_base.ts";
+import { SqlStatementDataset, SqlTemplate } from "../SqlStatement.ts";
+import { AssertJsType, ObjectToValueKeys, SqlValuesTextData } from "./type.ts";
 /** @public js 对象到编码函数的映射*/
 export type JsObjectMapSql = Map<new (...args: any[]) => any, SqlValueEncoder>;
 /** @public 将 js 值转为 SQl 字符串的函数*/
 export type SqlValueEncoder<T = any> = (this: SqlValuesCreator, value: T) => string;
-/** @public 断言类型 */
-export type AssertJsType = "bigint" | "number" | "string" | "boolean" | "object" | (new (...args: any[]) => any);
 /** @public */
 export type SqlValueFn = SqlValuesCreator & {
     /**
@@ -41,31 +40,39 @@ export declare class SqlValuesCreator {
      * ```
      */
     toSqlStr(value: any, assertJsType?: AssertJsType): string;
-    /**
-     * @deprecated 已废弃
-     * 获取值对应的 SqlValueEncoder
-     */
-    getObjectType(value: object): SqlValueEncoder;
+    /** @alpha */
+    gen(split: TemplateStringsArray, ...values: any[]): SqlTemplate;
     /** 获取值对应已定义的类 */
     getClassType(value: object): undefined | (new (...args: unknown[]) => unknown);
     protected defaultObject(value: object): string;
+    /** @deprecated 改用 objectListToValues */
+    objectListToValuesList<T extends object>(objectList: T[], keys?: ObjectToValueKeys<T>, keepUndefinedKey?: boolean): string;
     /**
-     * 将对象列表转为 SQL 的 VALUES。
-     * @example 返回示例： " (...),(...) "
+     * 将对象列表转为 SQL 的 VALUES。与 objectToValues类似。如果设定了 keys 的类型，只会转换第一行的数据。
+     * @example 返回的文本示例： " (...),(...) "
      * @param keys - 选择的键。如果指定了 keys, 值为 undefined 的属性将自动填充为 null; 如果未指定 keys，将选择 objectList 所有不是 undefined 项的键的并集
      * @param keepUndefinedKey - 是否保留 undefined 的键。默认值为 false，如果为 true , 数组的某一个字段均为 undefined时，将忽略字段,
      */
-    objectListToValuesList<T extends object>(objectList: T[], keys?: readonly (keyof T)[] | {
-        [key in keyof T]?: string | undefined | ColumnToValueConfig;
-    }, keepUndefinedKey?: boolean): string;
+    objectListToValues<T extends object>(objectList: T[], keys?: ObjectToValueKeys<T>, keepUndefinedKey?: boolean): SqlValuesTextData;
+    /**
+     * @deprecated 请使用 objectToValue 代替
+     */
+    objectToValues<T extends object>(object: T, keys?: ObjectToValueKeys<T>): string;
     /**
      * 将对象转为 SQL 的 value
-     * @example 返回示例： " 'abc', '6', 'now()' "
+     * @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
      */
-    objectToValues<T extends object>(object: T, keys?: readonly (keyof T)[] | {
-        [key in keyof T]?: string | undefined | ColumnToValueConfig;
-    }): string;
+    objectToValue<T extends object>(object: T, keys?: ObjectToValueKeys<T>): SqlValuesTextData;
+    private _getObjectValueInfo;
     private _internalObjectToValues;
     /**
      * 将数组列表转为 SQL 的一个 value
@@ -93,9 +100,4 @@ export declare class SqlValuesCreator {
         assertJsType?: AssertJsType;
     }>): SqlStatementDataset<T>;
 }
-/** @public */
-export type ColumnToValueConfig = {
-    sqlType?: string;
-    assertJsType?: AssertJsType;
-};
 //# sourceMappingURL=sql_value.d.ts.map

package/dist/sql_gen/sql_value/sql_value.js

@@ -1,5 +1,6 @@
-import { getObjectListKeys } from '../util.js';
-import { SqlStatementDataset } from '../select/chain_base.js';
+import { getObjectListKeys } from '../_statement.js';
+import { ValueSqlTemplate } from './ValueSqlTemplate.js';
+import { initColumnAssert, YourValuesAs } from './_utils.js';
 
 /**
  * SQL value 生成器
@@ -95,16 +96,14 @@ class SqlValuesCreator {
                 throw new Error("不支持 " + type + " 类型");
         }
     }
-    /**
-     * @deprecated 已废弃
-     * 获取值对应的 SqlValueEncoder
-     */
-    getObjectType(value) {
-        for (const Class of this._map.keys()) {
-            if (value instanceof Class)
-                return this._map.get(Class);
+    /** @alpha */
+    gen(split, ...values) {
+        let sql = split[0];
+        for (let i = 0; i < values.length; i++) {
+            sql += this.toSqlStr(values[i]);
+            sql += split[i + 1];
         }
-        return this.defaultObject;
+        return new ValueSqlTemplate(this.toSqlStr.bind(this), split, values);
     }
     /** 获取值对应已定义的类 */
     getClassType(value) {
@@ -116,7 +115,11 @@ class SqlValuesCreator {
     defaultObject(value) {
         return SqlValuesCreator.string(JSON.stringify(value));
     }
-    objectListToValuesList(objectList, keys_types, keepUndefinedKey) {
+    /** @deprecated 改用 objectListToValues */
+    objectListToValuesList(objectList, keys, keepUndefinedKey) {
+        return this.objectListToValues(objectList, keys, keepUndefinedKey).text;
+    }
+    objectListToValues(objectList, keys_types, keepUndefinedKey) {
         if (objectList.length <= 0)
             throw new Error("objectList 不能是空数组");
         let keys;
@@ -154,13 +157,22 @@ class SqlValuesCreator {
             let message = error instanceof Error ? error.message : String(error);
             throw new Error("第 " + i + " 项，字段 '" + keys[j] + "' 异常，" + message);
         }
-        return str;
+        return { columns: keys, text: str };
     }
     objectToValues(object, keys_types) {
+        const { keys, type } = this._getObjectValueInfo(object, keys_types);
+        return this._internalObjectToValues(object, keys, type);
+    }
+    objectToValue(object, keys_types) {
+        const { keys, type } = this._getObjectValueInfo(object, keys_types);
+        const text = this._internalObjectToValues(object, keys, type);
+        return { columns: keys, text: "(" + text + ")" };
+    }
+    _getObjectValueInfo(object, keys_types) {
         let type;
         let keys;
         if (keys_types instanceof Array) {
-            keys = keys_types;
+            keys = [...keys_types];
             type = [];
         }
         else if (keys_types) {
@@ -171,7 +183,7 @@ class SqlValuesCreator {
             keys = Object.keys(object);
             type = [];
         }
-        return this._internalObjectToValues(object, keys, type);
+        return { keys, type };
     }
     _internalObjectToValues(object, keys, type) {
         const values = [];
@@ -263,39 +275,6 @@ class SqlValuesCreator {
         return new YourValuesAs(insertKeys, asName, valuesStr.join(",\n"));
     }
 }
-class YourValuesAs extends SqlStatementDataset {
-    constructor(columns, asName, valuesStr) {
-        super();
-        this.#asName = asName;
-        this.#valuesStr = valuesStr;
-        this.#sql = `(VALUES\n${this.#valuesStr})\nAS ${this.#asName}(${columns.join(",")})`;
-    }
-    #asName;
-    #valuesStr;
-    #sql;
-    toSelect() {
-        return this.#sql;
-    }
-    genSql() {
-        return this.#sql;
-    }
-}
-function initColumnAssert(keys, keys_types) {
-    let key;
-    let value;
-    let type = new Array(keys.length);
-    for (let i = 0; i < keys.length; i++) {
-        key = keys[i];
-        value = keys_types[key];
-        if (typeof value === "string") {
-            type[i] = { sqlType: value };
-        }
-        else {
-            type[i] = value;
-        }
-    }
-    return type;
-}
 class AssertError extends TypeError {
     constructor(assertType, actual) {
         super(`Assert ${assertType} type, Actual ${actual} type`);

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

@@ -0,0 +1,19 @@
+/** @public 断言类型 */
+export type AssertJsType = "bigint" | "number" | "string" | "boolean" | "object" | (new (...args: any[]) => any);
+/** @public */
+export type SqlValuesTextData = {
+    columns: string[];
+    text: string;
+};
+/** @public */
+export type ColumnToValueConfig = {
+    /** 设置显式 SQL 类型，设置后会显示转换 SQL 值 */
+    sqlType?: string;
+    /** 设置 JS 转换器类型，引导转换器如何将 JS 值转换为 SQL 值 */
+    assertJsType?: AssertJsType;
+};
+/** @public */
+export type ObjectToValueKeys<T extends {}> = readonly (keyof T)[] | {
+    [key in keyof T]?: string | undefined | ColumnToValueConfig;
+};
+//# sourceMappingURL=type.d.ts.map

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

@@ -0,0 +1,6 @@
+import { Constructable, SelectParam, TableType } from "../util.ts";
+import { SqlStatementDataset, SqlStatement } from "../SqlStatement.ts";
+export interface ChainModifyReturning extends SqlStatement {
+    returning<R extends TableType>(columns: Constructable<SelectParam>): SqlStatementDataset<R>;
+}
+//# sourceMappingURL=_modify.d.ts.map

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

@@ -0,0 +1,15 @@
+import { ChainDelete } 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;
+//# sourceMappingURL=delete.d.ts.map