@asla/yoursql 0.13.0 → 0.14.0

package/README.md

@@ -1,7 +1,5 @@
-[![ESM package][package]][package-url]
-[![NPM version][npm]][npm-url]
-[![JSR version][jsr]][jsr-url]
-[![Install size][size]][size-url]
+[![ESM package][package]][package-url] [![NPM version][npm]][npm-url]
+[![JSR version][jsr]][jsr-url] [![Install size][size]][size-url]
 
 [package]: https://img.shields.io/badge/package-ESM-ffe536.svg
 [package-url]: https://nodejs.org/api/esm.html
@@ -23,7 +21,8 @@ SQL 生成器
 安全转将 JS 值转换为 SQL 值，避免 SQL 注入
 
 `v` 函数能够将 JS 值转换为 SQL 的文本形式。\
-默认情况下，支持 PostgresSQL, 因为不同数据库的值转换有些差异，如果使用其他数据库，可能需要配置对象到字符串的自定义转换器
+默认情况下，支持 PostgresSQL,
+因为不同数据库的值转换有些差异，如果使用其他数据库，可能需要配置对象到字符串的自定义转换器
 
 ```ts
 import { v } from "@asla/yoursql";
@@ -41,7 +40,8 @@ const params = { id: 3 };
 const sql = `SELECT * FROM user WHERE user_id=${v(params.id)}`;
 ```
 
-如果传入 String 对象，将保留其字符串值，不会进行任何转换， 这在有些需要原生SQL操作的场景下非常有用
+如果传入 String 对象，将保留其字符串值，不会进行任何转换，
+这在有些需要原生SQL操作的场景下非常有用
 
 ```ts
 import { v } from "@asla/yoursql";
@@ -49,7 +49,8 @@ import { v } from "@asla/yoursql";
 v(new String("1+1")); // "1+1"
 ```
 
-你可以自定义对象到字符串的转换, 例如，你想将 Set 转换为 PostgresSql 的 ARRAY[] 输入格式
+你可以自定义对象到字符串的转换, 例如，你想将 Set 转换为 PostgresSql 的 ARRAY[]
+输入格式
 
 ```ts
 import { v } from "@asla/yoursql";
@@ -70,42 +71,34 @@ 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 的单个值
-
-```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
+转换单个对象或对象数组为 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" }, {}];
+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",
 });
