@asla/yoursql 0.12.1 → 0.13.0

package/dist/sql_gen/mod.js

@@ -1,6 +1,6 @@
 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 { SqlValuesDataset } 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';

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

@@ -51,19 +51,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
@@ -74,15 +72,26 @@ export declare class SqlValuesCreator {
     toValues(values: readonly any[]): string;
 }
 /** @public */
-export type SqlValuesTextData = {
-    columns: string[];
-    text: string;
-};
-/** @public */
-export declare class SqlExplicitValuesStatement {
+export declare class SqlValuesDataset {
+    #private;
     columns: readonly string[];
-    readonly text: string;
-    constructor(columns: readonly string[], text: 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=sql_value.d.ts.map

package/dist/sql_gen/sql_value/sql_value.js

@@ -1,5 +1,5 @@
-import { getObjectListKeys } from '../_statement.js';
 import { TemplateSqlStatement } from './ValueSqlTemplate.js';
+import { AssertError, getColumnInfo, internalObjectToValues, getObjectValueInfo } from './_to_values.js';
 
 /**
  * SQL value 生成器
@@ -122,7 +122,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 +135,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 SqlValuesDataset(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 SqlValuesDataset(keys, res.types, res.values, []);
     }
     /**
      * 将数组列表转为 SQL 的一个 value
@@ -243,38 +182,57 @@ 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 {
+class SqlValuesDataset {
     columns;
-    text;
-    constructor(columns, text) {
+    columnsSqlType;
+    constructor(columns, columnsSqlType, firstValues, nextRows) {
         this.columns = columns;
-        this.text = text;
+        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 { SqlExplicitValuesStatement, SqlValuesCreator, TemplateSqlStatement as ValueSqlTemplate };
+export { SqlValuesCreator, SqlValuesDataset, TemplateSqlStatement as ValueSqlTemplate };

package/package.json

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