@asla/yoursql 0.12.1 → 0.13.1

package/README.md

@@ -70,42 +70,31 @@ import { v } from "@asla/yoursql";
 v.toValues([1, "abc", null, undefined, { key: "value" }]); // `1,'abc',NULL,DEFAULT,'{"key":"value"}'`
 ```
 
-#### v.objectToValue()
+#### v.createExplicitValues() 和 v.createImplicitValues()
 
-转换对象为 values 的单个值
+转换单个对象或对象数组为 VALUES
 
 ```ts
 import { v } from "@asla/yoursql";
-const obj = { a: "a1", b: "b1", c: undefined, d: "d1" };
-v.objectToValue(obj); // "'a1','b1',DEFAULT,'d1'"
-v.objectToValue(obj, ["b", "a"]); // "'b1','a1'"
-v.objectToValue(obj, [{ a: "TEXT", b: {} }]); // 'a1'::TEXT,'b1'"
-```
-
-#### v.objectListToValues()
 
-转换对象数组为 values
-
-```ts
-import { v } from "@asla/yoursql";
-
-const values = [{ a: 1, b: 2 }, { c: 3 }];
+const values = [{ a: 1, b: undefined }, { c: 3 }];
 
 // 这将自动选择数组中所有键的并集
-v.objectListToValues(values); // "(1,2,null),(null,null,3)"
+v.createExplicitValues(values).text; // "(1,NULL,NULL),(NULL,NULL,3)"
+v.createImplicitValues(values).text; // "(1,DEFAULT,NULL),(NULL,NULL,3)"
 
 // 或者你可以指定选择键并指定顺序
-const valueStr = v.objectListToValues(values, ["c", "b"]); // "(null,2),(3,3)"
+const valueStr = v.createExplicitValues(values, ["c", "b"]).text; // "(NULL,2),(3,NULL)"
 
 const sql = `INSERT INTO user(name, role) VALUES ${valueStr}`;
 ```
 
-#### v.createValues()
+可以指定 SQL类型和 JS 类型断言
 
 ```ts
 const objectList = [{ age: 1, name: "hhh" }, { age: 2, name: "row2" }, { age: 3, name: "row3" }, {}];
 
