exwiw 0.9.9 → 0.9.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b734fe407ce3c430c3197b04db275df36640849f6795d7636614d8fab0c6574
-  data.tar.gz: 4be4a94e18f929ef13c97072248e4c7b7e867ad80160841a81c0146a929b9e21
+  metadata.gz: 6f85d2a708bc4da44d7a32b0ef91dcf42967b65f5ddcfca516e0ce674de568b4
+  data.tar.gz: 0eb9ea0cd15abd41d64380170323070c0961a37a1bd796bfd9c1c63484c8b6d3
 SHA512:
-  metadata.gz: cdb946b9f0b3ae2bfca4aa74aca93454cbc0ae6f332f0900216c3a35be9d8bdcef2b2082744bcc6262b6bc9cf72afae9a477c85f7e00d60da8d6eaa4ed55b825
-  data.tar.gz: 12f63468a2d834e558b98e73937e739aa2ab4581cf83699e0a675e280cfd6e6f158d136156400e3ec7c7672beaa63189a6e90c727cc1c87281412e061c72b417
+  metadata.gz: 645793841437d64ad976c84e89dc7f0bde405dbc549a953b870085a6fac26886060535a69bc3f41f5480f4dc31d5c15ce97b598d0146bb96981004cdcee3679e
+  data.tar.gz: 15efb4638a90daf07b9cc83cf2f6613fd0ecee93daaff6fbad40608002d0bf26c4bf61a64a83389d7e672101a6d15c3b4250e34b7daa202d176c62d931b1a7a5

data/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## [Unreleased]
 
