@tricoteuses/senat 2.22.16 → 3.0.0

package/lib/src/scripts/shared/incremental_import_sql.js

@@ -0,0 +1,894 @@
+import { prefixedName, senatSchemaName, stagingSchemaName } from "./prefixed_tables";
+function escapeSqlLiteral(value) {
+    return value.replace(/'/g, "''");
+}
+function buildConfiguredMergeKeysValues(datasetName, mergeKeys) {
+    if (!mergeKeys || Object.keys(mergeKeys).length === 0) {
+        return "SELECT NULL::text AS tablename, NULL::text[] AS key_columns WHERE false";
+    }
+    return Object.entries(mergeKeys)
+        .sort(([leftTable], [rightTable]) => leftTable.localeCompare(rightTable))
+        .map(([tableName, columns]) => {
+        const sqlColumns = columns.map((columnName) => `'${escapeSqlLiteral(columnName)}'`).join(", ");
+        return `SELECT '${escapeSqlLiteral(prefixedName(datasetName, tableName))}' AS tablename, ARRAY[${sqlColumns}]::text[] AS key_columns`;
+    })
+        .join("\nUNION ALL\n");
+}
+function buildConfiguredTableNamesValues(datasetName, tableNames) {
+    if (!tableNames || tableNames.length === 0) {
+        return "SELECT NULL::text AS tablename WHERE false";
+    }
+    return [...tableNames]
+        .sort((leftTable, rightTable) => leftTable.localeCompare(rightTable))
+        .map((tableName) => `SELECT '${escapeSqlLiteral(prefixedName(datasetName, tableName))}' AS tablename`)
+        .join("\nUNION ALL\n");
+}
+export function buildNormalizeStagingSchemaSql(datasetName) {
+    const stagingSchema = stagingSchemaName(datasetName);
+    const prefix = `${datasetName}_`;
+    const escapedPrefix = escapeSqlLiteral(prefix);
+    const escapedStagingSchema = escapeSqlLiteral(stagingSchema);
+    return `
+DO $$
+DECLARE
+  relation record;
+  table_row record;
+BEGIN
+  FOR relation IN
+    SELECT c.relname
+    FROM pg_class c
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+    WHERE n.nspname = '${escapedStagingSchema}'
+      AND c.relkind = 'i'
+      AND c.relname NOT LIKE '${escapedPrefix}' || '%'
+  LOOP
+    EXECUTE format(
+      'ALTER INDEX %I.%I RENAME TO %I',
+      '${stagingSchema}',
+      relation.relname,
+      '${prefix}' || relation.relname
+    );
+  END LOOP;
+
+  FOR relation IN
+    SELECT c.relname
+    FROM pg_class c
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+    WHERE n.nspname = '${escapedStagingSchema}'
+      AND c.relkind = 'S'
+      AND c.relname NOT LIKE '${escapedPrefix}' || '%'
+  LOOP
+    EXECUTE format(
+      'ALTER SEQUENCE %I.%I RENAME TO %I',
+      '${stagingSchema}',
+      relation.relname,
+      '${prefix}' || relation.relname
+    );
+  END LOOP;
+
+  FOR table_row IN
+    SELECT tablename
+    FROM pg_tables
+    WHERE schemaname = '${escapedStagingSchema}'
+    ORDER BY tablename
+  LOOP
+    IF table_row.tablename NOT LIKE '${escapedPrefix}' || '%' THEN
+      EXECUTE format(
+        'ALTER TABLE %I.%I RENAME TO %I',
+        '${stagingSchema}',
+        table_row.tablename,
+        '${prefix}' || table_row.tablename
+      );
+    END IF;
+  END LOOP;
+END $$;
+`;
+}
+export function buildIncrementalDatasetImportSql(datasetName, dbUser, mergeKeys, rowMultisetMergeTables) {
+    const stagingSchema = stagingSchemaName(datasetName);
+    const prefix = `${datasetName}_`;
+    const escapedPrefix = escapeSqlLiteral(prefix);
+    const escapedStagingSchema = escapeSqlLiteral(stagingSchema);
+    const configuredMergeKeysValues = buildConfiguredMergeKeysValues(datasetName, mergeKeys);
+    const configuredRowMultisetTablesValues = buildConfiguredTableNamesValues(datasetName, rowMultisetMergeTables);
+    const stagingRelationsQuery = [
+        "SELECT c.relname AS tablename",
+        "FROM pg_class c",
+        "JOIN pg_namespace n ON n.oid = c.relnamespace",
+        `WHERE n.nspname = '${escapedStagingSchema}'`,
+        "  AND c.relkind IN ('r', 'p', 'f')",
+        "ORDER BY c.relname",
+    ].join("\n");
+    return `
+DO $$
+DECLARE
+  table_row record;
+  column_row record;
+  sequence_row record;
+  constraint_row record;
+  index_row record;
+  sequence_owner record;
+  sequence_state record;
+  staging_default text;
+  target_default text;
+  column_definition text;
+  column_list text;
+  staging_column_list text;
+  key_columns text[];
+  key_schema_name text;
+  configured_key_columns text[];
+  matching_key_column_count integer;
+  use_row_multiset_merge boolean;
+  join_condition text;
+  update_assignments text;
+  change_condition text;
+  target_row_signature_expression text;
+  staging_row_signature_expression text;
+  sync_strategy text;
+  staging_table_comment text;
+  target_table_comment text;
+BEGIN
+  PERFORM set_config('search_path', '${senatSchemaName}, pg_catalog', true);
+
+  FOR table_row IN
+    ${stagingRelationsQuery}
+  LOOP
+    IF NOT EXISTS (
+      SELECT 1
+      FROM pg_tables
+      WHERE schemaname = '${senatSchemaName}'
+        AND tablename = table_row.tablename
+    ) THEN
+      EXECUTE format(
+        'CREATE TABLE ${senatSchemaName}.%I (LIKE %I.%I INCLUDING IDENTITY INCLUDING GENERATED INCLUDING DEFAULTS)',
+        table_row.tablename,
+        '${stagingSchema}',
+        table_row.tablename
+      );
+    END IF;
+  END LOOP;
+
+  FOR sequence_row IN
+    SELECT
+      sequencename,
+      data_type,
+      start_value,
+      min_value,
+      max_value,
+      increment_by,
+      cycle,
+      cache_size
+    FROM pg_sequences
+    WHERE schemaname = '${escapedStagingSchema}'
+    ORDER BY sequencename
+  LOOP
+    IF NOT EXISTS (
+      SELECT 1
+      FROM pg_class c
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+      WHERE n.nspname = '${senatSchemaName}'
+        AND c.relkind = 'S'
+        AND c.relname = sequence_row.sequencename
+    ) THEN
+      EXECUTE format('CREATE SEQUENCE ${senatSchemaName}.%I', sequence_row.sequencename);
+    END IF;
+
+    EXECUTE format(
+      'ALTER SEQUENCE ${senatSchemaName}.%I AS %s INCREMENT BY %s MINVALUE %s MAXVALUE %s START WITH %s CACHE %s %s',
+      sequence_row.sequencename,
+      sequence_row.data_type,
+      sequence_row.increment_by,
+      sequence_row.min_value,
+      sequence_row.max_value,
+      sequence_row.start_value,
+      sequence_row.cache_size,
+      CASE WHEN sequence_row.cycle THEN 'CYCLE' ELSE 'NO CYCLE' END
+    );
+  END LOOP;
+
+  FOR table_row IN
+    SELECT tablename
+    FROM pg_tables
+    WHERE schemaname = '${senatSchemaName}'
+      AND tablename LIKE '${escapedPrefix}' || '%'
+    ORDER BY tablename
+  LOOP
+    IF NOT EXISTS (
+      SELECT 1
+      FROM pg_class c
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+      WHERE n.nspname = '${escapedStagingSchema}'
+        AND c.relkind IN ('r', 'p', 'f')
+        AND c.relname = table_row.tablename
+    ) THEN
+      EXECUTE format('DROP TABLE IF EXISTS ${senatSchemaName}.%I CASCADE', table_row.tablename);
+    END IF;
+  END LOOP;
+
+  FOR table_row IN
+    ${stagingRelationsQuery}
+  LOOP
+    key_columns := NULL;
+    key_schema_name := NULL;
+    configured_key_columns := NULL;
+    matching_key_column_count := 0;
+    use_row_multiset_merge := false;
+    join_condition := NULL;
+    update_assignments := NULL;
+    change_condition := NULL;
+    target_row_signature_expression := NULL;
+    staging_row_signature_expression := NULL;
+
+    SELECT configured.key_columns
+    INTO configured_key_columns
+    FROM (
+      ${configuredMergeKeysValues}
+    ) AS configured
+    WHERE configured.tablename = table_row.tablename;
+
+    IF configured_key_columns IS NOT NULL THEN
+      key_columns := configured_key_columns;
+      key_schema_name := 'configured';
+
+      SELECT string_agg(format('t.%1$I IS NOT DISTINCT FROM s.%1$I', key_column), ' AND ' ORDER BY ordinality)
+      INTO join_condition
+      FROM unnest(configured_key_columns) WITH ORDINALITY AS configured_key(key_column, ordinality);
+    ELSE
+      SELECT candidate.key_columns, candidate.join_condition, candidate.source_schema
+      INTO key_columns, join_condition, key_schema_name
+      FROM (
+        SELECT
+          array_agg(att.attname ORDER BY key_column.ordinality) AS key_columns,
+          string_agg(format('t.%1$I = s.%1$I', att.attname), ' AND ' ORDER BY key_column.ordinality) AS join_condition,
+          table_namespace.nspname AS source_schema,
+          CASE WHEN table_namespace.nspname = '${escapedStagingSchema}' THEN 0 ELSE 1 END AS schema_priority,
+          CASE WHEN index_data.indisprimary THEN 0 ELSE 1 END AS priority,
+          count(*) AS key_column_count,
+          index_data.indexrelid
+        FROM pg_index index_data
+        JOIN pg_class table_class ON table_class.oid = index_data.indrelid
+        JOIN pg_namespace table_namespace ON table_namespace.oid = table_class.relnamespace
+        JOIN LATERAL unnest(index_data.indkey::int2[]) WITH ORDINALITY AS key_column(attnum, ordinality) ON true
+        JOIN pg_attribute att
+          ON att.attrelid = table_class.oid
+         AND att.attnum = key_column.attnum
+        WHERE table_namespace.nspname IN ('${escapedStagingSchema}', '${senatSchemaName}')
+          AND table_class.relname = table_row.tablename
+          AND index_data.indisunique
+          AND index_data.indpred IS NULL
+          AND index_data.indexprs IS NULL
+          AND key_column.ordinality <= index_data.indnkeyatts
+          AND key_column.attnum > 0
+          AND EXISTS (
+            SELECT 1
+            FROM information_schema.columns staging_columns
+            WHERE staging_columns.table_schema = '${escapedStagingSchema}'
+              AND staging_columns.table_name = table_row.tablename
+              AND staging_columns.column_name = att.attname
+          )
+        GROUP BY index_data.indexrelid, index_data.indisprimary, table_namespace.nspname
+        HAVING index_data.indisprimary OR bool_and(att.attnotnull)
+        ORDER BY schema_priority, priority, key_column_count, index_data.indexrelid
+        LIMIT 1
+      ) AS candidate;
+    END IF;
+
+    SELECT EXISTS (
+      SELECT 1
+      FROM (
+        ${configuredRowMultisetTablesValues}
+      ) AS configured
+      WHERE configured.tablename = table_row.tablename
+    )
+    INTO use_row_multiset_merge;
+
+    FOR constraint_row IN
+      SELECT con.conname
+      FROM pg_constraint con
+      JOIN pg_class c ON c.oid = con.conrelid
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+      WHERE n.nspname = '${senatSchemaName}'
+        AND c.relname = table_row.tablename
+        AND con.contype <> 'n'
+    LOOP
+      EXECUTE format(
+        'ALTER TABLE ${senatSchemaName}.%I DROP CONSTRAINT IF EXISTS %I CASCADE',
+        table_row.tablename,
+        constraint_row.conname
+      );
+    END LOOP;
+
+    FOR index_row IN
+      SELECT index_class.relname AS index_name
+      FROM pg_index idx
+      JOIN pg_class table_class ON table_class.oid = idx.indrelid
+      JOIN pg_namespace table_namespace ON table_namespace.oid = table_class.relnamespace
+      JOIN pg_class index_class ON index_class.oid = idx.indexrelid
+      LEFT JOIN pg_constraint con ON con.conindid = idx.indexrelid
+      WHERE table_namespace.nspname = '${senatSchemaName}'
+        AND table_class.relname = table_row.tablename
+        AND con.oid IS NULL
+    LOOP
+      EXECUTE format('DROP INDEX IF EXISTS ${senatSchemaName}.%I', index_row.index_name);
+    END LOOP;
+
+    FOR column_row IN
+      SELECT target_columns.column_name
+      FROM information_schema.columns target_columns
+      WHERE target_columns.table_schema = '${senatSchemaName}'
+        AND target_columns.table_name = table_row.tablename
+        AND NOT EXISTS (
+          SELECT 1
+          FROM information_schema.columns staging_columns
+          WHERE staging_columns.table_schema = '${escapedStagingSchema}'
+            AND staging_columns.table_name = table_row.tablename
+            AND staging_columns.column_name = target_columns.column_name
+        )
+      ORDER BY target_columns.ordinal_position DESC
+    LOOP
+      EXECUTE format(
+        'ALTER TABLE ${senatSchemaName}.%I DROP COLUMN IF EXISTS %I CASCADE',
+        table_row.tablename,
+        column_row.column_name
+      );
+    END LOOP;
+
+    FOR column_row IN
+      SELECT
+        staging_columns.column_name,
+        format_type(a.atttypid, a.atttypmod) AS data_type,
+        a.attnotnull AS not_null,
+        a.attidentity AS identity_kind,
+        a.attgenerated AS generated_kind,
+        pg_get_expr(ad.adbin, ad.adrelid) AS default_expression,
+        CASE
+          WHEN coll.oid IS NULL THEN NULL
+          ELSE format('%I.%I', coll_namespace.nspname, coll.collname)
+        END AS collation_name
+      FROM information_schema.columns staging_columns
+      JOIN pg_class c ON c.relname = staging_columns.table_name
+      JOIN pg_namespace n ON n.oid = c.relnamespace AND n.nspname = staging_columns.table_schema
+      JOIN pg_attribute a ON a.attrelid = c.oid AND a.attname = staging_columns.column_name
+      LEFT JOIN pg_attrdef ad ON ad.adrelid = a.attrelid AND ad.adnum = a.attnum
+      LEFT JOIN pg_type typ ON typ.oid = a.atttypid
+      LEFT JOIN pg_collation coll ON coll.oid = a.attcollation AND coll.oid <> typ.typcollation
+      LEFT JOIN pg_namespace coll_namespace ON coll_namespace.oid = coll.collnamespace
+      WHERE staging_columns.table_schema = '${escapedStagingSchema}'
+        AND staging_columns.table_name = table_row.tablename
+        AND NOT EXISTS (
+          SELECT 1
+          FROM information_schema.columns target_columns
+          WHERE target_columns.table_schema = '${senatSchemaName}'
+            AND target_columns.table_name = table_row.tablename
+            AND target_columns.column_name = staging_columns.column_name
+        )
+      ORDER BY staging_columns.ordinal_position
+    LOOP
+      column_definition := column_row.data_type;
+      IF column_row.collation_name IS NOT NULL THEN
+        column_definition := column_definition || ' COLLATE ' || column_row.collation_name;
+      END IF;
+      IF column_row.generated_kind = 's' THEN
+        column_definition :=
+          column_definition ||
+          ' GENERATED ALWAYS AS (' || replace(column_row.default_expression, '${stagingSchema}.', '${senatSchemaName}.') || ') STORED';
+      ELSIF column_row.identity_kind = 'a' THEN
+        column_definition := column_definition || ' GENERATED ALWAYS AS IDENTITY';
+      ELSIF column_row.identity_kind = 'd' THEN
+        column_definition := column_definition || ' GENERATED BY DEFAULT AS IDENTITY';
+      END IF;
+
+      EXECUTE format(
+        'ALTER TABLE ${senatSchemaName}.%I ADD COLUMN %I %s',
+        table_row.tablename,
+        column_row.column_name,
+        column_definition
+      );
+
+      IF column_row.generated_kind = ''
+         AND column_row.identity_kind = ''
+         AND column_row.default_expression IS NOT NULL THEN
+        EXECUTE format(
+          'ALTER TABLE ${senatSchemaName}.%I ALTER COLUMN %I SET DEFAULT %s',
+          table_row.tablename,
+          column_row.column_name,
+          replace(column_row.default_expression, '${stagingSchema}.', '${senatSchemaName}.')
+        );
+      END IF;
+
+      IF column_row.not_null THEN
+        EXECUTE format(
+          'ALTER TABLE ${senatSchemaName}.%I ALTER COLUMN %I SET NOT NULL',
+          table_row.tablename,
+          column_row.column_name
+        );
+      END IF;
+    END LOOP;
+
+    FOR column_row IN
+      SELECT
+        staging_columns.column_name,
+        format_type(staging_attribute.atttypid, staging_attribute.atttypmod) AS staging_data_type,
+        format_type(target_attribute.atttypid, target_attribute.atttypmod) AS target_data_type,
+        staging_attribute.attnotnull AS staging_not_null,
+        target_attribute.attnotnull AS target_not_null,
+        staging_attribute.attidentity AS staging_identity_kind,
+        target_attribute.attidentity AS target_identity_kind,
+        staging_attribute.attgenerated AS staging_generated_kind,
+        target_attribute.attgenerated AS target_generated_kind,
+        pg_get_expr(staging_default_expr.adbin, staging_default_expr.adrelid) AS staging_default_expression,
+        pg_get_expr(target_default_expr.adbin, target_default_expr.adrelid) AS target_default_expression,
+        CASE
+          WHEN staging_collation.oid IS NULL THEN NULL
+          ELSE format('%I.%I', staging_collation_namespace.nspname, staging_collation.collname)
+        END AS staging_collation_name,
+        CASE
+          WHEN target_collation.oid IS NULL THEN NULL
+          ELSE format('%I.%I', target_collation_namespace.nspname, target_collation.collname)
+        END AS target_collation_name
+      FROM information_schema.columns staging_columns
+      JOIN information_schema.columns target_columns
+        ON target_columns.table_schema = '${senatSchemaName}'
+       AND target_columns.table_name = staging_columns.table_name
+       AND target_columns.column_name = staging_columns.column_name
+      JOIN pg_class staging_class ON staging_class.relname = staging_columns.table_name
+      JOIN pg_namespace staging_namespace
+        ON staging_namespace.oid = staging_class.relnamespace
+       AND staging_namespace.nspname = staging_columns.table_schema
+      JOIN pg_attribute staging_attribute
+        ON staging_attribute.attrelid = staging_class.oid
+       AND staging_attribute.attname = staging_columns.column_name
+      LEFT JOIN pg_attrdef staging_default_expr
+        ON staging_default_expr.adrelid = staging_attribute.attrelid
+       AND staging_default_expr.adnum = staging_attribute.attnum
+      LEFT JOIN pg_type staging_type ON staging_type.oid = staging_attribute.atttypid
+      LEFT JOIN pg_collation staging_collation
+        ON staging_collation.oid = staging_attribute.attcollation
+       AND staging_collation.oid <> staging_type.typcollation
+      LEFT JOIN pg_namespace staging_collation_namespace
+        ON staging_collation_namespace.oid = staging_collation.collnamespace
+      JOIN pg_class target_class ON target_class.relname = target_columns.table_name
+      JOIN pg_namespace target_namespace
+        ON target_namespace.oid = target_class.relnamespace
+       AND target_namespace.nspname = target_columns.table_schema
+      JOIN pg_attribute target_attribute
+        ON target_attribute.attrelid = target_class.oid
+       AND target_attribute.attname = target_columns.column_name
+      LEFT JOIN pg_attrdef target_default_expr
+        ON target_default_expr.adrelid = target_attribute.attrelid
+       AND target_default_expr.adnum = target_attribute.attnum
+      LEFT JOIN pg_type target_type ON target_type.oid = target_attribute.atttypid
+      LEFT JOIN pg_collation target_collation
+        ON target_collation.oid = target_attribute.attcollation
+       AND target_collation.oid <> target_type.typcollation
+      LEFT JOIN pg_namespace target_collation_namespace
+        ON target_collation_namespace.oid = target_collation.collnamespace
+      WHERE staging_columns.table_schema = '${escapedStagingSchema}'
+        AND staging_columns.table_name = table_row.tablename
+      ORDER BY staging_columns.ordinal_position
+    LOOP
+      IF column_row.staging_identity_kind <> column_row.target_identity_kind
+         OR column_row.staging_generated_kind <> column_row.target_generated_kind THEN
+        RAISE EXCEPTION
+          'Unsupported identity/generated column change for %.%',
+          table_row.tablename,
+          column_row.column_name;
+      END IF;
+
+      IF column_row.staging_data_type <> column_row.target_data_type
+         OR column_row.staging_collation_name IS DISTINCT FROM column_row.target_collation_name THEN
+        EXECUTE format(
+          'ALTER TABLE ${senatSchemaName}.%I ALTER COLUMN %I TYPE %s%s USING %I::%s',
+          table_row.tablename,
+          column_row.column_name,
+          column_row.staging_data_type,
+          CASE
+            WHEN column_row.staging_collation_name IS NULL THEN ''
+            ELSE ' COLLATE ' || column_row.staging_collation_name
+          END,
+          column_row.column_name,
+          column_row.staging_data_type
+        );
+      END IF;
+
+      staging_default := replace(
+        coalesce(column_row.staging_default_expression, ''),
+        '${stagingSchema}.',
+        '${senatSchemaName}.'
+      );
+      target_default := replace(
+        coalesce(column_row.target_default_expression, ''),
+        '${stagingSchema}.',
+        '${senatSchemaName}.'
+      );
+
+      IF staging_default <> target_default THEN
+        IF column_row.staging_default_expression IS NULL THEN
+          EXECUTE format(
+            'ALTER TABLE ${senatSchemaName}.%I ALTER COLUMN %I DROP DEFAULT',
+            table_row.tablename,
+            column_row.column_name
+          );
+        ELSE
+          EXECUTE format(
+            'ALTER TABLE ${senatSchemaName}.%I ALTER COLUMN %I SET DEFAULT %s',
+            table_row.tablename,
+            column_row.column_name,
+            staging_default
+          );
+        END IF;
+      END IF;
+
+      IF column_row.staging_not_null <> column_row.target_not_null THEN
+        EXECUTE format(
+          'ALTER TABLE ${senatSchemaName}.%I ALTER COLUMN %I %s NOT NULL',
+          table_row.tablename,
+          column_row.column_name,
+          CASE WHEN column_row.staging_not_null THEN 'SET' ELSE 'DROP' END
+        );
+      END IF;
+    END LOOP;
+
+    SELECT obj_description(c.oid, 'pg_class')
+    INTO staging_table_comment
+    FROM pg_class c
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+    WHERE n.nspname = '${escapedStagingSchema}'
+      AND c.relkind IN ('r', 'p', 'f')
+      AND c.relname = table_row.tablename;
+
+    SELECT obj_description(c.oid, 'pg_class')
+    INTO target_table_comment
+    FROM pg_class c
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+    WHERE n.nspname = '${senatSchemaName}'
+      AND c.relkind IN ('r', 'p')
+      AND c.relname = table_row.tablename;
+
+    IF staging_table_comment IS DISTINCT FROM target_table_comment THEN
+      EXECUTE format(
+        'COMMENT ON TABLE ${senatSchemaName}.%I IS %L',
+        table_row.tablename,
+        staging_table_comment
+      );
+    END IF;
+
+    FOR column_row IN
+      SELECT
+        staging_columns.column_name,
+        col_description(staging_class.oid, staging_attribute.attnum) AS staging_comment,
+        col_description(target_class.oid, target_attribute.attnum) AS target_comment
+      FROM information_schema.columns staging_columns
+      JOIN pg_class staging_class ON staging_class.relname = staging_columns.table_name
+      JOIN pg_namespace staging_namespace
+        ON staging_namespace.oid = staging_class.relnamespace
+       AND staging_namespace.nspname = staging_columns.table_schema
+      JOIN pg_attribute staging_attribute
+        ON staging_attribute.attrelid = staging_class.oid
+       AND staging_attribute.attname = staging_columns.column_name
+      JOIN information_schema.columns target_columns
+        ON target_columns.table_schema = '${senatSchemaName}'
+       AND target_columns.table_name = staging_columns.table_name
+       AND target_columns.column_name = staging_columns.column_name
+      JOIN pg_class target_class ON target_class.relname = target_columns.table_name
+      JOIN pg_namespace target_namespace
+        ON target_namespace.oid = target_class.relnamespace
+       AND target_namespace.nspname = target_columns.table_schema
+      JOIN pg_attribute target_attribute
+        ON target_attribute.attrelid = target_class.oid
+       AND target_attribute.attname = target_columns.column_name
+      WHERE staging_columns.table_schema = '${escapedStagingSchema}'
+        AND staging_columns.table_name = table_row.tablename
+      ORDER BY staging_columns.ordinal_position
+    LOOP
+      IF column_row.staging_comment IS DISTINCT FROM column_row.target_comment THEN
+        EXECUTE format(
+          'COMMENT ON COLUMN ${senatSchemaName}.%I.%I IS %L',
+          table_row.tablename,
+          column_row.column_name,
+          column_row.staging_comment
+        );
+      END IF;
+    END LOOP;
+
+    SELECT string_agg(format('%I', columns.column_name), ', ' ORDER BY columns.ordinal_position)
+           , string_agg(format('s.%I', columns.column_name), ', ' ORDER BY columns.ordinal_position)
+    INTO column_list, staging_column_list
+    FROM information_schema.columns columns
+    WHERE columns.table_schema = '${escapedStagingSchema}'
+      AND columns.table_name = table_row.tablename;
+
+    SELECT
+      string_agg(format('%1$I = s.%1$I', columns.column_name), ', ' ORDER BY columns.ordinal_position),
+      string_agg(format('t.%1$I IS DISTINCT FROM s.%1$I', columns.column_name), ' OR ' ORDER BY columns.ordinal_position)
+    INTO update_assignments, change_condition
+    FROM information_schema.columns columns
+    WHERE columns.table_schema = '${escapedStagingSchema}'
+      AND columns.table_name = table_row.tablename
+      AND NOT (columns.column_name = ANY(coalesce(key_columns, ARRAY[]::text[])));
+
+    IF key_columns IS NOT NULL THEN
+      SELECT count(*)
+      INTO matching_key_column_count
+      FROM unnest(key_columns) AS key_column(column_name)
+      JOIN information_schema.columns staging_columns
+        ON staging_columns.table_schema = '${escapedStagingSchema}'
+       AND staging_columns.table_name = table_row.tablename
+       AND staging_columns.column_name = key_column.column_name
+      JOIN information_schema.columns target_columns
+        ON target_columns.table_schema = '${senatSchemaName}'
+       AND target_columns.table_name = table_row.tablename
+       AND target_columns.column_name = key_column.column_name;
+
+      IF matching_key_column_count <> cardinality(key_columns) THEN
+        RAISE NOTICE
+          'Rejected sync key for %.% from % because only %/% columns are present in both staging and target: %',
+          '${senatSchemaName}',
+          table_row.tablename,
+          coalesce(key_schema_name, 'unknown'),
+          matching_key_column_count,
+          cardinality(key_columns),
+          array_to_string(key_columns, ', ');
+        key_columns := NULL;
+        key_schema_name := NULL;
+        join_condition := NULL;
+      END IF;
+    END IF;
+
+    SELECT
+      'jsonb_build_array(' || string_agg(format('t.%I', columns.column_name), ', ' ORDER BY columns.ordinal_position) || ')',
+      'jsonb_build_array(' || string_agg(format('s.%I', columns.column_name), ', ' ORDER BY columns.ordinal_position) || ')'
+    INTO target_row_signature_expression, staging_row_signature_expression
+    FROM information_schema.columns columns
+    WHERE columns.table_schema = '${escapedStagingSchema}'
+      AND columns.table_name = table_row.tablename;
+
+    IF use_row_multiset_merge THEN
+      sync_strategy := 'incremental_row_multiset';
+      RAISE NOTICE
+        'Sync strategy for %.%: %',
+        '${senatSchemaName}',
+        table_row.tablename,
+        sync_strategy;
+
+      EXECUTE format(
+        'WITH staging_counts AS (' ||
+        '  SELECT %2$s AS row_signature, count(*) AS row_count' ||
+        '  FROM %3$I.%1$I s' ||
+        '  GROUP BY 1' ||
+        '), target_ranked AS (' ||
+        '  SELECT ctid, %4$s AS row_signature, row_number() OVER (PARTITION BY %4$s) AS row_number' ||
+        '  FROM ${senatSchemaName}.%1$I t' ||
+        ')' ||
+        ' DELETE FROM ${senatSchemaName}.%1$I t' ||
+        ' USING (' ||
+        '  SELECT candidate_row.ctid' ||
+        '  FROM target_ranked candidate_row' ||
+        '  LEFT JOIN staging_counts reference_row USING (row_signature)' ||
+        '  WHERE candidate_row.row_number > coalesce(reference_row.row_count, 0)' ||
+        ' ) rows_to_delete' ||
+        ' WHERE t.ctid = rows_to_delete.ctid',
+        table_row.tablename,
+        staging_row_signature_expression,
+        '${stagingSchema}',
+        target_row_signature_expression
+      );
+
+      EXECUTE format(
+        'WITH target_counts AS (' ||
+        '  SELECT %2$s AS row_signature, count(*) AS row_count' ||
+        '  FROM ${senatSchemaName}.%1$I t' ||
+        '  GROUP BY 1' ||
+        '), staging_ranked AS (' ||
+        '  SELECT %3$s, %4$s AS row_signature, row_number() OVER (PARTITION BY %4$s) AS row_number' ||
+        '  FROM %5$I.%1$I s' ||
+        ')' ||
+        ' INSERT INTO ${senatSchemaName}.%1$I (%3$s)' ||
+        ' SELECT %3$s' ||
+        ' FROM staging_ranked candidate_row' ||
+        ' LEFT JOIN target_counts reference_row USING (row_signature)' ||
+        ' WHERE candidate_row.row_number > coalesce(reference_row.row_count, 0)',
+        table_row.tablename,
+        target_row_signature_expression,
+        column_list,
+        staging_row_signature_expression,
+        '${stagingSchema}'
+      );
+    ELSIF key_columns IS NULL THEN
+        sync_strategy := 'full_refresh_fallback';
+        RAISE NOTICE
+          'Sync strategy for %.%: %',
+          '${senatSchemaName}',
+          table_row.tablename,
+          sync_strategy;
+        RAISE WARNING
+          'No primary key or all-NOT-NULL unique key found for %.%; falling back to full refresh',
+          '${senatSchemaName}',
+          table_row.tablename;
+
+        EXECUTE format('TRUNCATE TABLE ${senatSchemaName}.%I', table_row.tablename);
+
+        EXECUTE format(
+          'INSERT INTO ${senatSchemaName}.%I (%s) SELECT %s FROM %I.%I s',
+          table_row.tablename,
+          column_list,
+          staging_column_list,
+          '${stagingSchema}',
+          table_row.tablename
+        );
+    ELSE
+      sync_strategy := 'incremental';
+      RAISE NOTICE
+        'Sync strategy for %.%: % (key from %: %)',
+        '${senatSchemaName}',
+        table_row.tablename,
+        sync_strategy,
+        key_schema_name,
+        array_to_string(key_columns, ', ');
+
+      EXECUTE format(
+        'DELETE FROM ${senatSchemaName}.%1$I t WHERE NOT EXISTS (SELECT 1 FROM %2$I.%1$I s WHERE %3$s)',
+        table_row.tablename,
+        '${stagingSchema}',
+        join_condition
+      );
+
+      IF update_assignments IS NOT NULL THEN
+        EXECUTE format(
+          'UPDATE ${senatSchemaName}.%1$I t SET %2$s FROM %3$I.%1$I s WHERE %4$s AND (%5$s)',
+          table_row.tablename,
+          update_assignments,
+          '${stagingSchema}',
+          join_condition,
+          change_condition
+        );
+      END IF;
+
+      EXECUTE format(
+        'INSERT INTO ${senatSchemaName}.%1$I (%2$s) SELECT %3$s FROM %4$I.%1$I s WHERE NOT EXISTS (SELECT 1 FROM ${senatSchemaName}.%1$I t WHERE %5$s)',
+        table_row.tablename,
+        column_list,
+        staging_column_list,
+        '${stagingSchema}',
+        join_condition
+      );
+    END IF;
+  END LOOP;
+
+  FOR sequence_row IN
+    SELECT sequencename
+    FROM pg_sequences
+    WHERE schemaname = '${escapedStagingSchema}'
+    ORDER BY sequencename
+  LOOP
+    SELECT
+      dependent_table.relname AS table_name,
+      dependent_column.attname AS column_name
+    INTO sequence_owner
+    FROM pg_class sequence_class
+    JOIN pg_namespace sequence_namespace ON sequence_namespace.oid = sequence_class.relnamespace
+    JOIN pg_depend dependency
+      ON dependency.objid = sequence_class.oid
+     AND dependency.deptype = 'a'
+    JOIN pg_class dependent_table ON dependent_table.oid = dependency.refobjid
+    JOIN pg_namespace dependent_namespace ON dependent_namespace.oid = dependent_table.relnamespace
+    JOIN pg_attribute dependent_column
+      ON dependent_column.attrelid = dependent_table.oid
+     AND dependent_column.attnum = dependency.refobjsubid
+    WHERE sequence_namespace.nspname = '${escapedStagingSchema}'
+      AND dependent_namespace.nspname = '${escapedStagingSchema}'
+      AND sequence_class.relname = sequence_row.sequencename;
+
+    IF sequence_owner.table_name IS NULL THEN
+      EXECUTE format('ALTER SEQUENCE ${senatSchemaName}.%I OWNED BY NONE', sequence_row.sequencename);
+    ELSE
+      EXECUTE format(
+        'ALTER SEQUENCE ${senatSchemaName}.%I OWNED BY ${senatSchemaName}.%I.%I',
+        sequence_row.sequencename,
+        sequence_owner.table_name,
+        sequence_owner.column_name
+      );
+    END IF;
+  END LOOP;
+
+  FOR constraint_row IN
+    SELECT
+      table_class.relname AS table_name,
+      con.conname,
+      con.contype,
+      pg_get_constraintdef(con.oid, true) AS constraint_definition
+    FROM pg_constraint con
+    JOIN pg_class table_class ON table_class.oid = con.conrelid
+    JOIN pg_namespace table_namespace ON table_namespace.oid = table_class.relnamespace
+    WHERE table_namespace.nspname = '${escapedStagingSchema}'
+      AND con.contype <> 'n'
+    ORDER BY
+      CASE con.contype
+        WHEN 'p' THEN 1
+        WHEN 'u' THEN 2
+        WHEN 'c' THEN 3
+        WHEN 'f' THEN 4
+        ELSE 5
+      END,
+      table_class.relname,
+      con.conname
+  LOOP
+    EXECUTE format(
+      'ALTER TABLE ${senatSchemaName}.%I ADD CONSTRAINT %I %s',
+      constraint_row.table_name,
+      constraint_row.conname,
+      replace(
+        replace(
+          constraint_row.constraint_definition,
+          ' REFERENCES ' || '${stagingSchema}' || '.',
+          ' REFERENCES ${senatSchemaName}.'
+        ),
+        ' REFERENCES ONLY ' || '${stagingSchema}' || '.',
+        ' REFERENCES ONLY ${senatSchemaName}.'
+      )
+    );
+  END LOOP;
+
+  FOR index_row IN
+    SELECT
+      table_class.relname AS table_name,
+      pg_get_indexdef(index_data.indexrelid) AS index_definition
+    FROM pg_index index_data
+    JOIN pg_class table_class ON table_class.oid = index_data.indrelid
+    JOIN pg_namespace table_namespace ON table_namespace.oid = table_class.relnamespace
+    LEFT JOIN pg_constraint con ON con.conindid = index_data.indexrelid
+    WHERE table_namespace.nspname = '${escapedStagingSchema}'
+      AND con.oid IS NULL
+    ORDER BY table_class.relname, pg_get_indexdef(index_data.indexrelid)
+  LOOP
+    EXECUTE replace(
+      index_row.index_definition,
+      ' ON ${stagingSchema}.',
+      ' ON ${senatSchemaName}.'
+    );
+  END LOOP;
+
+  FOR sequence_row IN
+    SELECT sequencename
+    FROM pg_sequences
+    WHERE schemaname = '${escapedStagingSchema}'
+    ORDER BY sequencename
+  LOOP
+    EXECUTE format(
+      'SELECT last_value, is_called FROM %I.%I',
+      '${stagingSchema}',
+      sequence_row.sequencename
+    )
+    INTO sequence_state;
+
+    EXECUTE format(
+      'SELECT setval(%L, %s, %L)',
+      '${senatSchemaName}.' || sequence_row.sequencename,
+      sequence_state.last_value,
+      sequence_state.is_called
+    );
+  END LOOP;
+
+  FOR sequence_row IN
+    SELECT c.relname AS sequencename
+    FROM pg_class c
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+    WHERE n.nspname = '${senatSchemaName}'
+      AND c.relkind = 'S'
+      AND c.relname LIKE '${escapedPrefix}' || '%'
+    ORDER BY c.relname
+  LOOP
+    IF NOT EXISTS (
+      SELECT 1
+      FROM pg_sequences
+      WHERE schemaname = '${escapedStagingSchema}'
+        AND sequencename = sequence_row.sequencename
+    ) THEN
+      EXECUTE format('DROP SEQUENCE IF EXISTS ${senatSchemaName}.%I CASCADE', sequence_row.sequencename);
+    END IF;
+  END LOOP;
+END $$;
+
+GRANT SELECT ON ALL TABLES IN SCHEMA ${senatSchemaName} TO ${dbUser};
+`;
+}