@@ -131,8 +124,8 @@ const s = select({ uid: "u.id", rid: "r.id", example: "u.id||r.id" })
   .toString();
 ```
 
-查看 [select](./docs/select.md) 用法
-查看 [insert/update/delete](./docs/table.md) 用法
+查看 [select](./docs/select.md) 用法 查看
+[insert/update/delete](./docs/table.md) 用法
 
 #### Constructable
 
@@ -141,180 +134,3 @@ toto
 #### ConditionParam
 
 toto
-
-### client 抽象类
-
-yoursql 还导出了一些抽象类，实现抽象类后可以方便的进行数据查询
-
-```ts
-import {
-  type DbQueryPool,
-  type DbTransaction,
-  type DbConnection,
-  DbQuery,
-  DbCursor,
-  DbPoolConnection,
-  DbPoolTransaction,
-} from "@asla/yoursql/client";
-```
-
-#### DbQuery 抽象类
-
-```ts
-class YourQuery extends DbQuery {
-  query<T = any>(sql: StringLike): Promise<QueryRowsResult<T>> {
-    // implement
-  }
-  multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: StringLike): Promise<T> {
-    // implement
-  }
-}
-const db: DbQuery = new YourQuery();
-```
-
-```ts
-declare const db: DbQuery;
-
-type Row = { name: string; age: number };
-const sqlText = "SELECT * FROM user";
-
-const rows: Row[] = await db.queryRows<Row>(sqlText);
-const count: number = await db.queryCount(sqlText);
-const rows: Map<string, Row> = await db.queryMap<Row>(sqlText, "name");
-```
-
-#### DbQueryPool 接口
-
-```ts
-class YourPool extends DbQuery implements DbQuery {
-  // implement
-}
-const pool: DbQueryPool = new YourPool();
-```
-
-##### 普通查询
-
-```ts
-const conn = await pool.connect();
-try {
-  await conn.queryRows(sqlText);
-} finally {
-  conn.release();
-}
-```
-
-或者，使用 `using` 语法更优雅
-
-```ts
-using conn = await pool.connect();
-await conn.queryRows(sqlText);
-```
-
-##### 事务查询
-
-```ts
-const conn = pool.begin();
-try {
-  await conn.queryRows(sqlText);
-  await conn.queryRows(sqlText);
-  await conn.commit();
-} catch (e) {
-  await conn.rollback();
-  throw e;
-}
-```
-
-或者，使用 `using` 语法更优雅
-
-```ts
-await using conn = pool.begin();
-
-await conn.queryRows(sqlText);
-await conn.queryRows(sqlText);
-await conn.commit();
-```
-
-##### 游标查询
-
-```ts
-const cursor = await pool.cursor(sqlText);
-
-let rows = await cursor.read(20);
-while (rows.length) {
-  console.log(rows);
-  rows = await cursor.read(20);
-  if (conditions) {
-    await cursor.close(); // 提前关闭游标
-    break;
-  }
-}
-```
-
-或者使用 `for await of` 更优雅
-
-```ts
-const cursor = await pool.cursor(sqlText);
-for await (const element of cursor) {
-  console.log(element);
-  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/SqlStatement.d.ts

@@ -58,4 +58,3 @@ export interface SqlTextTemplate {
     readonly textTemplate: string;
     readonly textArgs: readonly string[];
 }
-//# sourceMappingURL=SqlStatement.d.ts.map

package/dist/sql_gen/SqlStatement.js

@@ -1,12 +1,12 @@
 /** @public */
-class SqlStatement {
+export class SqlStatement {
     /** 获取 SQL 语句 */
     toString() {
         return this.genSql();
     }
 }
 /** @public */
-class SqlStatementDataset extends SqlStatement {
+export class SqlStatementDataset extends SqlStatement {
     /**
      * 转成子选择语句, 你可以使用 select form xxx 选择
      * 如果是 table 则是 table name
@@ -26,7 +26,7 @@ class SqlStatementDataset extends SqlStatement {
     }
 }
 /** @public */
-class SqlTextStatementDataset extends SqlStatementDataset {
+export class SqlTextStatementDataset extends SqlStatementDataset {
     sql;
     constructor(sql) {
         super();
@@ -36,5 +36,3 @@ class SqlTextStatementDataset extends SqlStatementDataset {
         return this.sql;
     }
 }
-
-export { SqlStatement, SqlStatementDataset, SqlTextStatementDataset };

package/dist/sql_gen/_statement.d.ts

@@ -26,4 +26,3 @@ export declare function whereToString(conditions?: Constructable<ConditionParam
 export declare function createUpdateSetFromObject(set: Record<string, string | undefined>, prefix?: string): string;
 export declare function selectableToString(selectable: Constructable<SqlSelectable | string>, as?: string): string;
 export declare function returningToString(returns: Constructable<SelectParam | "*">): string;
-//# sourceMappingURL=_statement.d.ts.map

package/dist/sql_gen/_statement.js

@@ -1,10 +1,9 @@
-import { selectColumns } from './util.js';
-
+import { selectColumns } from "./util.js";
 /**
  * 获取对象数组中的 key 的集合
  * @param keepUndefinedKey - 是否保留值为 undefined 的 key
  */
-function getObjectListKeys(objectList, keepUndefinedKey) {
+export function getObjectListKeys(objectList, keepUndefinedKey) {
     let keys = new Set();
     for (let i = 0; i < objectList.length; i++) {
         let obj = objectList[i];
@@ -14,14 +13,14 @@ function getObjectListKeys(objectList, keepUndefinedKey) {
             k = hasKeys[j];
             if (typeof k !== "string")
                 continue;
-            if (obj[k] === undefined)
+            if (!keepUndefinedKey && obj[k] === undefined)
                 continue;
             keys.add(k);
         }
     }
     return keys;
 }
-function condition(conditions, type = "AND") {
+export function condition(conditions, type = "AND") {
     if (typeof conditions === "function")
         conditions = conditions();
     if (!conditions)
@@ -53,13 +52,13 @@ function condition(conditions, type = "AND") {
  * where(undefined) // ""
  * ```
  */
-function whereToString(conditions, type) {
+export function whereToString(conditions, type) {
     const sql = condition(conditions, type);
     if (sql)
         return "\nWHERE " + sql;
     return "";
 }
-function createUpdateSetFromObject(set, prefix) {
+export function createUpdateSetFromObject(set, prefix) {
     const updateKey = Object.keys(set);
     let i = 0;
     let key;
@@ -68,7 +67,7 @@ function createUpdateSetFromObject(set, prefix) {
     let sql;
     for (; i < updateKey.length; i++) {
         key = updateKey[i];
-        sqlKey = key;
+        sqlKey = prefix ? `${prefix}.${key}` : key;
         value = set[key];
         if (value === undefined)
             continue;
@@ -85,7 +84,7 @@ function createUpdateSetFromObject(set, prefix) {
         i++;
         for (; i < updateKey.length; i++) {
             key = updateKey[i];
-            sqlKey = key;
+            sqlKey = prefix ? `${prefix}.${key}` : key;
             value = set[key];
             if (value === undefined)
                 continue;
@@ -101,7 +100,7 @@ function createUpdateSetFromObject(set, prefix) {
     else
         throw new Error("值不能为空");
 }
-function selectableToString(selectable, as) {
+export function selectableToString(selectable, as) {
     if (typeof selectable === "function")
         selectable = selectable();
     let sql = typeof selectable === "string" ? selectable : selectable.toSelect();
@@ -111,7 +110,7 @@ function selectableToString(selectable, as) {
         sql += " AS " + as;
     return sql;
 }
-function returningToString(returns) {
+export function returningToString(returns) {
     if (typeof returns === "function")
         returns = returns();
     let columnsStr;
@@ -123,5 +122,3 @@ function returningToString(returns) {
     }
     return "\nRETURNING " + columnsStr;
 }
-
-export { condition, createUpdateSetFromObject, getObjectListKeys, returningToString, selectableToString, whereToString };

package/dist/sql_gen/mod.d.ts

@@ -11,4 +11,3 @@ import { SqlValueFn } from "./sql_value/sql_value.ts";
  * @public
  */
 export declare const v: SqlValueFn;
-//# sourceMappingURL=mod.d.ts.map

package/dist/sql_gen/mod.js

@@ -1,23 +1,14 @@
-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';
-export { update } from './statement/update.js';
-export { deleteFrom } from './statement/delete.js';
-export { withAs, withRecursiveAs } from './statement/cte.js';
-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 { orderBy } from './statement/select_impl.js';
-
+export * from "./sql_value/db_type.js";
+export * from "./sql_value/sql_value.js";
+export * from "./sql_value/type.js";
+export * from "./SqlStatement.js";
+export * from "./statement/mod.js";
+export * from "./util.js";
+export * from "./your_table/mod.js";
+import { SqlValuesCreator } from "./sql_value/sql_value.js";
+import { pgSqlTransformer } from "./sql_value/db_type.js";
 /**
  * 默认的 SqlValuesCreator 实列
  * @public
  */
-const v = SqlValuesCreator.create(pgSqlTransformer);
-
-export { SqlValuesCreator, pgSqlTransformer, v };
+export const v = SqlValuesCreator.create(pgSqlTransformer);

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

@@ -0,0 +1,28 @@
+/** @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;
+}

package/dist/sql_gen/sql_value/SqlValuesDataset.js

@@ -0,0 +1,51 @@
+export 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(",")})`;
+    }
+}

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

@@ -11,4 +11,3 @@ export declare class TemplateSqlStatement extends SqlStatement implements SqlTem
     toTextArgs(): string[];
     genSql(): string;
 }
-//# sourceMappingURL=ValueSqlTemplate.d.ts.map

package/dist/sql_gen/sql_value/ValueSqlTemplate.js

@@ -1,7 +1,6 @@
-import { SqlStatement } from '../SqlStatement.js';
-
+import { SqlStatement } from "../SqlStatement.js";
 /** @alpha */
-class TemplateSqlStatement extends SqlStatement {
+export class TemplateSqlStatement extends SqlStatement {
     v;
     templates;
     args;
@@ -45,5 +44,3 @@ class TemplateSqlStatement extends SqlStatement {
         return sql;
     }
 }
-
-export { TemplateSqlStatement };

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

@@ -21,4 +21,3 @@ export declare function getColumnInfo(objectList: readonly Record<string, any>[]
     asserts: (ColumnToValueConfig | undefined)[];
 };
 export {};
-//# sourceMappingURL=_to_values.d.ts.map

package/dist/sql_gen/sql_value/_to_values.js

@@ -1,6 +1,5 @@
-import { getObjectListKeys } from '../_statement.js';
-
-function internalObjectToValues(object, keys, type, undefinedDefault, v) {
+import { getObjectListKeys } from "../_statement.js";
+export function internalObjectToValues(object, keys, type, undefinedDefault, v) {
     const values = new Array(keys.length);
     const types = new Array(keys.length);
     let i = 0;
@@ -32,7 +31,7 @@ function internalObjectToValues(object, keys, type, undefinedDefault, v) {
         throw new Error("object 不能为空");
     return { values, types };
 }
-class AssertError extends TypeError {
+export class AssertError extends TypeError {
     constructor(assertType, actual) {
         super(`Assert ${assertType} type, Actual ${actual} type`);
     }
@@ -53,7 +52,7 @@ function initColumnAssert(keys, keys_types) {
     }
     return type;
 }
-function getObjectValueInfo(object, keys_types) {
+export function getObjectValueInfo(object, keys_types) {
     let type;
     let keys;
     if (keys_types instanceof Array) {
@@ -70,7 +69,7 @@ function getObjectValueInfo(object, keys_types) {
     }
     return { keys, type };
 }
-function getColumnInfo(objectList, columns) {
+export function getColumnInfo(objectList, columns) {
     let keys;
     let asserts;
     if (!columns) {
@@ -87,5 +86,3 @@ function getColumnInfo(objectList, columns) {
     }
     return { keys, asserts };
 }
-
-export { AssertError, getColumnInfo, getObjectValueInfo, internalObjectToValues };

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

@@ -1,4 +1,3 @@
 import { JsObjectMapSql } from "./sql_value.ts";
 /** @public PgSql 转换器 */
 export declare const pgSqlTransformer: JsObjectMapSql;
-//# sourceMappingURL=db_type.d.ts.map

package/dist/sql_gen/sql_value/db_type.js

@@ -1,7 +1,6 @@
-import { SqlValuesCreator } from './sql_value.js';
-
+import { SqlValuesCreator } from "./sql_value.js";
 /** @public PgSql 转换器 */
-const pgSqlTransformer = new Map([
+export const pgSqlTransformer = new Map([
     [
         Array,
         function encodePgArray(value) {
@@ -36,5 +35,3 @@ const pgSqlTransformer = new Map([
         },
     ],
 ]);
-
-export { pgSqlTransformer };

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,3 @@ 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