imodel-pg 0.19.1 → 0.19.3

package/index.d.mts

@@ -1,5 +1,5 @@
 /*!
- * imodel v0.19.1
+ * imodel v0.19.3
  * (c) 2019-2026 undefined
  * @license undefined
  */

package/index.mjs

@@ -1,5 +1,5 @@
 /*!
- * imodel v0.19.1
+ * imodel v0.19.3
  * (c) 2019-2026 undefined
  * @license undefined
  */
@@ -80,6 +80,7 @@ function getBaseType(s, {
     case 'json':
       return 'json';
   }
+  return s;
 }
 /**
  *
@@ -522,14 +523,17 @@ function buildSelect(env, selectList) {
     offset,
     limit,
     group,
-    having
+    having,
+    lock
   } of selectList) {
     const Table = Sql.Table(table);
     const selectSql = getSelect(Table, select);
     const orderSql = getOrder(sort);
     const limitSql = limit && limit > 0 ? Sql('LIMIT', limit) : undefined;
     const offsetSql = offset && offset > 0 ? Sql('OFFSET', offset) : undefined;
-    list.push(Sql(Sql`SELECT`, distinct ? Sql`DISTINCT` : undefined, Sql`${selectSql}`, Sql`FROM ${Table}`, getWhere(env, where), orderSql, limitSql, offsetSql, group?.length ? Sql`GROUP BY ${Sql`,`.glue(group.map(v => Sql.Field(v)))}` : undefined, getWhere(env, having, 'HAVING')));
+    list.push(Sql(Sql`SELECT`, distinct ? Sql`DISTINCT` : undefined, Sql`${selectSql}`, Sql`FROM ${Table}`, getWhere(env, where), orderSql, limitSql, offsetSql, group?.length ? Sql`GROUP BY ${Sql`,`.glue(group.map(v => Sql.Field(v)))}` : undefined, getWhere(env, having, 'HAVING'),
+    // eslint-disable-next-line no-nested-ternary
+    lock === 'X' ? Sql`FOR UPDATE` : lock === 'S' ? Sql`FOR SHARE` : undefined));
   }
   if (!list.length) {
     return null;
@@ -1316,6 +1320,35 @@ async function loadTables(env, query, tables, schema) {
   return dbTables;
 }
 
+/**
+ * 生成 PostgreSQL ALTER TABLE 语句中强制类型转换的 USING 子句
+ * @param {Sql} COLUMN - 列名
+ * @param {boolean?} [array]
+ * @param {boolean?} [nullable]
+ * @param {boolean?} [oldArray]
+ * @param {Sql?} [def]
+ * @returns {Sql}
+ */
+function generateUsingClause(COLUMN, array, nullable, oldArray, def) {
+  if (array && !oldArray) {
+    if (nullable) {
+      return Sql`(CASE
+			WHEN ${COLUMN} IS NULL THEN NULL
+			ELSE ARRAY[${COLUMN}]
+			END)`;
+    }
+    return Sql`(CASE
+			WHEN ${COLUMN} IS NULL THEN ARRAY[]
+			ELSE ARRAY[${COLUMN}]
+		END)`;
+  }
+  const val = oldArray && !array ? Sql`${COLUMN}[1]` : Sql`${COLUMN}`;
+  if (nullable || !def) {
+    return val;
+  }
+  return Sql`COALESCE(${val}, ${def})`;
+}
+
 /** @import { Environment, IConnection } from 'imodel' */
 /** @import { PgEnvTrans } from '../index.mjs' */
 /** @import { DBIndex, DBTable, DBColumn } from 'imodel' */
@@ -1639,15 +1672,18 @@ WHERE table_name = ${table} AND constraint_type = 'PRIMARY KEY'
       size
     }, array);
     const oldType = getType(old.type, old, old.array);
-    if (newType !== oldType) {
-      COLUMNs.push(Sql`${COLUMN} TYPE ${Sql(newType)}`);
+    const def = getDefault(env, defaultValue, type, array);
+    if (newType !== oldType || !nullable && old.nullable) {
+      console.log(newType, oldType);
+      const usingClause = generateUsingClause(Sql.Field(fieldName), array, nullable, old.array, def);
+      const type = Sql(newType);
+      COLUMNs.push(Sql`${COLUMN} TYPE ${type} USING ${usingClause}::${type}`);
       // TODO: USING "description"::int2
     }
     if (Boolean(nullable) !== Boolean(old.nullable)) {
       COLUMNs.push(nullable ? Sql`${COLUMN} DROP NOT NULL` : Sql`${COLUMN} SET NOT NULL`);
     }
     if (!defaultIsQe(defaultValue, old.default)) {
-      const def = getDefault(env, defaultValue, type, array);
       COLUMNs.push(def ? Sql`${COLUMN} SET DEFAULT ${def}` : Sql`${COLUMN} DROP DEFAULT`);
     }
   }
