@asla/yoursql 0.9.2 → 0.9.3

package/dist/sql_gen/mod.d.ts

@@ -7,6 +7,7 @@ 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 "./util.ts";
 export * from "./your_table/mod.ts";
 import { SqlValueFn } from "./sql_value/sql_value.ts";

package/dist/sql_gen/mod.js

@@ -4,6 +4,7 @@ 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 { TypeChecker } from './your_table/checker.js';
 export { ColumnMeta, CustomDbType, YourTypeMap } from './your_table/infer_db_type.js';

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

@@ -1,7 +1,7 @@
 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 { ChainDelete, ChainInsert, ChainModifyReturning, ChainUpdate } from "./chain_modify.ts";
 import { ChainSelect } from "./chain_select.ts";
 /**
  * 数据库表
@@ -43,12 +43,16 @@ export declare class DbTable<T extends TableType> {
      */
     update(values: Constructable<{
         [key in keyof T]?: string;
-    } | string>): ChainUpdate<T>;
+    } | string>, asName?: string): ChainUpdate<T>;
+    /** @deprecated 改用 delete().where */
+    delete(option: {
+        where?: Constructable<ConditionParam | void>;
+    }): ChainModifyReturning<T>;
     delete(option?: DeleteOption): ChainDelete<T>;
     toSelect(): string;
 }
 /** @public */
 export interface DeleteOption {
-    where?: Constructable<ConditionParam | void>;
+    asName?: string;
 }
 //# sourceMappingURL=DbTable.d.ts.map

package/dist/sql_gen/select/DbTable.js

@@ -43,23 +43,31 @@ class DbTable {
      * table.update({age: "3", name: "'hi'", k1: undefined, k2: ""}) // "UPDATE table SET age=3, name='hi'"
      * ```
      */
-    update(values) {
+    update(values, asName) {
         if (typeof values === "function")
             values = values();
+        let name = asName ? `${this.name} AS ${asName}` : this.name;
         switch (typeof values) {
             case "object": {
-                let sql = createUpdateSetFromObject(values);
-                return new SqlChainModify("UPDATE " + this.name + " " + sql);
+                let sql = createUpdateSetFromObject(values, asName);
+                return new SqlChainModify("UPDATE " + name + " " + sql);
             }
             case "string":
-                return new SqlChainModify("UPDATE " + this.name + " SET\n" + values);
+                return new SqlChainModify("UPDATE " + name + " SET\n" + values);
             default:
                 throw new TypeError("参数 values 错误");
         }
     }
     delete(option = {}) {
         let sql = "DELETE FROM " + this.name;
-        sql += where(option.where);
+        if (option.where) {
+            sql += where(option.where);
+        }
+        else {
+            if (option.asName) {
+                sql += ` AS ${option.asName}`;
+            }
+        }
         return new SqlChainModify(sql);
     }
     toSelect() {

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

@@ -23,6 +23,6 @@ export declare class DbTableQuery<T extends TableType = Record<string, any>, C e
      * table.update({age:3, name:"hi"}, true) // "UPDATE table SET age=3, name='hi'"
      * ```
      */
-    updateFrom(values: Constructable<UpdateRowValue<T>>): ChainUpdate<T>;
+    updateFrom(values: Constructable<UpdateRowValue<T>>, asName?: string): ChainUpdate<T>;
 }
 //# sourceMappingURL=TableQuery.d.ts.map

package/dist/sql_gen/select/TableQuery.js

@@ -42,7 +42,7 @@ class DbTableQuery extends DbTable {
      * table.update({age:3, name:"hi"}, true) // "UPDATE table SET age=3, name='hi'"
      * ```
      */
-    updateFrom(values) {
+    updateFrom(values, asName) {
         if (typeof values === "function")
             values = values();
         let setStr;
@@ -54,13 +54,18 @@ class DbTableQuery extends DbTable {
             for (const [k, v] of updateKey) {
                 if (v === undefined)
                     continue;
-                setList.push(k + "= " + this.statement.toSqlStr(v));
+                if (asName) {
+                    setList.push(`${asName}.${k}= ` + this.statement.toSqlStr(v));
+                }
+                else
+                    setList.push(k + "= " + this.statement.toSqlStr(v));
             }
             setStr = setList.join(",\n");
         }
         if (!setStr)
             throw new Error("值不能为空");
-        let sql = `UPDATE ${this.name} SET\n${setStr}`;
+        const name = asName ? `${this.name} AS ${asName}` : this.name;
+        let sql = `UPDATE ${name} SET\n${setStr}`;
         return new SqlChainModify(sql);
     }
 }

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

@@ -4,6 +4,6 @@ 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 declare function createUpdateSetFromObject(set: Record<string, string | undefined>, prefix?: string): string;
 export {};
 //# sourceMappingURL=_statement.d.ts.map

package/dist/sql_gen/select/_statement.js

@@ -17,20 +17,22 @@ function condition(conditions, type = "AND") {
         return;
     }
 }
-function createUpdateSetFromObject(set) {
+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 = prefix ? `${prefix}.${key}` : key;
         value = set[key];
         if (value === undefined)
             continue;
         if (typeof value === "string") {
             if (value) {
-                sql = "SET\n" + key + "= " + value;
+                sql = "SET\n" + sqlKey + "= " + value;
                 break;
             }
         }
@@ -41,12 +43,13 @@ function createUpdateSetFromObject(set) {
         i++;
         for (; i < updateKey.length; i++) {
             key = updateKey[i];
+            sqlKey = prefix ? `${prefix}.${key}` : key;
             value = set[key];
             if (value === undefined)
                 continue;
             if (typeof value === "string") {
                 if (value)
-                    sql += "," + key + "= " + value;
+                    sql += "," + sqlKey + "= " + value;
             }
             else
                 throw new TypeError(`key ${key} 类型错误(${typeof value})`);

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

@@ -19,15 +19,50 @@ export interface ChainAfterConflictDo<T extends TableType = {}> {
     toString(): string;
 }
 /** @public */
+export interface ChainUpdateWhere<T extends TableType = {}> extends ChainModifyReturning<T> {
+    where(where: Constructable<ConditionParam | void>): ChainModifyReturning<T>;
+}
+/** @public */
+export interface ChainDeleteWhere<T extends TableType = {}> extends ChainModifyReturning<T> {
+    where(where: Constructable<ConditionParam | void>): ChainModifyReturning<T>;
+}
+/** @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>;
+export interface ChainUpdate<T extends TableType = {}> extends ChainUpdateWhere<T> {
+    /**
+     * @example
+     * ```ts
+     *
+     * table.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;
+    })[]): ChainUpdateWhere<T>;
 }
 /** @public */
