@asla/yoursql 0.10.1 → 0.10.2

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,5 +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 { SqlStatement, SqlStatementDataset, SqlTextStatementDataset } from './SqlStatement.js';
 export { orderBy, select } from './statement/select.js';
 export { insertInto } from './statement/insert.js';

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 { AssertJsType, ColumnToValueConfig, ObjectToValueKeys } from "./type.ts";
 /** @public js 对象到编码函数的映射*/
 export type JsObjectMapSql = Map<new (...args: any[]) => any, SqlValueEncoder>;
 /** @public 将 js 值转为 SQl 字符串的函数*/
@@ -45,20 +45,32 @@ 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;
+    /** @deprecated 改用 createImplicitValues */
+    objectListToValuesList<T extends object>(objectList: T[], keys?: ObjectToValueKeys<T>): string;
+    /** @deprecated 请使用 objectListToValues 代替 */
+    objectListToValues<T extends object>(objectList: T[], columns?: ObjectToValueKeys<T>): SqlValuesTextData;
     /**
-     * 将对象列表转为 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;
+    /**
+     * 将对象列表转为 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;
+    private _objectListToValues;
+    private _objectToValue;
     /**
      * @deprecated 请使用 objectToValue 代替
      */
     objectToValues<T extends object>(object: T, keys?: ObjectToValueKeys<T>): string;
     /**
+     * @deprecated 请使用 createImplicitValues 代替
      * 将对象转为 SQL 的 value
      * @example
      * ```ts
@@ -83,6 +95,7 @@ export declare class SqlValuesCreator {
      */
     toValues(values: readonly any[]): string;
     /**
+     * @deprecated 请使用 objectListToValues 代替
      * @public 创建 VALUES AS  语句
      * @example
      * ```ts
@@ -94,10 +107,20 @@ export declare class SqlValuesCreator {
      * // (VALUES (8:INT,'hhh':TEXT),(9,'row2')) AS customName(age, name)
      * ```
      */
-    createValues<T extends {}>(asName: string, values: T[], valuesTypes: Record<string, string | {
+    createValues<T extends {}>(asName: string, values: T[], valuesTypes: Record<string, string | ({
         sqlType: string;
-        sqlDefault?: string;
-        assertJsType?: AssertJsType;
-    }>): SqlStatementDataset<T>;
+    } & Pick<ColumnToValueConfig, "assertJsType" | "sqlDefault">)>): 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,6 @@
+import { SqlTextStatementDataset } from '../SqlStatement.js';
 import { getObjectListKeys } from '../_statement.js';
 import { ValueSqlTemplate } from './ValueSqlTemplate.js';
-import { initColumnAssert, YourValuesAs } from './_utils.js';
 
 /**
  * SQL value 生成器
@@ -115,32 +115,56 @@ class SqlValuesCreator {
     defaultObject(value) {
         return SqlValuesCreator.string(JSON.stringify(value));
     }
-    /** @deprecated 改用 objectListToValues */
-    objectListToValuesList(objectList, keys, keepUndefinedKey) {
-        return this.objectListToValues(objectList, keys, keepUndefinedKey).text;
+    /** @deprecated 改用 createImplicitValues */
+    objectListToValuesList(objectList, keys) {
+        return this.objectListToValues(objectList, keys).text;
     }
-    objectListToValues(objectList, keys_types, keepUndefinedKey) {
+    /** @deprecated 请使用 objectListToValues 代替 */
+    objectListToValues(objectList, columns) {
+        return this.createImplicitValues(objectList, columns);
+    }
+    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, 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 +172,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 +183,34 @@ 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);
+        const undefinedDefault = option.undefinedDefault || "DEFAULT";
+        const text = this._internalObjectToValues(object, keys, type, undefinedDefault);
+        return new SqlExplicitValuesStatement(keys, `(${text})`);
     }
-    objectToValue(object, keys_types) {
+    objectToValues(object, keys_types) {
         const { keys, type } = this._getObjectValueInfo(object, keys_types);
-        const text = this._internalObjectToValues(object, keys, type);
-        return { columns: keys, text: "(" + text + ")" };
+        return this._internalObjectToValues(object, keys, type, "DEFAULT");
+    }
+    /**
+     * @deprecated 请使用 createImplicitValues 代替
+     * 将对象转为 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
+     */
+    objectToValue(object, keys) {
+        return this.createImplicitValues(object, keys);
     }
     _getObjectValueInfo(object, keys_types) {
         let type;
@@ -185,7 +229,7 @@ class SqlValuesCreator {
         }
         return { keys, type };
     }
-    _internalObjectToValues(object, keys, type) {
+    _internalObjectToValues(object, keys, type, undefinedDefault) {
         const values = [];
         let i = 0;
         let key;
@@ -197,12 +241,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) {
@@ -228,51 +275,8 @@ class SqlValuesCreator {
     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"));
+        const res = this.createExplicitValues(values, valuesTypes); // 预检数据
+        return new SqlTextStatementDataset(res.toSelect(asName));
     }
 }
 class AssertError extends TypeError {
@@ -280,5 +284,33 @@ class AssertError extends TypeError {
         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/package.json

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

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

@@ -1,11 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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 };