@asla/yoursql 0.10.1 → 0.11.0

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

@@ -4,7 +4,7 @@ import { SqlSelectable } from "./SqlStatement.ts";
  * 获取对象数组中的 key 的集合
  * @param keepUndefinedKey - 是否保留值为 undefined 的 key
  */
-export declare function getObjectListKeys(objectList: any[], keepUndefinedKey?: boolean): Set<string>;
+export declare function getObjectListKeys(objectList: readonly any[], keepUndefinedKey?: boolean): Set<string>;
 /**
  * 生成条件语句
  */

package/dist/sql_gen/_statement.js

@@ -14,7 +14,7 @@ function getObjectListKeys(objectList, keepUndefinedKey) {
             k = hasKeys[j];
             if (typeof k !== "string")
                 continue;
-            if (!keepUndefinedKey && obj[k] === undefined)
+            if (obj[k] === undefined)
                 continue;
             keys.add(k);
         }

package/dist/sql_gen/mod.js

@@ -1,7 +1,8 @@
 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';
@@ -10,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, ObjectToValueKeys, SqlValuesTextData } 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,33 +45,22 @@ export declare class SqlValuesCreator {
     /** 获取值对应已定义的类 */
     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。与 objectToValues类似。如果设定了 keys 的类型，只会转换第一行的数据。
+     * 将对象列表转为 SQL 的 VALUES。如果 objectList 中有某个对象的属性值为 undefined，则会被转换为 "DEFAULT"
      * @example 返回的文本示例： " (...),(...) "
-     * @param keys - 选择的键。如果指定了 keys, 值为 undefined 的属性将自动填充为 null; 如果未指定 keys，将选择 objectList 所有不是 undefined 项的键的并集
-     * @param keepUndefinedKey - 是否保留 undefined 的键。默认值为 false，如果为 true , 数组的某一个字段均为 undefined时，将忽略字段,
+     * @param columns - 选择的键。如果指定了 columns, 值为 undefined 的属性将自动填充为 null; 如果未指定 columns，将选择 objectList 所有不是 undefined 项的键的并集
      */
-    objectListToValues<T extends object>(objectList: T[], keys?: ObjectToValueKeys<T>, keepUndefinedKey?: boolean): SqlValuesTextData;
+    createImplicitValues<T extends object>(objectList: T, columns?: ObjectToValueKeys<T>): SqlValuesTextData;
+    createImplicitValues<T extends object>(objectList: T[], columns?: ObjectToValueKeys<T>): SqlValuesTextData;
     /**
-     * @deprecated 请使用 objectToValue 代替
-     */
-    objectToValues<T extends object>(object: T, keys?: ObjectToValueKeys<T>): string;
-    /**
-     * 将对象转为 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
+     * 将对象列表转为 SQL 的 VALUES。如果 objectList 中有某个对象的属性值为 undefined，则会被转换为 "NULL"
+     * @example 返回的文本示例： " (...),(...) "
+     * @param columns - 选择的键。
      */
-    objectToValue<T extends object>(object: T, keys?: ObjectToValueKeys<T>): SqlValuesTextData;
+    createExplicitValues<T extends object>(objectList: T, columns?: ObjectToValueKeys<T>): SqlExplicitValuesStatement;
+    createExplicitValues<T extends object>(objectList: T[], columns?: ObjectToValueKeys<T>): SqlExplicitValuesStatement;
+    private _objectListToValues;
+    private _objectToValue;
     private _getObjectValueInfo;
     private _internalObjectToValues;
     /**
@@ -82,22 +71,17 @@ export declare class SqlValuesCreator {
      * ```
      */
     toValues(values: readonly any[]): string;
-    /**
-     * @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;
-        sqlDefault?: string;
-        assertJsType?: AssertJsType;
-    }>): SqlStatementDataset<T>;
+}
+/** @public */
+export type SqlValuesTextData = {
+    columns: string[];
+    text: string;
+};
+/** @public */
+export declare class SqlExplicitValuesStatement {
+    columns: readonly string[];
+    readonly text: string;
+    constructor(columns: readonly string[], text: string);
+    toSelect(name: string): string;
 }
 //# sourceMappingURL=sql_value.d.ts.map

package/dist/sql_gen/sql_value/sql_value.js

@@ -1,6 +1,5 @@
 import { getObjectListKeys } from '../_statement.js';
 import { ValueSqlTemplate } from './ValueSqlTemplate.js';
-import { initColumnAssert, YourValuesAs } from './_utils.js';
 
 /**
  * SQL value 生成器
@@ -115,32 +114,48 @@ class SqlValuesCreator {
     defaultObject(value) {
         return SqlValuesCreator.string(JSON.stringify(value));
     }
-    /** @deprecated 改用 objectListToValues */
-    objectListToValuesList(objectList, keys, keepUndefinedKey) {
-        return this.objectListToValues(objectList, keys, keepUndefinedKey).text;
+    createImplicitValues(objectList, columns) {
+        let res;
+        if (objectList instanceof Array) {
+            res = this._objectListToValues(objectList, columns, { undefinedDefault: "DEFAULT" });
+        }
+        else {
+            res = this._objectToValue(objectList, columns, { undefinedDefault: "DEFAULT" });
+        }
+        return { columns: [...res.columns], text: res.text };
+    }
+    createExplicitValues(objectList, columns) {
+        if (objectList instanceof Array) {
+            return this._objectListToValues(objectList, columns, { undefinedDefault: "NULL" });
+        }
+        else {
+            return this._objectToValue(objectList, columns, { undefinedDefault: "NULL" });
+        }
     }
-    objectListToValues(objectList, keys_types, keepUndefinedKey) {
+    _objectListToValues(objectList, columns, option = {}) {
         if (objectList.length <= 0)
             throw new Error("objectList 不能是空数组");
         let keys;
         let asserts;
-        if (!keys_types) {
-            keys = Array.from(getObjectListKeys(objectList, keepUndefinedKey));
+        if (!columns) {
+            keys = Array.from(getObjectListKeys(objectList));
             asserts = [];
         }
-        else if (keys_types instanceof Array) {
-            keys = keys_types;
+        else if (columns instanceof Array) {
+            keys = [...columns];
             asserts = [];
         }
         else {
-            keys = Object.keys(keys_types);
-            asserts = initColumnAssert(keys, keys_types);
+            keys = Object.keys(columns);
+            asserts = initColumnAssert(keys, columns);
         }
-        let str = "(" + this._internalObjectToValues(objectList[0], keys, asserts) + ")";
+        const undefinedDefault = option.undefinedDefault || "DEFAULT";
+        let str = "(" + this._internalObjectToValues(objectList[0], keys, asserts, undefinedDefault) + ")";
         let i = 1;
         let j;
         let value;
         let rows;
+        let assert;
         try {
             for (; i < objectList.length; i++) {
                 const object = objectList[i];
@@ -148,7 +163,9 @@ class SqlValuesCreator {
                 j = 0;
                 for (; j < keys.length; j++) {
                     value = object[keys[j]];
-                    rows[j] = this.toSqlStr(value, asserts[j]?.assertJsType);
+                    assert = asserts[j];
+                    rows[j] =
+                        value === undefined ? assert?.sqlDefault || undefinedDefault : this.toSqlStr(value, assert?.assertJsType);
                 }
                 str += ",\n(" + rows.join(",") + ")";
             }
@@ -157,16 +174,13 @@ class SqlValuesCreator {
             let message = error instanceof Error ? error.message : String(error);
             throw new Error("第 " + i + " 项，字段 '" + keys[j] + "' 异常，" + message);
         }
-        return { columns: keys, text: str };
+        return new SqlExplicitValuesStatement(keys, str);
     }
-    objectToValues(object, keys_types) {
+    _objectToValue(object, keys_types, option = {}) {
         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 + ")" };
+        const undefinedDefault = option.undefinedDefault || "DEFAULT";
+        const text = this._internalObjectToValues(object, keys, type, undefinedDefault);
+        return new SqlExplicitValuesStatement(keys, `(${text})`);
     }
     _getObjectValueInfo(object, keys_types) {
         let type;
@@ -185,7 +199,7 @@ class SqlValuesCreator {
         }
         return { keys, type };
     }
-    _internalObjectToValues(object, keys, type) {
+    _internalObjectToValues(object, keys, type, undefinedDefault) {
         const values = [];
         let i = 0;
         let key;
@@ -197,12 +211,15 @@ class SqlValuesCreator {
                 value = object[key];
                 assertType = type[i];
                 if (assertType) {
-                    values[i] = this.toSqlStr(value, assertType.assertJsType);
+                    values[i] =
+                        value === undefined
+                            ? assertType.sqlDefault || undefinedDefault
+                            : this.toSqlStr(value, assertType.assertJsType);
                     if (assertType.sqlType)
                         values[i] += "::" + assertType.sqlType;
                 }
                 else
-                    values[i] = this.toSqlStr(value);
+                    values[i] = value === undefined ? undefinedDefault : this.toSqlStr(value);
             }
         }
         catch (error) {
@@ -225,60 +242,39 @@ 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 insertKeys = Object.keys(valuesTypes);
-        const defaultValues = [];
-        const asserts = new Array(insertKeys.length);
-        const valuesStr = new Array(values.length);
-        {
-            const column0 = new Array(insertKeys.length);
-            let columnName;
-            let item;
-            let sqlType;
-            let assertJsType;
-            let value;
-            for (let i = 0; i < insertKeys.length; i++) {
-                columnName = insertKeys[i];
-                item = valuesTypes[columnName];
-                if (typeof item === "string") {
-                    sqlType = item;
-                    defaultValues[i] = "NULL";
-                }
-                else {
-                    sqlType = item.sqlType;
-                    assertJsType = item.assertJsType;
-                    asserts[i] = assertJsType;
-                    defaultValues[i] = item.sqlDefault ?? "NULL";
-                }
-                value = values[0][columnName];
-                if (value === undefined)
-                    column0[i] = defaultValues[i] + "::" + sqlType;
-                else
-                    column0[i] = this.toSqlStr(value, assertJsType) + "::" + sqlType;
-            }
-            valuesStr[0] = "(" + column0.join(",") + ")";
-        }
-        let items = new Array(insertKeys.length);
-        let value;
-        for (let i = 1; i < values.length; i++) {
-            for (let j = 0; j < insertKeys.length; j++) {
-                value = values[i][insertKeys[j]];
-                if (value === undefined)
-                    items[j] = defaultValues[j];
-                else
-                    items[j] = this.toSqlStr(value, asserts[j]);
-            }
-            valuesStr[i] = "(" + items.join(",") + ")";
-        }
-        return new YourValuesAs(insertKeys, asName, valuesStr.join(",\n"));
-    }
 }
 class AssertError extends TypeError {
     constructor(assertType, actual) {
         super(`Assert ${assertType} type, Actual ${actual} type`);
     }
 }
+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;
+}
+/** @public */
+class SqlExplicitValuesStatement {
+    columns;
+    text;
+    constructor(columns, text) {
+        this.columns = columns;
+        this.text = text;
+    }
+    toSelect(name) {
+        return `(VALUES\n${this.text})\nAS ${name}(${this.columns.join(",")})`;
+    }
+}
 
-export { SqlValuesCreator };
+export { SqlExplicitValuesStatement, SqlValuesCreator };

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

@@ -1,19 +1,18 @@
 /** @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 值 */
+    /** 设置显式 SQL 类型，设置后会显式转换 SQL 值 */
     sqlType?: string;
     /** 设置 JS 转换器类型，引导转换器如何将 JS 值转换为 SQL 值 */
     assertJsType?: AssertJsType;
+    /** undefined 会被替换的值 */
+    sqlDefault?: string;
 };
 /** @public */
-export type ObjectToValueKeys<T extends {}> = readonly (keyof T)[] | {
-    [key in keyof T]?: string | undefined | ColumnToValueConfig;
-};
+export type ObjectToValueKeys<T extends {}> = readonly string[] | ({
+    [key in keyof T as key extends string ? key : never]?: string | ColumnToValueConfig;
+} & {
+    [key: string]: string | undefined | ColumnToValueConfig;
+});
 //# sourceMappingURL=type.d.ts.map

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