imodel-pg 0.3.1 → 0.3.2

package/index.d.mts

@@ -1,5 +1,5 @@
 /*!
- * imodel v0.3.1
+ * imodel v0.3.2
  * (c) 2019-2025 undefined
  * @license undefined
  */

package/index.mjs

@@ -1,5 +1,5 @@
 /*!
- * imodel v0.3.1
+ * imodel v0.3.2
  * (c) 2019-2025 undefined
  * @license undefined
  */
@@ -934,6 +934,7 @@ WHERE ${Sql`AND`.glue(pKeys.map(f => Sql`${main.field(f)}=${tmp.field(f)}`), get
 /** @import { Environment, IConnection } from 'imodel' */
 /** @import { PgEnvTrans } from '../index.mjs' */
 /** @import { DBIndex, DBTable, DBField } from 'imodel' */
+const tableType = 'BASE TABLE';
 /**
  *
  * @param {Environment<PgEnvTrans>} env
@@ -1065,7 +1066,7 @@ async function loadDefault(env, query, fields) {
     return fields;
   }
   const sql = Sql`
-SELECT ${Sql`,`.glue(data.map((v, k) => Sql`${v} as ${Sql(`a${k}`)}`))}
+SELECT ${Sql`,`.glue(data.map((v, k) => Sql`${v.default} as ${Sql(`a${k}`)}`))}
 `;
   const values = await query(env, sql);
   for (const [index, field] of data.entries()) {
@@ -1143,7 +1144,7 @@ async function loadBaseTables(env, schema, query, tables) {
 		WHERE
 			table_schema = ${schema} 
 			AND
-			table_type = 'base table'
+			table_type = ${tableType}
 			AND
 			table_name IN (${Sql`,`.glue(tables.map(t => Sql`${t}`))})`;
   const rows = await query(env, sql);
@@ -1287,6 +1288,216 @@ async function createNewTable(env, query, {
     await createIndex(env, query, table, index);
   }
 }
+/**
+ *
+ * @param {{fields: string[]; includes: string[]?; unique?: boolean; name: string[]}} oldIndex
+ * @param {DBIndex} [newIndex]
+ * @returns
+ */
+function indexIsEq({
+  includes,
+  name,
+  unique
+}, newIndex) {
+  if (!newIndex) {
+    return false;
+  }
+  if (name?.length !== 1) {
+    return false;
+  }
+  if (!includes) {
+    return false;
+  }
+  if (Boolean(newIndex.unique) !== Boolean(unique)) {
+    return false;
+  }
+  const oldIncludes = new Set(includes);
+  const newIncludes = new Set(newIndex.includes);
+  if (oldIncludes.size !== newIncludes.size) {
+    return false;
+  }
+  for (const k of oldIncludes) {
+    if (!newIncludes.has(k)) {
+      return false;
+    }
+  }
+  return true;
+}
+/**
+ *
+ * @param {DBIndex[]} [indexes]
+ * @returns
+ */
+function buildOldIndexes(indexes) {
+  /** @type {Record<string, {fields: string[]; includes: string[]?; unique?: boolean; name: string[]}>} */
+  const indexMap = {};
+  if (!indexes) {
+    return indexMap;
+  }
+  for (const {
+    fields,
+    includes,
+    unique,
+    name
+  } of indexes) {
+    const keys = [];
+    for (const f of fields) {
+      if (keys.includes(f)) {
+        continue;
+      }
+      keys.push(f);
+    }
+    const key = keys.join('\n');
+    const index = indexMap[key];
+    if (!index) {
+      indexMap[key] = {
+        fields: keys,
+        includes: includes || [],
+        unique,
+        name: name ? [name] : []
+      };
+      continue;
+    }
+    index.includes = null;
+    if (name) {
+      index.name.push(name);
+    }
+  }
+  return indexMap;
+}
+function toTypeHad(type) {
+  switch (type) {
+    case 'ipv4':
+    case 'ipv6':
+      return 'ip';
+    case 'ipnetv4':
+    case 'ipnetv6':
+      return 'ipnet';
+    case 'object':
+      return 'json';
+  }
+  return type;
+}
+/**
+ *
+ * @param {Environment<PgEnvTrans>} env
+ * @param {<T extends pg.QueryResultRow>(env: Environment<PgEnvTrans>, sql: Sql) => Promise<T[]>} query
+ * @param {DBTable} newTable
+ * @param {DBTable} oldTable
+ */
+async function changeTable(env, query, newTable, oldTable) {
+  const {
+    table
+  } = newTable;
+  const newIndexes = new Map(Object.entries(buildNewIndexes(newTable.indexes)));
+  const oldIndexes = buildOldIndexes(oldTable.indexes);
+  for (const [key, index] of Object.entries(oldIndexes)) {
+    if (indexIsEq(index, newIndexes.get(key))) {
+      newIndexes.delete(key);
+      continue;
+    }
+    for (const n of index.name || []) {
+      const sql = Sql`DROP INDEX ${Sql.Id(n, 'index')}`;
+      await query(env, sql);
+    }
+  }
+  // 改名
+  if (table !== oldTable.table) {
+    const sql = Sql`
+ALTER TABLE ${Sql.Table(oldTable.table)} 
+RENAME TO ${Sql.Table(table)}
+`;
+    await query(env, sql);
+  }
+  const primary = Object.entries(newTable.fields).filter(([, v]) => v.primary).sort(([, {
+    primary: a = 0
+  }], [, {
+    primary: b = 0
+  }]) => a - b).map(([v]) => v);
+  const oldPrimary = Object.entries(oldTable.fields).filter(([, v]) => v.primary).sort(([, {
+    primary: a = 0
+  }], [, {
+    primary: b = 0
+  }]) => a - b).map(([v]) => v);
+  const prEq = oldPrimary.length === primary.length && primary.join('\n') === oldPrimary.join('\n');
+  if (!prEq && oldPrimary.length) {
+    let name = oldTable.primary;
+    if (!name) {
+      const sql = Sql`
+SELECT constraint_name 
+FROM information_schema.table_constraints 
+WHERE table_name = ${table} AND constraint_type = 'PRIMARY KEY'
+`;
+      name = (await query(env, sql).then(v => v[0]?.constraint_name)) || '';
+    }
+    // @ts-ignore
+    // eslint-disable-next-line max-len
+    const sql = Sql`ALTER TABLE ${Sql.Table(table)} DROP CONSTRAINT ${Sql.Id(name)}`;
+    await query(env, sql);
+  }
+  const oldFields = new Map(Object.entries(oldTable.fields));
+  // 列处理
+  /** @type {Sql[]} */
+  const COLUMNs = [];
+  for (const [fieldName, field] of Object.entries(newTable.fields)) {
+    const old = oldFields.get(fieldName);
+    oldFields.delete(fieldName);
+    if (!old) {
+      COLUMNs.push(add(fieldName, field.type, field, env));
+      continue;
+    }
+    const type = toTypeHad(field.type);
+    const {
+      size,
+      scale,
+      array,
+      default: defaultValue = null,
+      nullable
+    } = field;
+    if (type !== old.type || Number(array) !== Number(old.array)) ;
+    const COLUMN = Sql`ALTER COLUMN ${Sql.Field(fieldName)}`;
+    const newType = getType(type, {
+      scale,
+      size
+    }, array);
+    const oldType = getType(old.type, old, old.array);
+    if (newType !== oldType) {
+      COLUMNs.push(Sql`${COLUMN} TYPE ${Sql(newType)}`);
+      // TODO: USING "description"::int2
+    }
+    if (Boolean(nullable) !== Boolean(old.nullable)) {
+      COLUMNs.push(nullable ? Sql`${COLUMN} DROP NOT NULL` : Sql`${COLUMN} SET NOT NULL`);
+    }
+    if (defaultValue !== (old.default ?? null)) {
+      COLUMNs.push(defaultValue !== null ? Sql`${COLUMN} SET DEFAULT ${defaultValue}` : Sql`${COLUMN} DROP DEFAULT`);
+    }
+  }
+  {
+    for (const [fieldName, {
+      nullable
+    }] of oldFields) {
+      if (nullable) {
+        continue;
+      }
+      COLUMNs.push(Sql`ALTER COLUMN ${Sql.Field(fieldName)} DROP NOT NULL`);
+    }
+  }
+  if (COLUMNs.length) {
+    const sql = Sql`ALTER TABLE ${Sql.Table(table)} ${Sql`,`.glue(COLUMNs)}`;
+    await query(env, sql);
+  }
+  if (!prEq && primary.length) {
+    const sql = Sql`
+ALTER TABLE ${Sql.Table(table)}
+ADD PRIMARY KEY ${Sql`,`.glue(primary.map(f => Sql.Field(f)))}
+`;
+    await query(env, sql);
+  }
+  // 重建索引
+  for (const index of newIndexes.values()) {
+    await createIndex(env, query, table, index);
+  }
+}
 /**
  *
  * @param {Environment<PgEnvTrans>} env
@@ -1299,12 +1510,14 @@ async function syncTables(env, schema, query, tables, del) {
   const tableNames = tables.map(v => v.table);
   const dbTables = await loadTables(env, schema, query, tableNames);
   const tableMap = new Map(dbTables.map(v => [v.table, v]));
-  tables.map(table => {
+  for (const table of tables) {
     const old = tableMap.get(table.table);
-    if (old) ; else {
-      return createNewTable(env, query, table);
+    if (old) {
+      await changeTable(env, query, table, old);
+    } else {
+      await createNewTable(env, query, table);
     }
-  });
+  }
 }
 
 /** @import { Environment, IConnection } from 'imodel' */

package/package.json

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