-v.createValues("customName", objectList, {
+v.createExplicitValues("customName", objectList, {
   age: { sqlType: "INT", sqlDefault: "MAXIMUM(1,2)" },
   name: "TEXT",
 });
@@ -162,12 +151,24 @@ import {
 
 ```ts
 class YourQuery extends DbQuery {
-  query<T = any>(sql: StringLike): Promise<QueryRowsResult<T>> {
+  execute(sql: QueryInput | MultipleQueryInput): Promise<void> {
+    // implement
+  }
+
+  query<T extends MultipleQueryResult = MultipleQueryResult>(sql: MultipleQueryInput): Promise<T>;
+  query<T = any>(sql: QueryDataInput<T>): Promise<QueryRowsResult<T>>;
+  query<T = any>(sql: QueryInput): Promise<QueryRowsResult<T>>;
+  query<T = any>(sql: QueryInput | MultipleQueryInput): Promise<QueryRowsResult<T>> {
     // implement
   }
   multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: StringLike): Promise<T> {
     // implement
   }
+  /**
+   * 执行多语句的方法
+   * @deprecated 不建议使用。改用 query()
+   */
+  abstract multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: SqlLike | SqlLike[]): Promise<T>;
 }
 const db: DbQuery = new YourQuery();
 ```
@@ -183,10 +184,10 @@ const count: number = await db.queryCount(sqlText);
 const rows: Map<string, Row> = await db.queryMap<Row>(sqlText, "name");
 ```
 
-#### DbQueryPool 接口
+#### DbQueryPool 抽象类
 
 ```ts
-class YourPool extends DbQuery implements DbQuery {
+class YourPool extends DbQueryPool {
   // implement
 }
 const pool: DbQueryPool = new YourPool();
@@ -203,7 +204,7 @@ try {
 }
 ```
 
-或者，使用 `using` 语法更优雅
+或者，使用 `using` 语法更优雅 (推荐)
 
 ```ts
 using conn = await pool.connect();
@@ -224,7 +225,7 @@ try {
 }
 ```
 
-或者，使用 `using` 语法更优雅
+或者，使用 `using` 语法更优雅 (推荐)
 
 ```ts
 await using conn = pool.begin();
@@ -250,7 +251,7 @@ while (rows.length) {
 }
 ```
 
-或者使用 `for await of` 更优雅
+或者使用 `for await of` 更优雅 (推荐)
 
 ```ts
 const cursor = await pool.cursor(sqlText);
@@ -259,62 +260,3 @@ for await (const element of cursor) {
   if (conditions) break; //提前关闭游标
 }
 ```
-
-### 扩展查询链
-
-```ts
-import { v, SqlStatement, SqlStatementDataset, SqlValuesCreator } from "@asla/yoursql";
-import type { DbCursor, QueryResult, QueryRowsResult } from "@asla/yoursql/client";
-
-declare const pool: DbQueryPool = new YourPool(); // 你需要实现一个 DbQueryPool
-
-export interface QueryableSql {
-  query(): Promise<QueryResult>;
-  queryCount(): Promise<number>;
-}
-export interface QueryableDataSql<T> extends QueryableSql {
-  queryRows(): Promise<T[]>;
-  queryMap<K>(key: string): Promise<Map<K, T>>;
-  cursor(): Promise<DbCursor<T>>;
-}
-declare module "@asla/yoursql" {
-  interface SqlStatement extends QueryableSql {}
-  interface SqlStatementDataset<T> extends QueryableDataSql<T> {}
-}
-const base: QueryableSql = {
-  queryCount(): Promise<number> {
-    return dbPool.queryCount(this.toString());
-  },
-  query(): Promise<QueryRowsResult<any>> {
-    return dbPool.query<any>(this);
-  },
-};
-const obj: QueryableDataSql<any> = {
-  ...base,
-  cursor(): Promise<DbCursor<any>> {
-    return dbPool.cursor(this.toString());
-  },
-  queryMap<K>(key: string): Promise<Map<K, any>> {
-    return dbPool.queryMap(this.toString(), key);
-  },
-  queryRows(): Promise<any[]> {
-    return dbPool.queryRows(this.toString());
-  },
-};
-
-Object.assign(SqlStatement.prototype, base);
-Object.assign(SqlStatementDataset.prototype, obj);
-```
-
-现在，以及扩展了 SqlStatement 和 SqlStatementDataset 类的原型链，你可以从 select 等语句直接调用查询方法了
-
-```ts
-import { Selection, v } from "@asla/yoursql";
-
-const searchName = "Bob";
-const rows = await Selection.from("user", "u")
-  .innerJoin("role", "r", "u.id=r.user_id")
-  .select({ uid: "u.id", rid: "r.id", example: "u.id||r.id" })
-  .where(`u.name LIKE %${v(searchName)}%`)
-  .queryRows();
-```

package/dist/sql_gen/mod.js

@@ -1,6 +1,5 @@
 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 { select } from './statement/select.js';
 export { insertInto } from './statement/insert.js';
@@ -11,7 +10,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 { TemplateSqlStatement as ValueSqlTemplate } from './sql_value/ValueSqlTemplate.js';
+export { TemplateSqlStatement } from './sql_value/ValueSqlTemplate.js';
 export { orderBy } from './statement/select_impl.js';
 
 /**

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

@@ -0,0 +1,29 @@
+/** @public */
+export interface SqlValuesDataset {
+    readonly columns: readonly string[];
+    readonly text: string;
+    toSelect(name: string): string;
+}
+export declare class ExplicitSqlValues implements SqlValuesDataset {
+    #private;
+    columns: readonly string[];
+    readonly columnsSqlType: readonly string[];
+    constructor(columns: readonly string[], columnsSqlType: readonly string[], firstValues: string[], nextRows: string[]);
+    get text(): string;
+    /**
+     * @example
+     * ```ts
+     *  const t = v.createImplicitValues(
+     *    [
+     *      { id: 1, name: "name1" },
+     *      { id: 2, name: "name2" },
+     *    ],
+     *    { id: "INT", name: "VARCHAR" },
+     *  );
+     *  // 返回 (VALUES (1::INT,'name1'::VARCHAR),(2,'name2')) AS t1(id,name)
+     *  t.toSelect("t1(id,name)")
+     * ```
+     */
+    toSelect(name: string): string;
+}
+//# sourceMappingURL=SqlValuesDataset.d.ts.map

package/dist/sql_gen/sql_value/SqlValuesDataset.js

@@ -0,0 +1,53 @@
+class ExplicitSqlValues {
+    columns;
+    columnsSqlType;
+    constructor(columns, columnsSqlType, firstValues, nextRows) {
+        this.columns = columns;
+        this.columnsSqlType = columnsSqlType;
+        this.#firstValues = firstValues;
+        this.#rows = nextRows;
+    }
+    #rows;
+    #firstValues;
+    #text;
+    get text() {
+        if (!this.#text) {
+            this.#text = this.#genText();
+        }
+        return this.#text;
+    }
+    #genText() {
+        const { columnsSqlType } = this;
+        const firstValues = this.#firstValues;
+        let firstRow = new Array(firstValues.length);
+        for (let i = 0; i < firstValues.length; i++) {
+            firstRow[i] = firstValues[i];
+            if (columnsSqlType[i])
+                firstRow[i] += "::" + columnsSqlType[i];
+        }
+        const base = "(" + firstRow.join(",") + ")";
+        if (this.#rows.length === 0) {
+            return base;
+        }
+        return "(" + firstRow.join(",") + "),\n" + this.#rows.join(",\n");
+    }
+    /**
+     * @example
+     * ```ts
+     *  const t = v.createImplicitValues(
+     *    [
+     *      { id: 1, name: "name1" },
+     *      { id: 2, name: "name2" },
+     *    ],
+     *    { id: "INT", name: "VARCHAR" },
+     *  );
+     *  // 返回 (VALUES (1::INT,'name1'::VARCHAR),(2,'name2')) AS t1(id,name)
+     *  t.toSelect("t1(id,name)")
+     * ```
+     */
+    toSelect(name) {
+        return `(VALUES\n${this.text})\nAS ${name}(${this.columns.join(",")})`;
+    }
+}
+
+export { ExplicitSqlValues };

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

@@ -0,0 +1,24 @@
+import { AssertJsType, ColumnToValueConfig, ObjectToValueKeys } from "./type.ts";
+interface ValueToSqlStr {
+    toSqlStr(value: any, assertType?: AssertJsType): string;
+}
+export declare function internalObjectToValues(object: Record<string, any>, keys: readonly string[], type: (ColumnToValueConfig | undefined)[], undefinedDefault: string, v: ValueToSqlStr): {
+    values: string[];
+    types: string[];
+};
+export type ObjectToValueOption = {
+    undefinedDefault?: string;
+};
+export declare class AssertError extends TypeError {
+    constructor(assertType: string, actual: string);
+}
+export declare function getObjectValueInfo(object: Record<string | number, any>, keys_types: readonly string[] | Record<string, string | undefined> | undefined): {
+    keys: string[];
+    type: (ColumnToValueConfig | undefined)[];
+};
+export declare function getColumnInfo(objectList: readonly Record<string, any>[], columns?: ObjectToValueKeys<Record<string, any>>): {
+    keys: string[];
+    asserts: (ColumnToValueConfig | undefined)[];
+};
+export {};
+//# sourceMappingURL=_to_values.d.ts.map

package/dist/sql_gen/sql_value/_to_values.js

@@ -0,0 +1,91 @@
+import { getObjectListKeys } from '../_statement.js';
+
+function internalObjectToValues(object, keys, type, undefinedDefault, v) {
+    const values = new Array(keys.length);
+    const types = new Array(keys.length);
+    let i = 0;
+    let key;
+    let value;
+    let assertType;
+    try {
+        for (; i < keys.length; i++) {
+            key = keys[i];
+            value = object[key];
+            assertType = type[i];
+            if (assertType) {
+                values[i] =
+                    value === undefined ? assertType.sqlDefault || undefinedDefault : v.toSqlStr(value, assertType.assertJsType);
+                if (assertType.sqlType) {
+                    types[i] = assertType.sqlType;
+                }
+            }
+            else {
+                values[i] = value === undefined ? undefinedDefault : v.toSqlStr(value);
+            }
+        }
+    }
+    catch (error) {
+        let message = error instanceof Error ? error.message : String(error);
+        throw new Error("字段 '" + key + "' 异常，" + message);
+    }
+    if (values.length === 0)
+        throw new Error("object 不能为空");
+    return { values, types };
+}
+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;
+}
+function getObjectValueInfo(object, keys_types) {
+    let type;
+    let keys;
+    if (keys_types instanceof Array) {
+        keys = [...keys_types];
+        type = [];
+    }
+    else if (keys_types) {
+        keys = Object.keys(keys_types);
+        type = initColumnAssert(keys, keys_types);
+    }
+    else {
+        keys = Object.keys(object).filter((k) => object[k] !== undefined);
+        type = [];
+    }
+    return { keys, type };
+}
+function getColumnInfo(objectList, columns) {
+    let keys;
+    let asserts;
+    if (!columns) {
+        keys = Array.from(getObjectListKeys(objectList));
+        asserts = [];
+    }
+    else if (columns instanceof Array) {
+        keys = [...columns];
+        asserts = [];
+    }
+    else {
+        keys = Object.keys(columns);
+        asserts = initColumnAssert(keys, columns);
+    }
+    return { keys, asserts };
+}
+
+export { AssertError, getColumnInfo, getObjectValueInfo, internalObjectToValues };

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

@@ -1,6 +1,8 @@
+import { SqlValuesDataset } from "./SqlValuesDataset.ts";
 import { TemplateSqlStatement } from "./ValueSqlTemplate.ts";
 import { AssertJsType, ObjectToValueKeys } from "./type.ts";
-export { TemplateSqlStatement as ValueSqlTemplate } from "./ValueSqlTemplate.ts";
+export { TemplateSqlStatement } from "./ValueSqlTemplate.ts";
+export type { SqlValuesDataset } from "./SqlValuesDataset.ts";
 /** @public js 对象到编码函数的映射*/
 export type JsObjectMapSql = Map<new (...args: any[]) => any, SqlValueEncoder>;
 /** @public 将 js 值转为 SQl 字符串的函数*/
@@ -51,19 +53,17 @@ export declare class SqlValuesCreator {
      * @example 返回的文本示例： " (...),(...) "
      * @param columns - 选择的键。如果指定了 columns, 值为 undefined 的属性将自动填充为 null; 如果未指定 columns，将选择 objectList 所有不是 undefined 项的键的并集
      */
-    createImplicitValues<T extends object>(objectList: T, columns?: ObjectToValueKeys<T>): SqlValuesTextData;
-    createImplicitValues<T extends object>(objectList: T[], columns?: ObjectToValueKeys<T>): SqlValuesTextData;
+    createImplicitValues<T extends object>(objectList: T, columns?: ObjectToValueKeys<T>): SqlValuesDataset;
+    createImplicitValues<T extends object>(objectList: T[], columns?: ObjectToValueKeys<T>): SqlValuesDataset;
     /**
      * 将对象列表转为 SQL 的 VALUES。如果 objectList 中有某个对象的属性值为 undefined，则会被转换为 "NULL"
      * @example 返回的文本示例： " (...),(...) "
      * @param columns - 选择的键。
      */
-    createExplicitValues<T extends object>(objectList: T, columns?: ObjectToValueKeys<T>): SqlExplicitValuesStatement;
-    createExplicitValues<T extends object>(objectList: T[], columns?: ObjectToValueKeys<T>): SqlExplicitValuesStatement;
+    createExplicitValues<T extends object>(objectList: T, columns?: ObjectToValueKeys<T>): SqlValuesDataset;
+    createExplicitValues<T extends object>(objectList: T[], columns?: ObjectToValueKeys<T>): SqlValuesDataset;
     private _objectListToValues;
     private _objectToValue;
-    private _getObjectValueInfo;
-    private _internalObjectToValues;
     /**
      * 将数组列表转为 SQL 的一个 value
      * @example
@@ -73,16 +73,4 @@ export declare class SqlValuesCreator {
      */
     toValues(values: readonly any[]): string;
 }
-/** @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,5 +1,6 @@
-import { getObjectListKeys } from '../_statement.js';
+import { ExplicitSqlValues } from './SqlValuesDataset.js';
 import { TemplateSqlStatement } from './ValueSqlTemplate.js';
+import { AssertError, getColumnInfo, internalObjectToValues, getObjectValueInfo } from './_to_values.js';
 
 /**
  * SQL value 生成器
@@ -122,7 +123,7 @@ class SqlValuesCreator {
         else {
             res = this._objectToValue(objectList, columns, { undefinedDefault: "DEFAULT" });
         }
-        return { columns: [...res.columns], text: res.text };
+        return res;
     }
     createExplicitValues(objectList, columns) {
         if (objectList instanceof Array) {
@@ -135,100 +136,39 @@ class SqlValuesCreator {
     _objectListToValues(objectList, columns, option = {}) {
         if (objectList.length <= 0)
             throw new Error("objectList 不能是空数组");
-        let keys;
-        let asserts;
-        if (!columns) {
-            keys = Array.from(getObjectListKeys(objectList));
-            asserts = [];
-        }
-        else if (columns instanceof Array) {
-            keys = [...columns];
-            asserts = [];
-        }
-        else {
-            keys = Object.keys(columns);
-            asserts = initColumnAssert(keys, columns);
-        }
+        const { keys, asserts } = getColumnInfo(objectList, columns);
         const undefinedDefault = option.undefinedDefault || "DEFAULT";
-        let str = "(" + this._internalObjectToValues(objectList[0], keys, asserts, undefinedDefault) + ")";
-        let i = 1;
+        let firstRow = internalObjectToValues(objectList[0], keys, asserts, undefinedDefault, this);
         let j;
         let value;
-        let rows;
+        const rows = new Array(objectList.length - 1);
         let assert;
+        let i = 1;
         try {
             for (; i < objectList.length; i++) {
                 const object = objectList[i];
-                rows = [];
+                const columns = [];
                 j = 0;
                 for (; j < keys.length; j++) {
                     value = object[keys[j]];
                     assert = asserts[j];
-                    rows[j] =
+                    columns[j] =
                         value === undefined ? assert?.sqlDefault || undefinedDefault : this.toSqlStr(value, assert?.assertJsType);
                 }
-                str += ",\n(" + rows.join(",") + ")";
+                rows[i - 1] = "(" + columns.join(",") + ")";
             }
         }
         catch (error) {
             let message = error instanceof Error ? error.message : String(error);
             throw new Error("第 " + i + " 项，字段 '" + keys[j] + "' 异常，" + message);
         }
-        return new SqlExplicitValuesStatement(keys, str);
+        return new ExplicitSqlValues(keys, firstRow.types, firstRow.values, rows);
     }
     _objectToValue(object, keys_types, option = {}) {
-        const { keys, type } = this._getObjectValueInfo(object, keys_types);
+        const { keys, type } = getObjectValueInfo(object, keys_types);
         const undefinedDefault = option.undefinedDefault || "DEFAULT";
-        const text = this._internalObjectToValues(object, keys, type, undefinedDefault);
-        return new SqlExplicitValuesStatement(keys, `(${text})`);
-    }
-    _getObjectValueInfo(object, keys_types) {
-        let type;
-        let keys;
-        if (keys_types instanceof Array) {
-            keys = [...keys_types];
-            type = [];
-        }
-        else if (keys_types) {
-            keys = Object.keys(keys_types);
-            type = initColumnAssert(keys, keys_types);
-        }
-        else {
-            keys = Object.keys(object).filter((k) => object[k] !== undefined);
-            type = [];
-        }
-        return { keys, type };
-    }
-    _internalObjectToValues(object, keys, type, undefinedDefault) {
-        const values = [];
-        let i = 0;
-        let key;
-        let value;
-        let assertType;
-        try {
-            for (; i < keys.length; i++) {
-                key = keys[i];
-                value = object[key];
-                assertType = type[i];
-                if (assertType) {
-                    values[i] =
-                        value === undefined
-                            ? assertType.sqlDefault || undefinedDefault
-                            : this.toSqlStr(value, assertType.assertJsType);
-                    if (assertType.sqlType)
-                        values[i] += "::" + assertType.sqlType;
-                }
-                else
-                    values[i] = value === undefined ? undefinedDefault : this.toSqlStr(value);
-            }
-        }
-        catch (error) {
-            let message = error instanceof Error ? error.message : String(error);
-            throw new Error("字段 '" + key + "' 异常，" + message);
-        }
-        if (values.length === 0)
-            throw new Error("object 不能为空");
-        return values.join(",");
+        const res = internalObjectToValues(object, keys, type, undefinedDefault, this);
+        return new ExplicitSqlValues(keys, res.types, res.values, []);
     }
     /**
      * 将数组列表转为 SQL 的一个 value
@@ -243,38 +183,5 @@ class SqlValuesCreator {
         return values.map((v) => this.toSqlStr(v)).join(",");
     }
 }
-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 { SqlExplicitValuesStatement, SqlValuesCreator, TemplateSqlStatement as ValueSqlTemplate };
+export { SqlValuesCreator, TemplateSqlStatement };

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

@@ -8,6 +8,14 @@ export interface InsertIntoSqlGenerator {
 /** @public */
 export interface ChainAfterConflict {
     doNotThing(): ChainInsertReturning;
+    /**
+     * @example
+     * ```ts
+     *  doUpdate("SET level= 89,name= 11") // " DO UPDATE SET level= 89,name= 11"
+     *  doUpdate(["level= 89", "name= 11"]) // " DO UPDATE SET\nlevel= 89,name= 11"
+     *  doUpdate({level: "89", name: "11"}) // " DO UPDATE SET\nlevel= 89,name= 11"
+     * ```
+     */
     doUpdate(set: Constructable<string | readonly string[] | Record<string, string>>): ChainInsertReturning;
     toString(): string;
 }

package/package.json

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