@asla/yoursql 0.8.4 → 0.8.6

package/README.md

@@ -77,3 +77,116 @@ const s = Selection.from("user", "u")
   .where(`u.name LIKE %${v(searchName)}%`)
   .toString();
 ```
+
+### client 抽象类
+
+yoursql 还导出了一些抽象类，实现抽象类后可以方便的进行数据查询
+
+```ts
+import {
+  type DbQueryPool,
+  type DbTransaction,
+  type DbConnection,
+  DbQuery,
+  DbCursor,
+  DbPoolConnection,
+  DbPoolTransaction,
+} from "@asla/yoursql/client";
+```
+
+#### DbQuery 抽象类
+
+```ts
+class YourQuery extends DbQuery {
+  // 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; //提前关闭游标
+}
+```

package/dist/client/DbPoolTransaction.d.ts

@@ -3,14 +3,19 @@ import { DbQuery } from "./DbQuery.ts";
 import type { MultipleQueryResult, QueryRowsResult } from "./DbQuery.ts";
 import type { DbPoolConnection } from "./DbPoolConnection.ts";
 import type { DbTransaction, TransactionMode } from "./interfaces.ts";
+/** @public */
+export type DbPoolTransactionOption = {
+    errorRollback?: boolean;
+    mode?: TransactionMode;
+};
 /**
  * @public
  * 池连接事务
  */
 export declare class DbPoolTransaction extends DbQuery implements DbTransaction {
     #private;
-    readonly mode?: TransactionMode | undefined;
-    constructor(connect: () => Promise<DbPoolConnection>, mode?: TransactionMode | undefined);
+    readonly mode?: TransactionMode;
+    constructor(connect: () => Promise<DbPoolConnection>, option?: TransactionMode | DbPoolTransactionOption);
     commit(): Promise<void>;
     rollback(): Promise<void>;
     savePoint(savePoint: string): Promise<void>;

package/dist/client/DbPoolTransaction.js

@@ -6,10 +6,18 @@ import { ParallelQueryError, ConnectionNotAvailableError } from './errors.js';
  * 池连接事务
  */
 class DbPoolTransaction extends DbQuery {
+    #errorRollback;
     mode;
-    constructor(connect, mode) {
+    constructor(connect, option) {
         super();
-        this.mode = mode;
+        if (option) {
+            if (typeof option === "string")
+                this.mode = option;
+            else {
+                this.mode = option.mode;
+                this.#errorRollback = option.errorRollback;
+            }
+        }
         this.#query = (sql) => {
             return new Promise((resolve, reject) => {
                 this.#pending = connect()
@@ -24,10 +32,21 @@ class DbPoolTransaction extends DbQuery {
                     this.#pending = undefined;
                     resolve(res[1]);
                 }, (e) => {
+                    // 语法错误、查询错误、网络错误
                     this.#pending = undefined;
                     reject(e);
-                    if (this.#conn)
-                        this.#release(this.#conn, e);
+                    const conn = this.#conn;
+                    if (!conn)
+                        return;
+                    if (this.#errorRollback) {
+                        const onFinally = () => {
+                            this.#release(conn, e);
+                        };
+                        return conn.rollback().then(onFinally, onFinally);
+                    }
+                    else {
+                        this.#release(conn, e);
+                    }
                 });
             });
         };
@@ -60,25 +79,35 @@ class DbPoolTransaction extends DbQuery {
     }
     /** 拿到连接后执行这个 */
     #queryAfter(sql) {
-        return this.#conn.query(sql).then((res) => {
+        const conn = this.#conn;
+        return conn.query(sql).then((res) => {
             this.#pending = undefined;
             return res;
         }, (e) => {
             this.#pending = undefined;
-            this.#release(this.#conn, e);
-            throw e;
+            if (this.#errorRollback) {
+                const onOk = () => {
+                    this.#release(conn, e);
+                    throw e;
+                };
+                return conn.rollback().then(onOk, onOk);
+            }
+            else {
+                this.#release(conn, e);
+                throw e;
+            }
         });
     }
     #query;
     query(sql) {
         if (this.#pending)
             return Promise.reject(new ParallelQueryError());
-        return this.#query(sql.toString());
+        return this.#query(sql);
     }
     multipleQuery(sql) {
         if (this.#pending)
             return Promise.reject(new ParallelQueryError());
-        return this.#query(sql.toString());
+        return this.#query(sql);
     }
     #error;
     #release(conn, error = new ConnectionNotAvailableError("Connection already release")) {

package/dist/sql_gen/select/DbTable.d.ts

@@ -13,12 +13,16 @@ export declare class DbTable<T extends TableType> {
     fromAs(as?: string): Selection;
     /** 选择单表全部列 */
     select(columns: "*", as?: string): ChainSelect<T>;
-    /** 选择单表  */
-    select(columns: Constructable<Record<string, boolean | string> | string>, as?: string): ChainSelect<Record<string, any>>;
+    /** 选择单表，带提示  */
+    select(columns: Constructable<{
+        [key in keyof T]?: string | boolean;
+    } & {
+        [key: string]: string | boolean;
+    }>, as?: string): ChainSelect<Record<string, any>>;
     /** 选择单表  */
     select<R extends {}>(columns: Constructable<{
         [key in keyof R]: boolean | string;
-    } | string>, as?: string): ChainSelect<R>;
+    } | string | string[]>, as?: string): ChainSelect<R>;
     /**
      * INSERT 语句，需要注意 SQL 注入
      * @example

package/package.json

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