-export interface ChainDelete<T extends TableType = {}> extends ChainModifyReturning<T> {
-    where(where: Constructable<ConditionParam | void>): ChainModifyReturning<T>;
+export interface ChainDelete<T extends TableType = {}> extends ChainDeleteWhere<T> {
+    /**
+     * @example
+     * ```ts
+     *
+     * table.delete().using("table1 AS b", "(SELECT k FROM table2) AS c").where(...)
+     * // DELETE FROM table
+     * // USING table1 AS b, (SELECT k FROM table2) AS c
+     * // WHERE ...
+     * ```
+     */
+    using(...table: (Constructable<string> | {
+        selectable: Constructable<string>;
+        as: string;
+    })[]): ChainDeleteWhere<T>;
 }
 //# sourceMappingURL=chain_modify.d.ts.map

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

@@ -0,0 +1,44 @@
+import { Constructable } from "../util.ts";
+/**
+ * @public
+ */
+export interface ChainCTE {
+    as(statement: Constructable<string>): ChainCTE;
+    as(name: string, statement: Constructable<string>): ChainCTE;
+    toString(): string;
+}
+/**
+ * @public
+ * @example
+ * ```ts
+ *
+ * //WITH cte1 AS(SELECT * FROM table1)
+ *
+ * withAs("cte1","SELECT * FROM table1")
+ * withAs("cte1",() => "SELECT * FROM table1")
+ *
+ * withAs(() => "cte1 AS(SELECT * FROM table1)")
+ * withAs("cte1 AS(SELECT * FROM table1)")
+ * ```
+ */
+export declare function withAs(statement: Constructable<string>): ChainCTE;
+/** @public */
+export declare function withAs(name: string, statement: Constructable<string>): ChainCTE;
+/**
+ * @public
+ * @example
+ * ```ts
+ *
+ * //WITH RECURSIVE cte1 AS(SELECT * FROM table1)
+ *
+ * withRecursiveAs("cte1","SELECT * FROM table1")
+ * withRecursiveAs("cte1",() => "SELECT * FROM table1")
+ *
+ * withRecursiveAs(() => "cte1 AS(SELECT * FROM table1)")
+ * withRecursiveAs("cte1 AS(SELECT * FROM table1)")
+ * ```
+ */
+export declare function withRecursiveAs(statement: Constructable<string>): ChainCTE;
+/** @public */
+export declare function withRecursiveAs(name: string, statement: Constructable<string>): ChainCTE;
+//# sourceMappingURL=cte.d.ts.map

package/dist/sql_gen/select/cte.js

@@ -0,0 +1,38 @@
+function withAs(nameOrStatement, statement) {
+    return new ChainCETImpl(`WITH \n${concat(nameOrStatement, statement)}`);
+}
+function withRecursiveAs(nameOrStatement, statement) {
+    return new ChainCETImpl(`WITH RECURSIVE \n${concat(nameOrStatement, statement)}`);
+}
+class ChainCETImpl {
+    sql;
+    constructor(sql) {
+        this.sql = sql;
+    }
+    as(nameOrStatement, statement) {
+        if (statement) {
+            return new ChainCETImpl(`${this.sql}\n${concat(nameOrStatement, statement)}`);
+        }
+        else {
+            return new ChainCETImpl(concat(nameOrStatement, statement));
+        }
+    }
+    toString() {
+        return this.sql;
+    }
+}
+function concat(nameOrStatement, statement) {
+    if (statement) {
+        if (typeof statement === "function")
+            statement = statement();
+        return `${nameOrStatement} AS(${statement})`;
+    }
+    else {
+        statement = nameOrStatement;
+        if (typeof statement === "function")
+            statement = statement();
+        return statement;
+    }
+}
+
+export { withAs, withRecursiveAs };

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

@@ -5,6 +5,8 @@ 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);
+    from(...from: Constructable<string>[]): SqlChainModify<T>;
+    using(...from: Constructable<string>[]): SqlChainModify<T>;
     returning<R extends {}>(returns: Constructable<SelectParam | "*">): SqlStatementDataset<R>;
     onConflict(onConflict: Constructable<readonly string[] | string>): ChainAfterConflictDo<T>;
     where(where: Constructable<ConditionParam | void>): ChainModifyReturning<T>;

package/dist/sql_gen/select/query_chain_insert.js

@@ -8,6 +8,24 @@ class SqlChainModify extends SqlStatement {
         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 SqlChainModify(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 SqlChainModify(sql);
+    }
     returning(returns) {
         if (typeof returns === "function")
             returns = returns();

package/package.json

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