@@ -1698,6 +1734,144 @@ async function syncTables(env, query, tables, schema) {
   }
 }
 
+/** @import { Environment } from 'imodel' */
+/** @import { PgEnvTrans } from './index.mjs' */
+/**
+ *
+ * @param {string?} [detail]
+ * @returns
+ */
+function parseUniqueViolationErrorColumns(detail) {
+  const match = /^[^"]*"(.*)"[^"]*$/.exec(detail || '');
+  const colsStr = match?.[1];
+  if (!colsStr) {
+    return [];
+  }
+  const cols = [];
+  let i = 1;
+  for (; i < colsStr.length; i++) {
+    const char = colsStr[i];
+    if (char === ' ' || char === ',') {
+      continue;
+    }
+    if (char === ')') {
+      break;
+    }
+    const list = [];
+    if (char === '"') {
+      i++;
+      for (; i < colsStr.length; i++) {
+        const char = colsStr[i];
+        if (char === '"') {
+          if (colsStr[i + 1] !== '"') {
+            break;
+          }
+          i++;
+        }
+        list.push(char);
+      }
+    } else {
+      for (; i < colsStr.length; i++) {
+        const char = colsStr[i];
+        if (char === ' ') {
+          continue;
+        }
+        if (char === ')' || char === ',') {
+          i--;
+          break;
+        }
+        list.push(char);
+      }
+    }
+    cols.push(list.join(''));
+    continue;
+  }
+  return cols;
+}
+/** @type {Record<string, (e: pg.DatabaseError, env: Environment<PgEnvTrans>) => any>} */
+const errors = {
+  '22P02'(error, {
+    errors
+  }) {
+    return new errors.InvalidInputSyntaxError(error.message);
+  },
+  23502(error, {
+    errors
+  }) {
+    const {
+      table,
+      column
+    } = error;
+    if (!table || !column) {
+      return;
+    }
+    return new errors.NotNullViolationError(table, column);
+  },
+  23505(error, {
+    errors
+  }) {
+    const {
+      table,
+      detail
+    } = error;
+    if (!table) {
+      return;
+    }
+    return new errors.UniqueViolationError(table, parseUniqueViolationErrorColumns(detail));
+  },
+  23503(error, {
+    errors
+  }) {
+    const {
+      table,
+      column,
+      constraint
+    } = error;
+    if (!table || !column) {
+      return;
+    }
+    return new errors.ForeignKeyViolationError(table, column, constraint);
+  },
+  42883(error, {
+    errors
+  }) {
+    return new errors.OperatorMismatchError(error.message);
+  }
+};
+const errorGroup = {
+  22: 'data',
+  23: 'constraint',
+  24: 'cursor',
+  25: 'transaction'
+};
+/**
+ *
+ * @param {pg.DatabaseError} error
+ * @param {Environment<PgEnvTrans>} env
+ */
+function errorConvert(error, env) {
+  if (!(error instanceof pg.DatabaseError)) {
+    return error;
+  }
+  const {
+    code
+  } = error;
+  if (!code) {
+    throw error;
+  }
+  const convert = Object.hasOwn(errors, code) ? errors[code] : null;
+  const converted = convert?.(error, env);
+  if (converted) {
+    return converted;
+  }
+  if (typeof code !== 'string' || code.length !== 5) {
+    return error;
+  }
+  const group = code.slice(0, 2);
+  const groupCode = Object.hasOwn(errorGroup, group) && errorGroup[group];
+  return new env.errors.ConnectionError(groupCode ? `${groupCode}::pg:${code}` : `:pg:${code}`, error.message);
+}
+
 /** @import { Environment, IConnection } from 'imodel' */
 const {
   types
@@ -1826,22 +2000,19 @@ function index (pool, version) {
     const {
       transaction
     } = env;
-    const transactionClient = transaction?.client;
-    if (transactionClient) {
-      const client = await Promise.resolve(transactionClient);
-      return client.query({
-        text,
-        values: [...values]
-      });
-    }
-    const client = await connect();
+    const transactionClient = await Promise.resolve(transaction?.client);
+    const client = transactionClient || (await connect());
     try {
       return await client.query({
         text,
         values: [...values]
       });
+    } catch (error) {
+      throw errorConvert(error, env) || error;
     } finally {
-      client.release();
+      if (!transactionClient) {
+        client.release();
+      }
     }
   }
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "imodel-pg",
-  "version": "0.19.1",
+  "version": "0.19.3",
   "dependencies": {
     "pg": "^8.13.3",
     "tagged-sql": "^0.9.0"