imodel-pg 0.1.0

package/index.d.mts

@@ -0,0 +1,26 @@
+/*!
+ * imodel v0.1.0
+ * (c) 2019-2025 undefined
+ * @license undefined
+ */
+
+import pg from 'pg';
+import { IConnection } from 'imodel';
+
+/**
+ *
+ * @param {pg.Pool | (() => pg.PoolClient | PromiseLike<pg.PoolClient>)} [pool]
+ * @param {(client?: pg.PoolClient?) => Promise<string>} [version]
+ * @returns {IConnection<PgEnvTrans>}
+ */
+declare function _default(pool?: pg.Pool | (() => pg.PoolClient | PromiseLike<pg.PoolClient>), version?: (client?: pg.PoolClient | null) => Promise<string>): IConnection<PgEnvTrans>;
+/**
+ * @param {pg.PoolClient} client
+ * @returns {PgEnvTrans}
+ */
+declare function toTransaction(client: pg.PoolClient): PgEnvTrans;
+type PgEnvTrans = {
+    client?: pg.PoolClient | null;
+};
+
+export { type PgEnvTrans, _default as default, toTransaction };

package/index.mjs

@@ -0,0 +1,1248 @@
+/*!
+ * imodel v0.1.0
+ * (c) 2019-2025 undefined
+ * @license undefined
+ */
+
+import pg from 'pg';
+import Sql from 'tagged-sql';
+
+/**
+ *
+ * @param {string} s
+ * @param {object} options
+ * @param {number} [options.precision] 精确度
+ * @param {number} [options.scale] 缩放比
+ * @param {number} [options.size] 占用空间大小
+ * @param {boolean} [define]
+ * @returns
+ */
+function getType(s, {
+  precision,
+  scale,
+  size
+}, define) {
+  switch (s) {
+    case 'id':
+      return define ? 'bigserial' : 'bigint';
+    case 'rid':
+      return 'bigint';
+    case 'ref':
+      return 'string';
+    case 'i2':
+    case 'i4':
+    case 'i8':
+    case 'u2':
+    case 'u4':
+    case 'u8':
+    case 'ref16':
+    case 'i16':
+    case 'seq16':
+      return 'smallint';
+    case 'u16':
+    case 'i32':
+    case 'seq32':
+      return 'integer';
+    case 'u32':
+    case 'ref52':
+    case 'ref64':
+    case 'i52':
+    case 'i64':
+    case 'u64':
+    case 'seq64':
+      return 'bigint';
+    case 'f32':
+      return 'real';
+    case 'f64':
+      return 'double precision';
+    case 'decimal':
+    case 'numeric':
+      if (!precision) {
+        return s;
+      }
+      if (!scale) {
+        return `${s}(${precision})`;
+      }
+      return `${s}(${precision}, ${scale})`;
+    case 'char':
+      return size ? `char(${size})` : `char`;
+    case 'string':
+      return size ? `varchar(${size || 255})` : `varchar`;
+    case 'text':
+      return 'text';
+    case 'bin':
+      return 'bytea';
+    case 'timestamp':
+      {
+        if (!precision) {
+          return `timestamp with time zone`;
+        }
+        return `timestamp(${precision}) with time zone`;
+      }
+    case 'date':
+      return 'date';
+    case 'datetime':
+      {
+        if (!precision) {
+          return `datetime without time zone`;
+        }
+        return `datetime(${precision}) without time zone`;
+      }
+    case 'time':
+      {
+        if (!precision) {
+          return `time without time zone`;
+        }
+        return `time(${precision}) without time zone`;
+      }
+    case 'timetz':
+      {
+        if (!precision) {
+          return `time with time zone`;
+        }
+        return `time(${precision}) with time zone`;
+      }
+    case 'interval':
+      {
+        if (!precision) {
+          return 'interval';
+        }
+        return `interval(${precision})`;
+      }
+    case 'bool':
+      return 'boolean';
+    case 'ip':
+    case 'ipv4':
+    case 'ipv6':
+      return 'cidr';
+    case 'mac48':
+      return 'macaddr';
+    case 'mac64':
+      return 'macaddr8';
+    case 'uuid':
+      return 'uuid';
+    case 'object':
+      return 'jsonb';
+  }
+}
+
+/** @import { Environment, ColumnOptions } from 'imodel' */
+/**
+ *
+ * @param {any} v
+ * @param {string} type
+ * @returns
+ */
+function toSqlString(v, type) {
+  if (typeof v === 'bigint' || typeof v === 'number') {
+    return String(v);
+  }
+  if (typeof v === 'string') {
+    return `'${v.replace(/\\/g, '\\\\').replace(/'/g, '\\\'')}'`;
+  }
+  if (v === true) {
+    return 'TRUE';
+  }
+  if (v === false) {
+    return 'FALSE';
+  }
+  if (v instanceof Date) {
+    return `'${v.toISOString()}'`;
+  }
+}
+/**
+ *
+ * @param {Environment} env
+ * @param {any} value
+ * @param {string} type
+ * @param {boolean} [array]
+ * @returns
+ */
+function getDefault(env, value, type, array) {
+  if (value === undefined) {
+    return;
+  }
+  if (value === env.values.now) {
+    return Sql`now()`;
+  }
+  const v = typeof value === 'function' ? value() : value;
+  if (v === undefined) {
+    return;
+  }
+  if (v instanceof Sql) {
+    return v;
+  }
+  if (v === null) {
+    return Sql`NULL`;
+  }
+  if (array) {
+    const values = Array.isArray(v) ? v : [v];
+    const t = values.map(v => toSqlString(v)).filter(Boolean).join(',');
+    return Sql(`'{${t.replace(/\\/g, '\\\\').replace(/'/g, '\\\'')}}'`);
+  }
+  const t = toSqlString(v);
+  if (t) {
+    return Sql(t);
+  }
+}
+/**
+ *
+ * @param {string} name
+ * @param {string} type
+ * @param {ColumnOptions<any>} columnOptions
+ * @param {Environment} env
+ * @returns {Sql}
+ */
+function add(name, type, {
+  unique,
+  nullable = true,
+  default: defaultValue,
+  array,
+  precision,
+  scale,
+  size,
+  serial
+}, env) {
+  const t = getType(type, {
+    precision,
+    scale,
+    size
+  }, serial);
+  const defValueSql = getDefault(env, defaultValue, type, array);
+  return Sql(Sql`ADD COLUMN ${Sql.Field(name)}`, Sql(`${t}${array ? '[]' : ''}`), nullable ? Sql`` : Sql`NOT NULL`, defValueSql ? Sql`DEFAULT ${defValueSql}` : Sql``);
+}
+/**
+ *
+ * @param {string} column
+ * @param {string} newName
+ * @returns {Sql}
+ */
+function rename(column, newName) {
+  return Sql`RENAME COLUMN ${Sql.Field(column)} TO ${Sql.Field(newName)}`;
+}
+/**
+ *
+ * @param {string} column
+ * @returns {Sql}
+ */
+function drop(column) {
+  return Sql`DROP COLUMN ${Sql.Table(column)}`;
+}
+/**
+ *
+ * @param {string} name
+ * @param {string} type
+ * @param {object} options
+ * @param {boolean} [options.array] 是否为数组格式
+ * @param {number} [options.precision] 精确度
+ * @param {number} [options.scale] 缩放比
+ * @param {number} [options.size] 占用空间大小
+ * @returns
+ */
+function changeType(name, type, {
+  precision,
+  scale,
+  size,
+  array
+}) {
+  const t = getType(type, {
+    precision,
+    scale,
+    size
+  });
+  const field = Sql.Field(name);
+  return Sql`ALTER COLUMN ${field} TYPE ${Sql(`${t}${array ? '[]' : ''}`)}`;
+}
+/**
+ *
+ * @param {string} name
+ * @param {boolean} [nullable]
+ * @returns
+ */
+function changeNull(name, nullable) {
+  return Sql(Sql`ALTER COLUMN ${Sql.Field(name)}`, nullable ? Sql`DROP NOT NULL` : Sql`SET NOT NULL`);
+}
+/**
+ *
+ * @param {Environment} env
+ * @param {string} name
+ * @param {any} defValue
+ * @param {string} type
+ * @param {boolean} [array]
+ * @returns
+ */
+function changeDefault(env, name, defValue, type, array) {
+  const v = getDefault(env, defValue, type, array);
+  return Sql(Sql`ALTER COLUMN ${Sql.Field(name)}`, v ? Sql`DEFAULT ${v}` : Sql` DROP DEFAULT`);
+}
+
+/** @import { Environment, ColumnOptions } from 'imodel' */
+/**
+ *
+ * @param {string} table
+ * @param {string} name
+ * @param {string} type
+ * @param {ColumnOptions<any>} options
+ * @param {Environment} env
+ * @returns {Sql}
+ */
+function addColumn(table, name, type, options, env) {
+  return Sql`ALTER TABLE ${Sql.Table(table)} ${add(name, type, options, env)}`;
+}
+
+/** @import { Environment, ColumnOptions } from 'imodel' */
+/**
+ *
+ * @param {string} table
+ * @param {string} name
+ * @param {string} type
+ * @param {ColumnOptions<any>} columnOptions
+ * @param {Environment} env
+ * @returns {Sql}
+ */
+function changeColumn(table, name, type, {
+  nullable,
+  default: defValue,
+  array,
+  precision,
+  scale,
+  size
+}, env) {
+  return Sql(Sql`ALTER TABLE ${Sql.Table(table)}`, changeType(name, type, {
+    precision,
+    scale,
+    size,
+    array
+  }), changeNull(name, nullable), changeDefault(env, name, defValue, type, array));
+}
+
+/**
+ *
+ * @param {string} table
+ * @param {string} name
+ * @param {boolean} nullable
+ * @returns {Sql}
+ */
+function changeColumnNull(table, name, nullable) {
+  return Sql(Sql`ALTER TABLE ${Sql.Table(table)}`, changeNull(name, nullable));
+}
+
+/**
+ *
+ * @param {string} table
+ * @param {string} column
+ * @returns {Sql}
+ */
+function dropColumn(table, column) {
+  return Sql`ALTER TABLE ${Sql.Table(table)} ${drop(column)}`;
+}
+
+/**
+ *
+ * @param {string} table
+ * @param {string} column
+ * @param {string} newName
+ * @returns {Sql}
+ */
+function renameColumn(table, column, newName) {
+  const t = Sql.Table(table);
+  return Sql`ALTER TABLE${t}${rename(column, newName)}`;
+}
+
+/** @import { IndexOptions } from 'imodel' */
+/**
+ *
+ * @param {string} table
+ * @param {string} name
+ * @param {string[]} fields
+ * @param {IndexOptions} [indexOptions]
+ * @returns {Sql}
+ */
+function addIndex(table, name, fields, {
+  unique,
+  include
+} = {}) {
+  const create = unique ? Sql`CREATE UNIQUE INDEX` : Sql`CREATE INDEX`;
+  const id = Sql.Id(`${table}#${name}`);
+  const allColumns = Sql`, `.glue(...fields.map(v => Sql.Field(v)));
+  const fieldSqls = Sql`ON ${Sql.Table(table)}(${allColumns})`;
+  const includes = include?.length ? Sql`INCLUDE (${Sql`, `.glue(...include.map(v => Sql.Field(v)))})` : undefined;
+  return Sql(create, id, fieldSqls, includes);
+}
+
+/**
+ *
+ * @param {string} table
+ * @param {string} name
+ * @returns {Sql}
+ */
+function dropIndex(table, name) {
+  return Sql`DROP INDEX ${Sql.Id(`${table}#${name}`)}`;
+}
+
+/** @import { Environment, Column } from 'imodel' */
+/**
+ *
+ * @param {string} table
+ * @param {Column<any>[]} fields
+ * @param {Environment} env
+ * @returns {Sql}
+ */
+function createTable(table, fields, env) {
+  const fieldsSql = fields.map(({
+    name,
+    type,
+    nullable = true,
+    serial,
+    default: defaultValue,
+    array,
+    precision,
+    scale,
+    size
+  }) => {
+    const t = getType(type, {
+      precision,
+      scale,
+      size
+    }, serial);
+    const typeSql = Sql(`${t}${array ? '[]' : ''}`);
+    const nullSql = nullable ? Sql`` : Sql`NOT NULL`;
+    const defValueSql = getDefault(env, defaultValue, type, array);
+    const defaultSql = defValueSql ? Sql`DEFAULT ${defValueSql}` : Sql``;
+    return Sql(Sql.Field(name), typeSql, nullSql, defaultSql);
+  });
+  const primary = fields.filter(v => v.primary).map(v => v.name);
+  if (primary.length) {
+    const c = primary.map(c => Sql.Field(c));
+    fieldsSql.push(Sql` PRIMARY KEY (${Sql`,`.glue(...c)})`);
+  }
+  const sql = Sql`CREATE TABLE ${Sql.Table(table)}
+		(${Sql`,`.glue(...fieldsSql)})`;
+  return sql;
+}
+
+/**
+ *
+ * @param {string} table
+ * @returns {Sql}
+ */
+function dropTable(table) {
+  return Sql`DROP TABLE ${Sql.Table(table)}`;
+}
+
+/**
+ *
+ * @param {string} table
+ * @param {string} newName
+ * @returns {Sql}
+ */
+function renameTable(table, newName) {
+  const t = Sql.Table(table);
+  const nn = Sql.Table(newName);
+  return Sql`ALTER TABLE ${t} RENAME TO ${nn}`;
+}
+
+/**
+ *
+ * @param {string} view
+ * @param {Sql} query
+ * @returns {Sql}
+ */
+function createView(view, query) {
+  return Sql`CREATE VIEW ${Sql.Table(view)} ${query}`;
+}
+
+/**
+ *
+ * @param {string} view
+ * @returns {Sql}
+ */
+function dropView(view) {
+  return Sql`DROP VIEW ${Sql.Table(view)}`;
+}
+
+/**
+ *
+ * @param {string} view
+ * @returns {Sql}
+ */
+function dropMaterializedView(view) {
+  return Sql`DROP MATERIALIZED VIEW ${Sql.Table(view)}`;
+}
+
+/**
+ *
+ * @param {string} view
+ * @param {Sql} query
+ * @returns {Sql}
+ */
+function createMaterializedView(view, query) {
+  return Sql`CREATE MATERIALIZED VIEW ${Sql.Table(view)} ${query}`;
+}
+
+/**
+ *
+ * @param {[string, boolean]} it
+ * @returns {Sql | Sql.Field}
+ */
+function getOrderItem(it) {
+  const [f, d] = it;
+  if (d) {
+    return Sql`${Sql.Field(f)} DESC`;
+  }
+  return Sql.Field(f);
+}
+/**
+ *
+ * @param {[string, boolean][]} [sort]
+ * @returns
+ */
+function getOrder(sort) {
+  if (!sort) {
+    return undefined;
+  }
+  if (!sort.length) {
+    return undefined;
+  }
+  return Sql`ORDER BY ${Sql`,`.glue(...sort.map(getOrderItem))}`;
+}
+
+/** @import { Select } from 'imodel' */
+/**
+ *
+ * @param {Sql.Table} table
+ * @param {string} k
+ * @param {Select | Sql | Sql.Field} v
+ * @returns
+ */
+function getField(table, k, v) {
+  if (!v) {
+    return;
+  }
+  if (v instanceof Sql.Field) {
+    return v.table ? v : table.field(v.field);
+  }
+  if (v instanceof Sql) {
+    return v;
+  }
+  const f = v.table ? Sql.Field(v.field, v.table) : table.field(v.field);
+  const {
+    fn
+  } = v;
+  if (!fn) {
+    return f;
+  }
+  return Sql.FnExpr(fn, [f]);
+}
+/**
+ *
+ * @param {Sql.Table} table
+ * @param {([string, Select] | Sql.Like | Sql.Field)[]} select
+ * @returns {Sql}
+ */
+function getSelect(table, select) {
+  /** @type {(Sql.Like | Sql.Field)[]} */
+  const selectList = [];
+  for (const s of select) {
+    if (Sql.isLike(s) || s instanceof Sql.Field) {
+      selectList.push(s);
+      continue;
+    }
+    if (!Array.isArray(s)) {
+      continue;
+    }
+    const [k, v] = s;
+    const f = getField(table, k, v);
+    if (!f) {
+      continue;
+    }
+    selectList.push(Sql`${f} AS ${Sql.Id(k)}`);
+  }
+  return Sql`, `.glue(...selectList);
+}
+
+/** @import { Environment, WhereValue } from 'imodel' */
+/**
+ *
+ * @param {string | {table?: string; field: string}} k
+ */
+function toField(k) {
+  if (typeof k === 'string') {
+    return Sql.Field(k);
+  }
+  const {
+    table,
+    field
+  } = k;
+  if (!table) {
+    return Sql.Field(field);
+  }
+  return Sql.Field(field, table);
+}
+/**
+ *
+ * @param {Environment} env
+ * @param {WhereValue[]?} [wheres]
+ * @returns {Sql | undefined}
+ */
+function getWhere2(env, wheres) {
+  if (!wheres?.length) {
+    return;
+  }
+  /**
+   *
+   * @param {WhereValue} where
+   * @returns {Sql?}
+   */
+  function toSql(where) {
+    if (where instanceof Sql) {
+      return where;
+    }
+    if (where.where) {
+      let q = Sql([...where.where], ...where.values);
+      if (where.not) {
+        return Sql`NOT(${q})`;
+      }
+      return q;
+    }
+    if (where.or) {
+      /** @type {Sql[]} */
+      const orList = [];
+      for (const list of where.or) {
+        /** @type {Sql[]} */
+        // @ts-ignore
+        const andList = list.map(v => toSql(v)).filter(Boolean);
+        if (andList.length) {
+          orList.push(Sql` AND `.glue(...andList));
+        }
+      }
+      if (!orList.length) {
+        return null;
+      }
+      if (where.not) {
+        return Sql`not(${Sql` OR `.glue(...orList)})`;
+      }
+      return Sql`(${Sql` OR `.glue(...orList)})`;
+    }
+    const {
+      field: k,
+      operator: o,
+      value: v
+    } = where;
+    if (Array.isArray(k)) {
+      let {
+        not
+      } = where;
+      const field = Sql`(${Sql`,`.glue(k.map(toField))})`;
+      let values = v;
+      switch (o?.toUpperCase().replaceAll('_', '').replaceAll(' ', '')) {
+        case 'NOTIN':
+        case 'NOT':
+        case '!=':
+        case '<>':
+          not = !not;
+          break;
+      }
+      console.log(v);
+      values = Array.isArray(v) ? Sql`(${Sql`,`.glue(v.map(v => Sql`(${Array.isArray(v) && v.length ? Sql(['', ...Array(v.length - 1).fill(','), ''], ...v.map(v => v ?? null)) : v ?? null})`))})` : Sql`(${v ?? null})`;
+      return Sql`${field} ${Sql(not ? `NOT IN` : `IN`)} ${values}`;
+    }
+    let {
+      not
+    } = where;
+    let operator = (o || '').toUpperCase() || '=';
+    let values = v;
+    switch (operator.replaceAll('_', '').replaceAll(' ', '')) {
+      case 'NOTIN':
+        not = !not;
+        operator = 'IN';
+        break;
+      case 'NOTLIKE':
+        not = !not;
+        operator = 'LIKE';
+        break;
+      case 'NOTCONTAINS':
+        not = !not;
+      case 'CONTAINS':
+        {
+          if (typeof values === 'string') {
+            values = `%${values.replaceAll('%', '\\%')}%`;
+            operator = 'LIKE';
+          }
+          break;
+        }
+      case 'STARTSWITH':
+        {
+          if (typeof values === 'string') {
+            values = `${values.replaceAll('%', '\\%')}%`;
+            operator = 'LIKE';
+          }
+          break;
+        }
+      case 'ENDSWITH':
+        {
+          if (typeof values === 'string') {
+            values = `%${values.replaceAll('%', '\\%')}`;
+            operator = 'LIKE';
+          }
+          break;
+        }
+    }
+    if (not) {
+      switch (operator) {
+        case 'IN':
+          operator = 'NOT IN';
+          not = false;
+          break;
+        case 'LIKE':
+          operator = 'NOT LIKE';
+          not = false;
+          break;
+      }
+    }
+    if (Array.isArray(v) && (operator === 'IN' || operator === 'NOT IN') && v.length) {
+      values = Sql(['', ...Array(v.length - 1).fill(','), ''], ...v.map(v => v ?? null));
+    } else {
+      values = Sql`${values}`;
+    }
+    if (!not) {
+      return Sql`${toField(k)} ${Sql(operator)} ${values}`;
+    }
+    return Sql`not(${toField(k)} ${Sql(operator)} ${values})`;
+  }
+  /** @type {Sql[]} */
+  // @ts-ignore
+  const andList = wheres.map(v => toSql(v)).filter(Boolean);
+  if (!andList) {
+    return;
+  }
+  return Sql` AND `.glue(...andList);
+}
+/**
+ *
+ * @param {Environment} env
+ * @param {WhereValue[]?} [where]
+ * @returns {Sql | undefined}
+ */
+function getWhere(env, where) {
+  const andList = getWhere2(env, where);
+  if (!andList) {
+    return;
+  }
+  return Sql`WHERE ${andList}`;
+}
+
+/** @import { Environment, SelectArg } from 'imodel' */
+/**
+ *
+ * @param {Environment} env
+ * @param {SelectArg} param1
+ * @returns {Sql}
+ */
+function selectSql(env, {
+  table,
+  fields,
+  alias,
+  select,
+  where,
+  sort,
+  offset,
+  limit
+}) {
+  const Table = alias ? Sql.Table(table, alias) : 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;
+  return Sql(Sql`SELECT ${selectSql} FROM ${Table}`, getWhere(env, where), orderSql, limitSql, offsetSql);
+}
+
+/** @import { Environment, CountArg } from 'imodel' */
+/**
+ *
+ * @param {Environment} env
+ * @param {CountArg} arg
+ * @returns {Sql}
+ */
+function countSql(env, {
+  table,
+  alias,
+  where
+}) {
+  const Table = alias ? Sql.Table(table, alias) : Sql.Table(table);
+  return Sql`SELECT count(*) AS count FROM ${Table} ${getWhere(env, where)}`;
+}
+
+/** @import { Environment, Fields, FieldType, WhereValue } from 'imodel' */
+/**
+ *
+ * @param {Environment} env
+ * @param {string} table
+ * @param {Fields<keyof FieldType>} [fields]
+ * @param {WhereValue[]?} [where]
+ * @param {string[]?} [returning]
+ * @returns {Sql}
+ */
+function deleteSql(env, table, fields, where, returning) {
+  const returnSql = returning ? Sql`RETURNING ${Sql`, `.glue(...returning.map(k => Sql.Field(k)))}` : undefined;
+  return Sql(Sql`DELETE FROM ${Sql.Table(table)}`, getWhere(env, where), returnSql);
+}
+
+/** @import { Environment, FieldDefine, Fields, FieldType } from 'imodel' */
+/**
+ *
+ * @param {object} data
+ * @param {string} key
+ * @param {FieldDefine<keyof FieldType, boolean, boolean>} field
+ * @param {Environment} env
+ * @returns
+ */
+function getValue(data, key, field, env) {
+  const val = data[key];
+  if (val === env.values.now) {
+    return Sql`now()`;
+  }
+  if (val !== undefined) {
+    return val;
+  }
+  const def = field.default;
+  return typeof def === 'function' ? def(data) ?? null : def ?? null;
+}
+/**
+ *
+ * @param {string} table
+ * @param {Fields<keyof FieldType>} fields
+ * @param {object[]} list
+ * @param {string[]} keys
+ * @param {Environment} env
+ * @returns {Sql}
+ */
+function insertSql(table, fields, list, keys, env) {
+  const key = new Set(keys);
+  const keyData = Object.entries(fields).filter(([f]) => key.has(f));
+  const values = list.map(v => Sql`(${Sql`,`.glue(...keyData.map(([k, f]) => Sql`${getValue(v, k, f, env)}`))})`);
+  return Sql`INSERT INTO ${Sql.Table(table)} (${Sql`,`.glue(...keyData.map(([k]) => Sql.Field(k)))}) VALUES ${Sql`,`.glue(...values)} RETURNING *`;
+}
+
+/** @import { Environment, Fields, FieldType, SetValue } from 'imodel' */
+/**
+ *
+ * @param {Record<string, SetValue>} update
+ * @param {Fields<keyof FieldType>} fields
+ * @param {Environment} env
+ * @returns {Sql[]}
+ */
+function getSet(update, fields, env) {
+  const {
+    now,
+    increment,
+    decrement,
+    multiply,
+    divide
+  } = env.values;
+  return /** @type {Sql[]} */Object.entries(update).filter(([, v]) => v !== undefined).map(([key, value]) => {
+    const field = key in fields && fields[key];
+    if (!field) {
+      return;
+    }
+    const f = Sql.Field(key);
+    if (value instanceof Sql) {
+      return Sql`${f} = ${value}`;
+    }
+    if (value === now) {
+      return Sql`${f} = now()`;
+    }
+    if (value === null) {
+      return Sql`${f} = NULL`;
+    }
+    if (typeof value !== 'object') {
+      return Sql`${f} = ${value}`;
+    }
+    const incrementValue = value[increment];
+    if (incrementValue !== undefined) {
+      return Sql`${f} = ${f} + ${incrementValue}`;
+    }
+    const decrementValue = value[decrement];
+    if (decrementValue !== undefined) {
+      return Sql`${f} = ${f} + ${decrementValue}`;
+    }
+    const multiplyValue = value[multiply];
+    if (multiplyValue !== undefined) {
+      return Sql`${f} = ${f} + ${multiplyValue}`;
+    }
+    const divideValue = value[divide];
+    if (divideValue !== undefined) {
+      return Sql`${f} = ${f} + ${divideValue}`;
+    }
+    return Sql`${f} = ${value}`;
+  }).filter(Boolean);
+}
+
+/** @import { Environment, MatchArg, SetValue } from 'imodel' */
+/**
+ *
+ * @param {Environment} env
+ * @param {MatchArg} param1
+ * @param {Record<string, SetValue>} update
+ * @param {string[]?} [returning]
+ * @returns {Sql}
+ */
+function updateSql(env, {
+  table,
+  fields,
+  where
+}, update, returning) {
+  const setSql = Sql`, `.glue(...getSet(update, fields, env));
+  const returnSql = returning ? Sql`RETURNING ${Sql`, `.glue(...returning.map(k => Sql.Field(k)))}` : undefined;
+  return Sql(Sql`UPDATE ${Sql.Table(table)} SET ${setSql}`, getWhere(env, where), returnSql);
+}
+
+/** @import { Environment, Fields, FieldType, WhereValue } from 'imodel' */
+const tmp = Sql.Table('__tmp').as('__tmp');
+const tmpId = Sql.Id('__tmp', 'alias');
+/**
+ *
+ * @param {Environment} env
+ * @param {string} table
+ * @param {Fields<keyof FieldType>} fields
+ * @param {string[]} pKeys
+ * @param {string[]} setKeys
+ * @param {Record<string, any>[]} list
+ * @param {Record<string, any>} values
+ * @param {WhereValue[]} where
+ * @param {string[]} [returning]
+ * @returns {Sql}
+ */
+function updateListSql(env, table, fields, pKeys, setKeys, list, values, where, returning) {
+  const dataFields = [...setKeys, ...pKeys];
+  const returnSql = returning ? Sql`RETURNING ${Sql`, `.glue(...returning.map(k => Sql.Field(k)))}` : undefined;
+  /** @type {[string, [string, string]][]} */
+  const dataFieldType = dataFields.map(f => {
+    const field = fields[f];
+    if (!field) {
+      return [f, ['', '']];
+    }
+    const type = `${getType(field.type, field)}${field.array ? '[]' : ''}`;
+    return [f, ['CAST(', ` as ${type})`]];
+  });
+  const main = Sql.Table(table);
+  return Sql`UPDATE ${main}
+SET ${Sql`, `.glue(setKeys.map(f => Sql`${Sql.Field(f)} = ${tmp.field(f)}`), Object.entries(values).map(([f, v]) => Sql`${Sql.Field(f)} = ${v}`))}
+FROM (values${Sql`,`.glue(list.map(data => Sql`(${Sql`,`.glue(dataFieldType.map(([f, t]) => {
+    const v = data[f] ?? null;
+    if (v === null) {
+      return Sql`${v}`;
+    }
+    return Sql(t, data[f] ?? null);
+  }))})`))}) as ${tmpId}(${Sql`,`.glue(dataFields.map(f => Sql.Field(f)))})
+WHERE ${Sql`AND`.glue(pKeys.map(f => Sql`${main.field(f)}=${tmp.field(f)}`), getWhere2(env, where))}${returnSql}`;
+}
+
+/** @import { Environment, IConnection } from 'imodel' */
+const {
+  types
+} = pg;
+types.setTypeParser(types.builtins.INT8, v => BigInt(v));
+const dbType = 'postgres';
+/**
+ *
+ * @param {string} text
+ * @param {readonly any[]} values
+ * @returns
+ */
+function echo(text, values) {
+  if (!values.length) {
+    console.info(text);
+    return;
+  }
+  console.groupCollapsed(text);
+  for (let i = 0; i < values.length; i++) {
+    console.info(`$${i + 1}:`, values[i]);
+  }
+  console.groupEnd();
+}
+/**
+ *
+ * @param {() => pg.PoolClient | PromiseLike<pg.PoolClient>} connect
+ * @returns
+ */
+function createVersion(connect) {
+  /**
+   *
+   * @param {pg.PoolClient?} [userClient]
+   * @returns
+   */
+  async function getVersion(userClient) {
+    const client = userClient || (await connect());
+    /** @type {pg.QueryResult<{server_version: string}>} */
+    const v = await client.query('show server_version');
+    if (!userClient) {
+      client.release();
+    }
+    /** 数据库版本号 */
+    return v.rows[0]?.server_version || '';
+  }
+  /** @type {Promise<string>?} */
+  let dbVersion = null;
+  /**
+   *
+   * @param {pg.PoolClient?} [client]
+   * @returns
+   */
+  return function version(client) {
+    dbVersion ||= getVersion(client);
+    return dbVersion;
+  };
+}
+/** @typedef {{client?: pg.PoolClient?}} PgEnvTrans */
+/**
+ *
+ * @param {pg.Pool | (() => pg.PoolClient | PromiseLike<pg.PoolClient>) | null} [pool]
+ * @returns {() => pg.PoolClient | PromiseLike<pg.PoolClient>}
+ */
+function toPoolConnection(pool) {
+  if (!pool) {
+    return () => {
+      throw new Error();
+    };
+  }
+  if (typeof pool === 'function') {
+    return pool;
+  }
+  return () => pool.connect();
+}
+/**
+ *
+ * @param {pg.Pool | (() => pg.PoolClient | PromiseLike<pg.PoolClient>)} [pool]
+ * @param {(client?: pg.PoolClient?) => Promise<string>} [version]
+ * @returns {IConnection<PgEnvTrans>}
+ */
+function index (pool, version) {
+  const connect = toPoolConnection(pool);
+  const dbVersion = typeof version === 'function' ? version : createVersion(connect);
+  /**
+   * @template {pg.QueryResultRow} T
+   * @param {Sql} sql
+   * @param {Environment<PgEnvTrans>} env
+   * @returns {Promise<pg.QueryResult<T>>}
+   */
+  async function _exec(sql, env) {
+    const text = sql.build((_, i) => `$${i + 1}`);
+    const {
+      values
+    } = sql;
+    if (env.isDevelopment) {
+      echo(text, values);
+    }
+    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();
+    try {
+      return await client.query({
+        text,
+        values: [...values]
+      });
+    } finally {
+      client.release();
+    }
+  }
+  /**
+   * @template {pg.QueryResultRow} T
+   * @param {Environment<PgEnvTrans>} env
+   * @param {Sql} sql
+   * @returns {Promise<T[]>}
+   */
+  async function query(env, sql) {
+    /** @type {pg.QueryResult<T>} */
+    const result = await _exec(sql, env);
+    return result.rows;
+  }
+  /**
+   * @param {Environment<PgEnvTrans>} env
+   * @param {Sql} sql
+   * @returns {Promise<number>}
+   */
+  async function exec(env, sql) {
+    const result = await _exec(sql, env);
+    return result.rowCount || 0;
+  }
+  return {
+    dbType,
+    async dbVersion(env) {
+      return dbVersion(env.transaction?.client);
+    },
+    query(env, sql, ...values) {
+      const ss = Array.isArray(sql) ? Sql(sql, ...values) : sql;
+      const {
+        getName
+      } = env;
+      const s = env.names ? ss.transform((id, group) => group === 'table' ? getName(id) : id) : ss;
+      return query(env, s);
+    },
+    exec(env, sql, ...values) {
+      const ss = Array.isArray(sql) ? Sql(sql, ...values) : sql;
+      const {
+        getName
+      } = env;
+      const s = env.names ? ss.transform((id, group) => group === 'table' ? getName(id) : id) : ss;
+      return exec(env, s);
+    },
+    async type(env, table) {
+      const sql = Sql`SELECT table_type as type
+			FROM information_schema.tables
+			WHERE table_schema = 'public' AND table_name = ${table} LIMIT 1`;
+      /** @type {pg.QueryResult<{ type: string; }>} */
+      const {
+        rows: [row]
+      } = await _exec(sql, env);
+      if (!row) {
+        return null;
+      }
+      switch (String(row.type).toLowerCase()) {
+        case 'base table':
+          return 'table';
+        case 'view':
+          return 'view';
+        default:
+          return '';
+      }
+    },
+    insert(env, table, fields, data, keys) {
+      return query(env, insertSql(table, fields, data, keys, env));
+    },
+    select(env, arg) {
+      return query(env, selectSql(env, arg));
+    },
+    count(env, argv) {
+      return query(env, countSql(env, argv)).then(r => r[0]?.count || 0);
+    },
+    update(env, argv, update) {
+      if (!Object.keys(update).length) {
+        return Promise.resolve(0);
+      }
+      return exec(env, updateSql(env, argv, update));
+    },
+    updateReturn(env, argv, update, returning) {
+      if (!Object.keys(update).length) {
+        const {
+          table,
+          fields,
+          where
+        } = argv;
+        return query(env, selectSql(env, {
+          table,
+          fields,
+          where: where || [],
+          select: returning.map(v => [v, {
+            field: v
+          }])
+        }));
+      }
+      return query(env, updateSql(env, argv, update, returning));
+    },
+    updateMany(env, table, fields, update, pKeys, setKeys, list, where) {
+      return exec(env, updateListSql(env, table, fields, pKeys, setKeys, list, update, where));
+    },
+    updateManyReturn(env, table, fields, update, pKeys, setKeys, list, where, returning) {
+      return query(env, updateListSql(env, table, fields, pKeys, setKeys, list, update, where, returning));
+    },
+    delete(env, {
+      table,
+      fields,
+      where
+    }) {
+      return exec(env, deleteSql(env, table, fields, where));
+    },
+    deleteReturn(env, {
+      table,
+      fields,
+      where
+    }, returning) {
+      return query(env, deleteSql(env, table, fields, where, returning));
+    },
+    addColumn(env, table, column, type, options) {
+      return exec(env, addColumn(table, column, type, options, env));
+    },
+    changeColumn(env, table, column, type, options) {
+      return exec(env, changeColumn(table, column, type, options, env));
+    },
+    changeColumnNull(env, table, column, nullable) {
+      return exec(env, changeColumnNull(table, column, nullable));
+    },
+    dropColumn(env, table, column) {
+      return exec(env, dropColumn(table, column));
+    },
+    renameColumn(env, table, column, newName) {
+      return exec(env, renameColumn(table, column, newName));
+    },
+    addIndex(env, table, name, fields, options) {
+      return exec(env, addIndex(table, name, fields, options));
+    },
+    dropIndex(env, table, name) {
+      return exec(env, dropIndex(table, name));
+    },
+    createTable(env, table, fields) {
+      return exec(env, createTable(table, fields, env));
+    },
+    dropTable(env, table) {
+      return exec(env, dropTable(table));
+    },
+    renameTable(env, table, newName) {
+      return exec(env, renameTable(table, newName));
+    },
+    createView(env, view, q) {
+      return exec(env, createView(view, selectSql(env, q)));
+    },
+    dropView(env, view) {
+      return exec(env, dropView(view));
+    },
+    createMaterializedView(env, view, q) {
+      return exec(env, createMaterializedView(view, selectSql(env, q)));
+    },
+    dropMaterializedView(env, view) {
+      return exec(env, dropMaterializedView(view));
+    },
+    async transaction(env, fn) {
+      if (env?.transaction?.client) {
+        throw new Error();
+      }
+      const client = await connect();
+      await client.query('BEGIN');
+      /** @type {PgEnvTrans} */
+      const transaction = {
+        client
+      };
+      let error = false;
+      try {
+        return await fn(transaction);
+      } catch (e) {
+        error = true;
+        throw e;
+      } finally {
+        transaction.client = null;
+        await client.query(error ? 'ROLLBACK' : 'COMMIT');
+        client.release();
+      }
+    }
+  };
+}
+/**
+ * @param {pg.PoolClient} client
+ * @returns {PgEnvTrans}
+ */
+function toTransaction(client) {
+  return {
+    client
+  };
+}
+
+export { index as default, toTransaction };

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "imodel-pg",
+  "version": "0.1.0",
+  "dependencies": {
+    "pg": "^8.13.3",
+    "tagged-sql": "^0.9.0"
+  },
+  "main": "index.mjs",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://git@gitee.com/fierflame/imodel.git"
+  }
+}