@asla/yoursql 0.13.0 → 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 { 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';
@@ -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/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 字符串的函数*/
@@ -71,27 +73,4 @@ export declare class SqlValuesCreator {
      */
     toValues(values: readonly any[]): string;
 }
-/** @public */
-export declare class 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=sql_value.d.ts.map

package/dist/sql_gen/sql_value/sql_value.js

@@ -1,3 +1,4 @@
+import { ExplicitSqlValues } from './SqlValuesDataset.js';
 import { TemplateSqlStatement } from './ValueSqlTemplate.js';
 import { AssertError, getColumnInfo, internalObjectToValues, getObjectValueInfo } from './_to_values.js';
 
@@ -161,13 +162,13 @@ class SqlValuesCreator {
             let message = error instanceof Error ? error.message : String(error);
             throw new Error("第 " + i + " 项，字段 '" + keys[j] + "' 异常，" + message);
         }
-        return new SqlValuesDataset(keys, firstRow.types, firstRow.values, rows);
+        return new ExplicitSqlValues(keys, firstRow.types, firstRow.values, rows);
     }
     _objectToValue(object, keys_types, option = {}) {
         const { keys, type } = getObjectValueInfo(object, keys_types);
         const undefinedDefault = option.undefinedDefault || "DEFAULT";
         const res = internalObjectToValues(object, keys, type, undefinedDefault, this);
-        return new SqlValuesDataset(keys, res.types, res.values, []);
+        return new ExplicitSqlValues(keys, res.types, res.values, []);
     }
     /**
      * 将数组列表转为 SQL 的一个 value
@@ -182,57 +183,5 @@ class SqlValuesCreator {
         return values.map((v) => this.toSqlStr(v)).join(",");
     }
 }
-/** @public */
-class SqlValuesDataset {
-    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 { SqlValuesCreator, SqlValuesDataset, 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.13.0",
+  "version": "0.13.1",
   "description": "",
   "type": "module",
   "types": "./dist/mod.d.ts",