+## [0.9.11] - 2026-07-09
+
+### Added
+
+- **Reserved-word and special-character identifiers are now quoted (SQL adapters).** Table and column names that are reserved words (`order`, `from`, `group`, …) or contain characters invalid as a bare identifier are conditionally quoted — backticks on mysql, double quotes on postgresql/sqlite — across every emission path: SELECT projection and masking expressions, FROM/JOIN, WHERE, subqueries, materialized scope JOINs, INSERT / COPY headers and DELETE. Previously only the mysql INSERT header was quoted ([#83](https://github.com/heyinc/exwiw/pull/83)), so a reserved table name broke the extraction SELECT everywhere, a reserved column broke postgresql/sqlite INSERTs, and sqlite rejected even table-qualified reserved columns. Ordinary names stay bare, so output for existing configs is byte-identical (mysql INSERT headers keep their always-backtick form from 0.4.5). Dotted table names are treated as schema qualification and quoted per part (`billing.order` → `` billing.`order` ``), preserving Rails multi-schema `table_name`s. The reserved-word lists cover MySQL 8.4 and 9.x (including 9's `LIBRARY`) plus MariaDB-specific words, PostgreSQL's fully reserved key words, and — for sqlite — exactly the keywords that fail to parse bare in exwiw's emission positions, so fallback-accepted names like `key` are not churned. The lists are enforced by specs that probe the live mysql/postgresql servers' own keyword catalogs and re-derive the sqlite set empirically.
+
+### Fixed
+
+- **PostgreSQL: post-import sequence sync now works for reserved or mixed-case table names.** `post_insert_sql` passed the raw table name to `pg_get_serial_sequence`, which parses its first argument with identifier rules and case-folds it — so a table like `"Order"` (now extractable thanks to identifier quoting) failed with `relation "order" does not exist` right after a successful data pass. The conditionally quoted name is passed instead; ordinary lowercase names are unaffected.
+
+## [0.9.10] - 2026-07-09
+
+### Fixed
+
+- **A whole-database schema restore no longer aborts when a preload-required extension (e.g. pglogical) is absent on the target.** `wrap_create_extension_in_do_block` already skipped a `CREATE EXTENSION` the target cannot provide for `feature_not_supported` (0A000) and `invalid_schema_name` (3F000), but an extension that must be loaded via `shared_preload_libraries` raises a bare `elog(ERROR, "<name> is not in shared_preload_libraries")`, which carries the default SQLSTATE `XX000` (`internal_error`) — not caught, so the whole `insert-000-schema.sql` restore aborted (observed restoring a pglogical-carrying production dump into a plain RDS mirage target). `internal_error` is now caught alongside the other two and re-raised as a WARNING, so the extension is skipped and the restore continues. `insufficient_privilege` (42501) is still deliberately NOT caught.
+
 ## [0.9.9] - 2026-07-09
 
 ### Changed
@@ -17,6 +33,7 @@
 ### Changed
 
 - **Unknown keys in schema config JSON are now rejected on load instead of being silently dropped.** Serdes deserialization is lenient, so a key that matched no declared attribute was discarded without a word — turning a typo (`reverse_scop`, `bulk_insert_chunk_sise`) or a key another adapter supports but this one does not (`raw_sql`/`map` on a MongoDB field; `reverse_scope` on a MongoDB collection before this release) into a silent no-op: the dump ran and the requested masking/scoping simply never happened. `TableConfig.from` / `MongodbCollectionConfig.from` now validate the raw hash against the declared attributes — including the nested `belongs_tos` / `columns` / `fields` / `reverse_scope` / `embedded_in` / `replace_with_fake_data` entries — and raise `Exwiw::UnknownConfigKeyError` (an `ArgumentError` subclass) naming the key(s), the table/collection, the nested position, and the allowed keys; `export`/`explain` prepend the offending file path. This is a deliberate hard error with no opt-out: every declared key still passes — including the documentation-only `comment` on table/collection configs and their `belongs_tos`/`columns`/`fields` entries, which remains the supported place for free-form notes — so a config that only uses supported keys is unaffected, while anything now rejected was already being ignored. If a config carries stray keys, remove them or fold them into `comment`.
+>>>>>>> 71a0958eea6e031d2beeb7349bea35cb460414ca
 
 ## [0.9.7] - 2026-07-08
 

data/lib/exwiw/adapter/identifier_quoting.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Exwiw
+  module Adapter
+    # Conditional identifier quoting shared by the SQL adapters (mysql /
+    # postgresql / sqlite).
+    #
+    # Table and column names are emitted bare unless they NEED quoting — a
+    # reserved word for that database, or characters outside the safe
+    # bare-identifier set (e.g. a column named `from`, which is a syntax error
+    # unquoted in every dialect's INSERT column list and in sqlite even when
+    # table-qualified). Quoting conditionally rather than always (Rails-style)
+    # keeps the generated SQL byte-identical to previous exwiw releases for
+    # ordinary names, so existing dump snapshots and diffs stay stable.
+    # Known exception to that byte-identity promise: mysql-only exotic names —
+    # digit-leading (`2fa_codes`) — are valid bare in mysql but fall outside
+    # BARE_IDENTIFIER_PATTERN and are now backtick-quoted (still valid SQL,
+    # cosmetic difference only).
+    #
+    # Table names get dot-aware handling (#quote_table_name): a Rails
+    # multi-schema app sets `self.table_name = "billing.invoices"` and the
+    # schema generator copies it verbatim into the config, so the name must be
+    # emitted as two identifiers (`billing."order"`), never quoted whole
+    # (`"billing.invoices"` names a nonexistent relation). An identifier with
+    # a literal dot in it cannot be expressed — but its bare form was already
+    # misparsed as schema.table before quoting existed, so nothing regresses.
+    #
+    # Each adapter includes its dialect submodule (Mysql / Postgresql /
+    # Sqlite below), which bundles the quote character with the matching
+    # reserved-word set. `Base` includes the bare module so shared helpers
+    # (Base#null_preserving) can rely on #qualified_name existing; the hooks
+    # raise NotImplementedError until a dialect submodule provides them.
+    #
+    # The word sets may over-approximate what strictly needs quoting in a
+    # given position (e.g. mysql accepts a reserved word unquoted right after
+    # a `.`): quoting a word that did not need it is still valid SQL and — for
+    # the lowercase names these lists contain — refers to the same identifier,
+    # while missing one is a syntax error. Reservedness is checked
+    # case-insensitively but the identifier is quoted with its exact spelling
+    # preserved, matching the catalog-exact names exwiw configs carry.
+    #
+    # spec/adapter/identifier_quoting_spec.rb keeps the lists honest: it
+    # probes every sqlite keyword in every emission context and asserts the
+    # live mysql / postgresql servers' own reserved-word catalogs are covered.
+    module IdentifierQuoting
+      # A name every supported dialect accepts bare: leading letter or
+      # underscore, then letters, digits, `_` or `$` (`$` verified bare-valid
+      # on mysql, postgresql and sqlite — and postgresql resolves such names
+      # by case-folding, so quoting them would break configs that spell a
+      # folded name in mixed case).
+      BARE_IDENTIFIER_PATTERN = /\A[A-Za-z_][A-Za-z0-9_$]*\z/
+
+      # Quote a single identifier (column name, or one part of a table name)
+      # only when the bare form would not parse (reserved word or unsafe
+      # characters).
+      def quote_identifier(name)
+        name = name.to_s
+        if name.match?(BARE_IDENTIFIER_PATTERN) && !reserved_words.include?(name.downcase)
+          name
+        else
+          force_quote_identifier(name)
+        end
+      end
+
+      # Always-quoted form of a single identifier (embedded quote chars
+      # doubled). Used where the adapter's output format has historically
+      # always quoted (mysql INSERT headers) and must stay byte-identical.
+      def force_quote_identifier(name)
+        quote_char = identifier_quote_char
+        "#{quote_char}#{name.to_s.gsub(quote_char) { quote_char * 2 }}#{quote_char}"
+      end
+
+      # Table-name form: dot-aware. `billing.invoices` is a schema-qualified
+      # name (two identifiers), so each dot-separated part is quoted
+      # independently — `billing."order"`, not `"billing.order"`.
+      def quote_table_name(name)
+        name.to_s.split(".", -1).map { |part| quote_identifier(part) }.join(".")
+      end
+
+      # Always-quoted, dot-aware table name (mysql INSERT headers). Splitting
+      # changes PR #83's output only for dotted names, whose whole-name quoting
+      # (`` `billing.invoices` ``) named a nonexistent table anyway.
+      def force_quote_table_name(name)
+        name.to_s.split(".", -1).map { |part| force_quote_identifier(part) }.join(".")
+      end
+
+      # `<table>.<column>` with the table part dot-aware and every identifier
+      # quoted as needed.
+      def qualified_name(table_name, column_name)
+        "#{quote_table_name(table_name)}.#{quote_identifier(column_name)}"
+      end
+
+      private def identifier_quote_char
+        raise NotImplementedError, "#{self.class} must provide #identifier_quote_char (include an IdentifierQuoting dialect submodule)"
+      end
+
+      private def reserved_words
+        raise NotImplementedError, "#{self.class} must provide #reserved_words (include an IdentifierQuoting dialect submodule)"
+      end
+
+      # MySQL reserved words: the 8.4 manual's "(R)" entries
+      # (https://dev.mysql.com/doc/refman/8.4/en/keywords.html), plus the
+      # 9.x additions (verified against a live 9.7 server's
+      # INFORMATION_SCHEMA.KEYWORDS by the identifier_quoting spec), plus the
+      # MariaDB-specific reserved words (https://mariadb.com/kb/en/reserved-words/
+      # — exwiw supports MariaDB servers, see MysqlAdapter#mariadb_mysqldump?).
+      # Words reserved in only one engine are still safe to quote in the
+      # other: backticks are always valid, and names in either engine's list
+      # were a syntax error there before, so no previously working output
+      # changes on the engine that reserves them.
+      MYSQL_RESERVED_WORDS = Set.new(%w[
+        accessible add all alter analyze and as asc asensitive before between
+        bigint binary blob both by call cascade case change char character
+        check collate column condition constraint continue convert create
+        cross cube cume_dist current_date current_time current_timestamp
+        current_user cursor database databases day_hour day_microsecond
+        day_minute day_second dec decimal declare default delayed delete
+        dense_rank desc describe deterministic distinct distinctrow div double
+        drop dual each else elseif empty enclosed escaped except exists exit
+        explain false fetch first_value float float4 float8 for force foreign
+        from fulltext function generated get grant group grouping groups
+        having high_priority hour_microsecond hour_minute hour_second if
+        ignore in index infile inner inout insensitive insert int int1 int2
+        int3 int4 int8 integer intersect interval into io_after_gtids
+        io_before_gtids is iterate join json_table key keys kill lag
+        last_value lateral lead leading leave left library like limit linear
+        lines load localtime localtimestamp lock long longblob longtext loop
+        low_priority master_bind master_ssl_verify_server_cert match maxvalue
+        mediumblob mediumint mediumtext middleint minute_microsecond
+        minute_second mod modifies natural not no_write_to_binlog nth_value
+        ntile null numeric of on optimize optimizer_costs option optionally
+        or order out outer outfile over partition percent_rank precision
+        primary procedure purge range rank read reads read_write real
+        recursive references regexp release rename repeat replace require
+        resignal restrict return revoke right rlike row rows row_number
+        schema schemas second_microsecond select sensitive separator set show
+        signal smallint spatial specific sql sqlexception sqlstate sqlwarning
+        sql_big_result sql_calc_found_rows sql_small_result ssl starting
+        stored straight_join system table terminated then tinyblob tinyint
+        tinytext to trailing trigger true undo union unique unlock unsigned
+        update usage use using utc_date utc_time utc_timestamp values
+        varbinary varchar varcharacter varying virtual when where while
+        window with write xor year_month zerofill
+        conversion current_role delete_domain_id do_domain_ids general
+        ignore_domain_ids ignore_server_ids master_heartbeat_period offset
+        page_checksum parse_vcol_expr ref_system_id returning slow
+        st_collect stats_auto_recalc stats_persistent stats_sample_pages
+        to_date vector
+      ]).freeze
+
+      # PostgreSQL reserved key words (SQL Key Words appendix): the "reserved"
+      # entries plus the "reserved (can be function or type name)" entries —
+      # neither may appear as a bare table/column identifier.
+      POSTGRESQL_RESERVED_WORDS = Set.new(%w[
+        all analyse analyze and any array as asc asymmetric authorization
+        binary both case cast check collate collation column concurrently
+        constraint create cross current_catalog current_date current_role
+        current_schema current_time current_timestamp current_user default
+        deferrable desc distinct do else end except false fetch for foreign
+        freeze from full grant group having ilike in initially inner intersect
+        into is isnull join lateral leading left like limit localtime
+        localtimestamp natural not notnull null offset on only or order outer
+        overlaps placing primary references returning right select
+        session_user similar some symmetric system_user table tablesample
+        then to trailing true union unique user using variadic verbose when
+        where window with
+      ]).freeze
+
+      # The subset of SQLite keywords (https://sqlite.org/lang_keywords.html)
+      # that actually fail to parse as bare identifiers in the positions exwiw
+      # emits (qualified column, INSERT column list, FROM/DELETE/JOIN table
+      # name, CASE masking, derived-table scope JOIN). SQLite's parser accepts
+      # the other ~half of its keywords as identifiers via fallback (e.g.
+      # `key`, `temp`, `row`), and those are deliberately NOT quoted so output
+      # for such names stays byte-identical with previous releases — a name in
+      # this list produced a syntax error before, so quoting it cannot change
+      # any previously working output. Derived empirically; the probe is
+      # checked in as spec/adapter/identifier_quoting_spec.rb, which re-runs
+      # it against the bundled sqlite3 and asserts this exact set, so a new
+      # SQLite reserved word (as RETURNING was in 3.35) or a drifted list
+      # fails the suite instead of silently emitting broken SQL.
+      SQLITE_RESERVED_WORDS = Set.new(%w[
+        add all alter and as autoincrement between case cast check collate
+        commit constraint create current_date current_time current_timestamp
+        default deferrable delete distinct drop else escape except exists
+        foreign from group having in index insert intersect into is isnull
+        join limit not nothing notnull null on or order primary raise
+        references returning select set table then to transaction union
+        unique update using values when where
+      ]).freeze
+
+      # Dialect submodules: bundle the quote character with the matching
+      # reserved-word set so an adapter opts in with a single include.
+      module Mysql
+        include IdentifierQuoting
+
+        private def identifier_quote_char
+          '`'
+        end
+
+        private def reserved_words
+          MYSQL_RESERVED_WORDS
+        end
+      end
+
+      module Postgresql
+        include IdentifierQuoting
+
+        private def identifier_quote_char
+          '"'
+        end
+
+        private def reserved_words
+          POSTGRESQL_RESERVED_WORDS
+        end
+      end
+
+      module Sqlite
+        include IdentifierQuoting
+
+        private def identifier_quote_char
+          '"'
+        end
+
+        private def reserved_words
+          SQLITE_RESERVED_WORDS
+        end
+      end
+    end
+  end
+end

data/lib/exwiw/adapter/mysql_adapter.rb

@@ -5,6 +5,7 @@ require 'open3'
 module Exwiw
   module Adapter
     class MysqlAdapter < Base
+      include IdentifierQuoting::Mysql
       include SqlBulkInsert
 
       # A lazy, streaming stand-in for the materialized rows #execute used to
@@ -152,22 +153,23 @@ module Exwiw
       end
 
       # The INSERT header for this adapter. MySQL backtick-quotes the table and
-      # column identifiers. #to_bulk_insert / #write_inserts (SqlBulkInsert)
-      # append the value tuples and the trailing `;`.
+      # column identifiers (always, to stay byte-identical with historical
+      # output). #to_bulk_insert / #write_inserts (SqlBulkInsert) append the
+      # value tuples and the trailing `;`.
       private def insert_header(table)
-        table_name = table.name
+        table_name = force_quote_table_name(table.name)
         if table.rails_managed?
-          "INSERT INTO `#{table_name}` VALUES\n"
+          "INSERT INTO #{table_name} VALUES\n"
         else
-          column_names = table.columns.map { |c| "`#{c.name}`" }.join(', ')
-          "INSERT INTO `#{table_name}` (#{column_names}) VALUES\n"
+          column_names = table.columns.map { |c| force_quote_identifier(c.name) }.join(', ')
+          "INSERT INTO #{table_name} (#{column_names}) VALUES\n"
         end
       end
 
       def to_bulk_delete(select_query_ast, table)
         raise NotImplementedError unless select_query_ast.is_a?(Exwiw::QueryAst::Select)
 
-        sql = "DELETE FROM #{select_query_ast.from_table_name}"
+        sql = "DELETE FROM #{quote_table_name(select_query_ast.from_table_name)}"
 
         if select_query_ast.join_clauses.empty?
           # Ignore filter option, because bulk delete is for cleaning before import,
@@ -205,7 +207,7 @@ module Exwiw
 
         foreign_key = first_join.foreign_key
         subquery_sql = compile_ast(subquery_ast)
-        sql += "\nWHERE #{select_query_ast.from_table_name}.#{foreign_key} IN (#{subquery_sql})"
+        sql += "\nWHERE #{qualified_name(select_query_ast.from_table_name, foreign_key)} IN (#{subquery_sql})"
 
         # first_join.base_where_clauses holds conditions on the outer
         # delete-target table (from_table_name), such as a polymorphic type
@@ -240,14 +242,14 @@ module Exwiw
                elsif query_ast.select_all
                  # A lifted scope JOIN brings a derived table into FROM, so a bare
                  # `*` would also project its column. Qualify to this table's own.
-                 scope_clauses.any? ? "#{query_ast.from_table_name}.*" : "*"
+                 scope_clauses.any? ? "#{quote_table_name(query_ast.from_table_name)}.*" : "*"
                else
                  query_ast.columns.map { |col| compile_column_name(query_ast, col) }.join(', ')
                end
-        sql += " FROM #{query_ast.from_table_name}"
+        sql += " FROM #{quote_table_name(query_ast.from_table_name)}"
 
         query_ast.join_clauses.each do |join|
-          sql += " JOIN #{join.join_table_name} ON #{join.base_table_name}.#{join.foreign_key} = #{join.join_table_name}.#{join.primary_key}"
+          sql += " JOIN #{quote_table_name(join.join_table_name)} ON #{qualified_name(join.base_table_name, join.foreign_key)} = #{qualified_name(join.join_table_name, join.primary_key)}"
 
           join.where_clauses.each do |where|
             compiled_where_condition = compile_where_condition(where, join.join_table_name)
@@ -290,10 +292,10 @@ module Exwiw
       # to `<col> IN (subquery)`.
       private def compile_scope_join(from_table_name, where_clause, idx)
         subquery = where_clause.value
-        projection = subquery_projection_name(subquery)
+        projection = quote_identifier(subquery_projection_name(subquery))
         src_alias = "exwiw_scope_src_#{idx}"
         ids_alias = "exwiw_scope_ids_#{idx}"
-        outer_key = "#{from_table_name}.#{where_clause.column_name}"
+        outer_key = qualified_name(from_table_name, where_clause.column_name)
 
         "JOIN (SELECT DISTINCT #{src_alias}.#{projection} AS exwiw_scope_id " \
           "FROM (#{compile_subquery(subquery)}) AS #{src_alias}) AS #{ids_alias} " \
@@ -304,7 +306,7 @@ module Exwiw
         # Use as it is if it's a raw query
         return where_clause if where_clause.is_a?(String)
 
-        key = "#{table_name}.#{where_clause.column_name}"
+        key = qualified_name(table_name, where_clause.column_name)
 
         if where_clause.operator == :eq
           values = where_clause.value.map { |v| escape_value(v) }
@@ -335,9 +337,9 @@ module Exwiw
         end
 
         inner_values = subquery.where_values.map { |v| escape_value(v) }
-        "SELECT #{subquery.table_name}.#{subquery.select_column} " \
-          "FROM #{subquery.table_name} " \
-          "WHERE #{subquery.table_name}.#{subquery.where_column} IN (#{inner_values.join(', ')})"
+        "SELECT #{qualified_name(subquery.table_name, subquery.select_column)} " \
+          "FROM #{quote_table_name(subquery.table_name)} " \
+          "WHERE #{qualified_name(subquery.table_name, subquery.where_column)} IN (#{inner_values.join(', ')})"
       end
 
       # Backslash and control-character escapes, matching mysqldump. Escaping
@@ -372,14 +374,14 @@ module Exwiw
       private def compile_column_name(ast, column)
         case column
         when Exwiw::QueryAst::ColumnValue::Plain
-          "#{ast.from_table_name}.#{column.name}"
+          qualified_name(ast.from_table_name, column.name)
         when Exwiw::QueryAst::ColumnValue::RawSql
           column.value
         when Exwiw::QueryAst::ColumnValue::ReplaceWith
           parts = column.value.scan(/[^{}]+|\{[^{}]*\}/).map do |part|
             if part.start_with?('{')
               name = part[1..-2]
-              "#{ast.from_table_name}.#{name}"
+              qualified_name(ast.from_table_name, name)
             else
               "'#{part}'"
             end

data/lib/exwiw/adapter/postgresql_adapter.rb

@@ -3,6 +3,7 @@
 module Exwiw
   module Adapter
     class PostgresqlAdapter < Base
+      include IdentifierQuoting::Postgresql
       include SqlBulkInsert
 
       # A lazy, streaming stand-in for the materialized rows #execute used to
@@ -158,25 +159,26 @@ module Exwiw
         @logger.info("  Wrote full-database schema to #{output_path} (#{ordered_tables.size} table(s) in scope for data).")
       end
 
-      # The INSERT header for this adapter. PostgreSQL uses bare identifiers.
+      # The INSERT header for this adapter. PostgreSQL uses bare identifiers,
+      # quoted only when required (reserved word / unsafe characters).
       # #to_bulk_insert / #write_inserts (SqlBulkInsert) append the value tuples
       # and the trailing `;`.
       private def insert_header(table)
-        table_name = table.name
+        table_name = quote_table_name(table.name)
         if table.rails_managed?
           "INSERT INTO #{table_name} VALUES\n"
         else
-          column_names = table.columns.map(&:name).join(', ')
+          column_names = table.columns.map { |c| quote_identifier(c.name) }.join(', ')
           "INSERT INTO #{table_name} (#{column_names}) VALUES\n"
         end
       end
 
       def to_copy_from_stdin(results, table)
         header = if table.rails_managed?
-                   "COPY #{table.name} FROM stdin;"
+                   "COPY #{quote_table_name(table.name)} FROM stdin;"
                  else
-                   column_names = table.columns.map(&:name).join(', ')
-                   "COPY #{table.name} (#{column_names}) FROM stdin;"
+                   column_names = table.columns.map { |c| quote_identifier(c.name) }.join(', ')
+                   "COPY #{quote_table_name(table.name)} (#{column_names}) FROM stdin;"
                  end
         lines = [header]
         results.each do |row|
@@ -203,8 +205,14 @@ module Exwiw
         pk = table.primary_key
         return nil if pk.nil? || pk.empty?
 
+        # pg_get_serial_sequence parses its first argument with identifier
+        # rules (unquoted parts are case-folded), so pass the same
+        # conditionally quoted form the extraction queries use — a bare
+        # 'Order' would fold to the nonexistent relation 'order' even though
+        # the quoted extraction just succeeded. The second argument is taken
+        # literally (no folding), so the raw column name is correct.
         seq_name = connection
-          .exec_params("SELECT pg_get_serial_sequence($1, $2)", [table.name, pk])
+          .exec_params("SELECT pg_get_serial_sequence($1, $2)", [quote_table_name(table.name), pk])
           .values.dig(0, 0)
         return nil if seq_name.nil?
 
@@ -219,7 +227,7 @@ module Exwiw
       def to_bulk_delete(select_query_ast, table)
         raise NotImplementedError unless select_query_ast.is_a?(Exwiw::QueryAst::Select)
 
-        sql = "DELETE FROM #{select_query_ast.from_table_name}"
+        sql = "DELETE FROM #{quote_table_name(select_query_ast.from_table_name)}"
 
         if select_query_ast.join_clauses.empty?
           # Ignore filter option, because bulk delete is for cleaning before import,
@@ -264,7 +272,7 @@ module Exwiw
           column_pg_type(inner_table, inner_column)
         ) ? 'text' : nil
         subquery_sql = compile_ast(subquery_ast, select_cast_to: cast_to)
-        outer_expr = "#{outer_table}.#{foreign_key}"
+        outer_expr = qualified_name(outer_table, foreign_key)
         outer_expr = "#{outer_expr}::text" if cast_to
         sql += "\nWHERE #{outer_expr} IN (#{subquery_sql})"
 
@@ -295,17 +303,17 @@ module Exwiw
         sql += if query_ast.select_all
                  # A lifted scope JOIN brings a derived table into FROM, so a bare
                  # `*` would also project its column. Qualify to this table's own.
-                 scope_clauses.any? ? "#{query_ast.from_table_name}.*" : "*"
+                 scope_clauses.any? ? "#{quote_table_name(query_ast.from_table_name)}.*" : "*"
                else
                  cols = query_ast.columns.map { |col| compile_column_name(query_ast, col) }
                  cols = cols.map { |c| "#{c}::#{select_cast_to}" } if select_cast_to
                  cols.join(', ')
                end
-        sql += " FROM #{query_ast.from_table_name}"
+        sql += " FROM #{quote_table_name(query_ast.from_table_name)}"
 
         query_ast.join_clauses.each do |join|
-          fk_expr = "#{join.base_table_name}.#{join.foreign_key}"
-          pk_expr = "#{join.join_table_name}.#{join.primary_key}"
+          fk_expr = qualified_name(join.base_table_name, join.foreign_key)
+          pk_expr = qualified_name(join.join_table_name, join.primary_key)
           if types_need_cast?(
             column_pg_type(join.base_table_name, join.foreign_key),
             column_pg_type(join.join_table_name, join.primary_key)
@@ -313,7 +321,7 @@ module Exwiw
             fk_expr = "#{fk_expr}::text"
             pk_expr = "#{pk_expr}::text"
           end
-          sql += " JOIN #{join.join_table_name} ON #{fk_expr} = #{pk_expr}"
+          sql += " JOIN #{quote_table_name(join.join_table_name)} ON #{fk_expr} = #{pk_expr}"
 
           join.where_clauses.each do |where|
             compiled_where_condition = compile_where_condition(where, join.join_table_name)
@@ -354,13 +362,13 @@ module Exwiw
       # outer key is cast to match.
       private def compile_scope_join(from_table_name, where_clause, idx)
         subquery = where_clause.value
-        projection = subquery_projection_name(subquery)
+        projection = quote_identifier(subquery_projection_name(subquery))
         src_alias = "exwiw_scope_src_#{idx}"
         ids_alias = "exwiw_scope_ids_#{idx}"
 
         inner_sql = compile_subquery(subquery, outer_table: from_table_name, outer_column: where_clause.column_name)
         cast_to = subquery_cast_to(subquery, from_table_name, where_clause.column_name)
-        outer_key = "#{from_table_name}.#{where_clause.column_name}"
+        outer_key = qualified_name(from_table_name, where_clause.column_name)
         outer_key = "#{outer_key}::#{cast_to}" if cast_to
 
         "JOIN (SELECT DISTINCT #{src_alias}.#{projection} AS exwiw_scope_id " \
@@ -372,7 +380,7 @@ module Exwiw
         # Use as it is if it's a raw query
         return where_clause if where_clause.is_a?(String)
 
-        key = "#{table_name}.#{where_clause.column_name}"
+        key = qualified_name(table_name, where_clause.column_name)
 
         if where_clause.operator == :eq
           values = where_clause.value.map { |v| escape_value(v) }
@@ -411,11 +419,11 @@ module Exwiw
         end
 
         inner_values = subquery.where_values.map { |v| escape_value(v) }
-        select_expr = "#{subquery.table_name}.#{subquery.select_column}"
+        select_expr = qualified_name(subquery.table_name, subquery.select_column)
         select_expr = "#{select_expr}::#{cast_to}" if cast_to
         "SELECT #{select_expr} " \
-          "FROM #{subquery.table_name} " \
-          "WHERE #{subquery.table_name}.#{subquery.where_column} IN (#{inner_values.join(', ')})"
+          "FROM #{quote_table_name(subquery.table_name)} " \
+          "WHERE #{qualified_name(subquery.table_name, subquery.where_column)} IN (#{inner_values.join(', ')})"
       end
 
       private def subquery_select_target(subquery)
@@ -498,14 +506,14 @@ module Exwiw
       private def compile_column_name(ast, column)
         case column
         when Exwiw::QueryAst::ColumnValue::Plain
-          "#{ast.from_table_name}.#{column.name}"
+          qualified_name(ast.from_table_name, column.name)
         when Exwiw::QueryAst::ColumnValue::RawSql
           column.value
         when Exwiw::QueryAst::ColumnValue::ReplaceWith
           parts = column.value.scan(/[^{}]+|\{[^{}]*\}/).map do |part|
             if part.start_with?('{')
               name = part[1..-2]
-              "#{ast.from_table_name}.#{name}"
+              qualified_name(ast.from_table_name, name)
             else
               "'#{part}'"
             end

data/lib/exwiw/adapter/sqlite_adapter.rb

@@ -3,6 +3,7 @@
 module Exwiw
   module Adapter
     class SqliteAdapter < Base
+      include IdentifierQuoting::Sqlite
       include SqlBulkInsert
 
       # A lazy, streaming stand-in for the materialized rows #execute used to
@@ -122,15 +123,16 @@ module Exwiw
         stmt.end_with?(';') ? stmt : "#{stmt};"
       end
 
-      # The INSERT header for this adapter. SQLite uses bare identifiers.
+      # The INSERT header for this adapter. SQLite uses bare identifiers,
+      # quoted only when required (reserved word / unsafe characters).
       # #to_bulk_insert / #write_inserts (SqlBulkInsert) append the value tuples
       # and the trailing `;`.
       private def insert_header(table)
-        table_name = table.name
+        table_name = quote_table_name(table.name)
         if table.rails_managed?
           "INSERT INTO #{table_name} VALUES\n"
         else
-          column_names = table.columns.map(&:name).join(', ')
+          column_names = table.columns.map { |c| quote_identifier(c.name) }.join(', ')
           "INSERT INTO #{table_name} (#{column_names}) VALUES\n"
         end
       end
@@ -138,7 +140,7 @@ module Exwiw
       def to_bulk_delete(select_query_ast, table)
         raise NotImplementedError unless select_query_ast.is_a?(Exwiw::QueryAst::Select)
 
-        sql = "DELETE FROM #{select_query_ast.from_table_name}"
+        sql = "DELETE FROM #{quote_table_name(select_query_ast.from_table_name)}"
 
         if select_query_ast.join_clauses.empty?
           # Ignore filter option, because bulk delete is for cleaning before import,
@@ -176,7 +178,7 @@ module Exwiw
 
         foreign_key = first_join.foreign_key
         subquery_sql = compile_ast(subquery_ast)
-        sql += "\nWHERE #{select_query_ast.from_table_name}.#{foreign_key} IN (#{subquery_sql})"
+        sql += "\nWHERE #{qualified_name(select_query_ast.from_table_name, foreign_key)} IN (#{subquery_sql})"
 
         # first_join.base_where_clauses holds conditions on the outer
         # delete-target table (from_table_name), such as a polymorphic type
@@ -211,14 +213,14 @@ module Exwiw
                elsif query_ast.select_all
                  # A lifted scope JOIN brings a derived table into FROM, so a bare
                  # `*` would also project its column. Qualify to this table's own.
-                 scope_clauses.any? ? "#{query_ast.from_table_name}.*" : "*"
+                 scope_clauses.any? ? "#{quote_table_name(query_ast.from_table_name)}.*" : "*"
                else
                  query_ast.columns.map { |col| compile_column_name(query_ast, col) }.join(', ')
                end
-        sql += " FROM #{query_ast.from_table_name}"
+        sql += " FROM #{quote_table_name(query_ast.from_table_name)}"
 
         query_ast.join_clauses.each do |join|
-          sql += " JOIN #{join.join_table_name} ON #{join.base_table_name}.#{join.foreign_key} = #{join.join_table_name}.#{join.primary_key}"
+          sql += " JOIN #{quote_table_name(join.join_table_name)} ON #{qualified_name(join.base_table_name, join.foreign_key)} = #{qualified_name(join.join_table_name, join.primary_key)}"
 
           join.where_clauses.each do |where|
             compiled_where_condition = compile_where_condition(where, join.join_table_name)
@@ -254,10 +256,10 @@ module Exwiw
       # `<col> IN (subquery)`.
       private def compile_scope_join(from_table_name, where_clause, idx)
         subquery = where_clause.value
-        projection = subquery_projection_name(subquery)
+        projection = quote_identifier(subquery_projection_name(subquery))
         src_alias = "exwiw_scope_src_#{idx}"
         ids_alias = "exwiw_scope_ids_#{idx}"
-        outer_key = "#{from_table_name}.#{where_clause.column_name}"
+        outer_key = qualified_name(from_table_name, where_clause.column_name)
 
         "JOIN (SELECT DISTINCT #{src_alias}.#{projection} AS exwiw_scope_id " \
           "FROM (#{compile_subquery(subquery)}) AS #{src_alias}) AS #{ids_alias} " \
@@ -268,7 +270,7 @@ module Exwiw
         # Use as it is if it's a raw query
         return where_clause if where_clause.is_a?(String)
 
-        key = "#{table_name}.#{where_clause.column_name}"
+        key = qualified_name(table_name, where_clause.column_name)
 
         if where_clause.operator == :eq
           values = where_clause.value.map { |v| escape_value(v) }
@@ -299,9 +301,9 @@ module Exwiw
         end
 
         inner_values = subquery.where_values.map { |v| escape_value(v) }
-        "SELECT #{subquery.table_name}.#{subquery.select_column} " \
-          "FROM #{subquery.table_name} " \
-          "WHERE #{subquery.table_name}.#{subquery.where_column} IN (#{inner_values.join(', ')})"
+        "SELECT #{qualified_name(subquery.table_name, subquery.select_column)} " \
+          "FROM #{quote_table_name(subquery.table_name)} " \
+          "WHERE #{qualified_name(subquery.table_name, subquery.where_column)} IN (#{inner_values.join(', ')})"
       end
 
       private def escape_value(value)
@@ -323,14 +325,14 @@ module Exwiw
       private def compile_column_name(ast, column)
         case column
         when Exwiw::QueryAst::ColumnValue::Plain
-          "#{ast.from_table_name}.#{column.name}"
+          qualified_name(ast.from_table_name, column.name)
         when Exwiw::QueryAst::ColumnValue::RawSql
           column.value
         when Exwiw::QueryAst::ColumnValue::ReplaceWith
           parts = column.value.scan(/[^{}]+|\{[^{}]*\}/).map do |part|
             if part.start_with?('{')
               name = part[1..-2]
-              "#{ast.from_table_name}.#{name}"
+              qualified_name(ast.from_table_name, name)
             else
               "'#{part}'"
             end

data/lib/exwiw/adapter.rb

@@ -33,6 +33,12 @@ module Exwiw
     end
 
     class Base
+      # Gives every adapter #qualified_name & co. so shared helpers below
+      # (#null_preserving) can use them; the quote-char/reserved-word hooks
+      # raise NotImplementedError until a SQL adapter includes its
+      # IdentifierQuoting dialect submodule (Mysql / Postgresql / Sqlite).
+      include IdentifierQuoting
+
       attr_reader :connection_config
 
       def initialize(connection_config, logger)
@@ -249,10 +255,11 @@ module Exwiw
       # column itself (`column.name`) — not any other column the template may
       # reference — so only true NULL is preserved; an empty string is a real
       # value and is still masked. The column reference uses the same
-      # `<from_table>.<col>` form as the Plain branch. Shared by the SQL
+      # `<from_table>.<col>` form as the Plain branch (qualified_name comes
+      # from IdentifierQuoting, included in Base). Shared by the SQL
       # adapters' #compile_column_name ReplaceWith handling.
       private def null_preserving(ast, column, masked_expr)
-        "CASE WHEN #{ast.from_table_name}.#{column.name} IS NOT NULL THEN #{masked_expr} ELSE NULL END"
+        "CASE WHEN #{qualified_name(ast.from_table_name, column.name)} IS NOT NULL THEN #{masked_expr} ELSE NULL END"
       end
 
       # Split an outer query's WHERE clauses into the scope id-set clauses to

data/lib/exwiw/ddl_postprocessor.rb

@@ -86,12 +86,18 @@ module Exwiw
     # A bare `CREATE EXTENSION ...;` (as a full-database pg_dump emits, unlike a
     # `--table` dump, which omits extensions) has no graceful skip: a restore
     # target that cannot create the extension aborts the whole restore. Wrap
-    # each in a DO block that catches only the two "cannot provide it here"
-    # cases — feature_not_supported (0A000, binaries absent) and
-    # invalid_schema_name (3F000, required schema absent) — and re-raises them
-    # as a WARNING so the skip surfaces in the restore logs. insufficient_
-    # privilege (42501) is deliberately NOT caught: a restore role lacking
-    # CREATE privilege is a misconfiguration to fix, not to skip silently.
+    # each in a DO block that catches only the "cannot provide it here" cases and
+    # re-raises them as a WARNING so the skip surfaces in the restore logs:
+    #   - feature_not_supported (0A000, binaries absent)
+    #   - invalid_schema_name (3F000, required schema absent)
+    #   - internal_error (XX000): an extension that must be preloaded via
+    #     shared_preload_libraries raises a bare `elog(ERROR, "<name> is not in
+    #     shared_preload_libraries")` (default SQLSTATE XX000) when it is not
+    #     preloaded on the target — e.g. pglogical restored into a plain RDS. Like
+    #     the other two, this is the target being unable to provide the extension,
+    #     not a broken dump, so the restore should skip it rather than abort.
+    # insufficient_privilege (42501) is deliberately NOT caught: a restore role
+    # lacking CREATE privilege is a misconfiguration to fix, not to skip silently.
     CREATE_EXTENSION_RE = /^[ \t]*CREATE\s+EXTENSION\b(?:\s+IF\s+NOT\s+EXISTS)?\s+(?<name>"[^"]+"|[^\s;]+)[^;]*;/i.freeze
 
     def wrap_create_extension_in_do_block(sql)
@@ -101,7 +107,7 @@ module Exwiw
         warning = "exwiw: skipped CREATE EXTENSION #{extname} (SQLSTATE %): %"
         warning_literal = "'#{warning.gsub("'", "''")}'"
         "DO $$ BEGIN #{stmt} " \
-          "EXCEPTION WHEN feature_not_supported OR invalid_schema_name THEN " \
+          "EXCEPTION WHEN feature_not_supported OR invalid_schema_name OR internal_error THEN " \
           "RAISE WARNING #{warning_literal}, SQLSTATE, SQLERRM; END $$;"
       end
     end

data/lib/exwiw/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Exwiw
-  VERSION = "0.9.9"
+  VERSION = "0.9.11"
 end

data/lib/exwiw.rb

@@ -17,6 +17,7 @@ require_relative "exwiw/embedded_in"
 require_relative "exwiw/mongodb_field"
 require_relative "exwiw/mongodb_collection_config"
 require_relative "exwiw/ddl_postprocessor"
+require_relative "exwiw/adapter/identifier_quoting"
 require_relative "exwiw/adapter"
 require_relative "exwiw/adapter/sql_bulk_insert"
 require_relative "exwiw/adapter/sqlite_adapter"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: exwiw
 version: !ruby/object:Gem::Version
-  version: 0.9.9
+  version: 0.9.11
 platform: ruby
 authors:
 - Shia
@@ -55,6 +55,7 @@ files:
 - ext/exwiw/ext_json/extconf.rb
 - lib/exwiw.rb
 - lib/exwiw/adapter.rb
+- lib/exwiw/adapter/identifier_quoting.rb
 - lib/exwiw/adapter/mongodb_adapter.rb
 - lib/exwiw/adapter/mysql_adapter.rb
 - lib/exwiw/adapter/mysql_client.rb