exwiw 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e62483afc43054ae026c232502f40f6c1a92381a9c2c833ef1f7d603f6b845ae
-  data.tar.gz: 660a006272b9156bbc98af2a0c288f7943bdd40523adffc45de713b36a5d0426
+  metadata.gz: 83bb3c7245d9174e5d16e85e6de2a530b58ca445b570d692c5198682fc43b9ef
+  data.tar.gz: cee17f919dab949c82942eae146a1d6182909ab6ef595e8cfc7d4c3f744d1ede
 SHA512:
-  metadata.gz: 988813923c5e8a2aa1fd499c3af3a2d5467fc9a77b60664b1cd8d245ed1837a1cf43dc88a872bbbcfb7951902624e6b61fb50d290af6716a06c1fe8bb376ae6a
-  data.tar.gz: d8f751b794c20658c643ab2aeca769b01f7b50e9acc46c9605a4d7121d0d5fa8041bfbdad8021ede6bbfefc8cb36a937509120f25b7bdd059aaf6989f4c94e00
+  metadata.gz: d655b0e5d55759932d7ab6646cb9ed9d0b699e6c96e6061863091eded7914c736b74c558e8a96d132ea94ef668376ae372a9eacf23f978d52540bf31c38c7c18
+  data.tar.gz: 5e068572f70d2b1869e5dffceba9f681d0b153c0947da3fd7b35d746e7f33bbc6c2d5fa25d23c9dfa0f190e14d3304ec6f2940aa19168749aa05b303c572ea10

data/CHANGELOG.md

@@ -2,13 +2,29 @@
 
 ## [Unreleased]
 
+## [0.3.2] - 2026-05-31
+
+### Changed
+
+- Adapter names are now driver-agnostic: `--adapter=mysql` and `--adapter=sqlite` replace the driver-flavored `mysql2` / `sqlite3` as the canonical names (`postgresql` and `mongodb` are unchanged). The CLI stays backward compatible — `mysql2` and `sqlite3` are accepted as aliases and folded onto the canonical name, and the matching is case-insensitive so a Rails app's `connection.adapter_name` (e.g. `Mysql2`, `SQLite`) is absorbed too. There is intentionally no `trilogy` adapter *name*: the MySQL adapter now connects through whichever of the `mysql2` or `trilogy` gem is installed (preferring `mysql2`), so an app on either driver works by passing `--adapter=mysql`. trilogy's typed result values are normalized back to the same raw strings `mysql2`'s `cast: false` returns, so the generated SQL is identical regardless of driver. **Breaking** only for code using the library classes directly: `Exwiw::Adapter::Mysql2Adapter` → `Exwiw::Adapter::MysqlAdapter` and `Exwiw::Adapter::Sqlite3Adapter` → `Exwiw::Adapter::SqliteAdapter`. The `EXWIW_DATABASE_ADAPTER` value passed to `--after-insert-hook` is now the canonical name (`mysql` / `sqlite`).
+
+## [0.3.1] - 2026-05-31
+
+### Changed
+
+- **Breaking:** the `dump` subcommand is renamed to `export` to match the gem name (Export What I Want). Invoke `exwiw export ...` (or omit the subcommand, which now defaults to `export`) instead of `exwiw dump ...`. There is no `dump` alias.
+
 ## [0.3.0] - 2026-05-31
 
+### Added
+
+- New `--ids-column=COLUMN` CLI option matches `--ids` against an arbitrary column on the target table instead of its primary key (e.g. `--target-table=users --ids=alice@example.com --ids-column=email`). This is the SQL-adapter (mysql2/postgresql/sqlite3) counterpart of the mongodb `--ids-field`; the two are mutually exclusive and each is rejected by the other adapter family (`--ids-field` is mongodb-only, `--ids-column` is sql-only), mirroring the existing `--target-table` / `--target-collection` split. Related tables are still extracted correctly: rather than propagating `--ids` directly onto foreign keys (which would be wrong when filtering on a non-primary-key column), each foreign key is resolved through the target via a subquery (`WHERE fk IN (SELECT pk FROM target WHERE COLUMN IN (...))`), so only the target table's filter column changes and direct / indirect / polymorphic relations all extract correctly. Note: if `COLUMN` is itself masked, re-running `delete-*` against an already-imported (masked) dump won't match, so prefer a stable natural key. ([#47](https://github.com/heyinc/exwiw/pull/47))
+
 ## [0.2.9] - 2026-05-31
 
 ### Added
 
-- New `--ids-field=FIELD` CLI option matches `--ids` against an arbitrary field on the target collection instead of its primary key (e.g. `--target-collection=users --ids=a@example.com --ids-field=email`). Only the target collection's filter changes — downstream foreign-key propagation still keys off the primary key. Unlike the primary-key path, the supplied ids are **not** type-coerced (a custom field's stored type is unknown, so values are passed through as-is). Currently **mongodb-only**: the SQL adapters (mysql2/postgresql/sqlite3) reject the flag at validation time, and threading `ids_field` through `QueryAstBuilder` for them is left as a TODO.
+- New `--ids-field=FIELD` CLI option matches `--ids` against an arbitrary field on the target collection instead of its primary key (e.g. `--target-collection=users --ids=a@example.com --ids-field=email`). Only the target collection's filter changes — downstream foreign-key propagation still keys off the primary key. Unlike the primary-key path, the supplied ids are **not** type-coerced (a custom field's stored type is unknown, so values are passed through as-is). This flag is **mongodb-only**.
 - New `--target-collection=COLLECTION` CLI option, a mongodb-only alias of `--target-table`. Specifying both, or using `--target-collection` with a non-mongodb adapter, is rejected at validation time.
 - New rake task `exwiw:schema:generate_mongoid` (backed by `Exwiw::MongoidSchemaGenerator`) generates `MongodbCollectionConfig` files by introspecting Mongoid document models — a separate task/class from the ActiveRecord `schema:generate` because the ORMs expose different metadata. It derives the collection name, the `_id` primary key, `fields` (including referenced `belongs_to` foreign keys), `belongs_tos` from referenced `belongs_to` associations, and `embedded_in` from `embedded_in` / `embeds_many` / `embeds_one` associations (each embedded config names its immediate parent collection and `store_as` document key; nested embedding is emitted as a chain — `comments` embedded_in `posts`, `posts` embedded_in `users` — so the adapter can recurse through both array and Hash subdocuments). Regeneration preserves hand-edited `replace_with` / `filter` / `skip` / `bulk_insert_chunk_size`. Polymorphic `belongs_to` is not yet expanded. Models in an inheritance hierarchy whose subclasses share the base's collection (Mongoid STI, `_type` discriminator) collapse into a single config: subclasses are discovered via `descendants` (Mongoid registers only the base in `Mongoid.models`) and every class's `fields` / `belongs_tos` are unioned, so subclass-only fields and associations are preserved. A referenced `belongs_to` declared on an *embedded* document (e.g. `Comment embedded_in :post, belongs_to :author`) is dropped from the embedded config's `belongs_tos` (cross-collection refs from inside embedded subdocuments are unsupported and rejected on load), while its foreign-key column is still kept as an ordinary field. A `has_and_belongs_to_many` association is likewise dropped from `belongs_tos` (its foreign keys are stored as an array field such as `tag_ids`, which exwiw cannot follow as a single-valued foreign key), while that `*_ids` array column is kept as an ordinary field. A *polymorphic* `embedded_in` (`embedded_in :addressable, polymorphic: true`) has no single embedding parent collection and cannot be expressed as an `embedded_in` config, so the generator raises a clear, actionable error rather than crashing on the unresolvable parent class. A *self-referential / cyclic* embedding (Mongoid's `recursively_embeds_many` / `recursively_embeds_one`) makes a collection both top-level and embedded inside documents of its own type; since exwiw represents a collection as either top-level or embedded (not both), the generator likewise raises a clear error rather than emit an `embedded_in` config that would silently make the collection undumpable. The `created_at` / `updated_at` columns added by `include Mongoid::Timestamps` are tracked as ordinary fields, and their BSON `ObjectId` / `Date` values (the shape a live `find` returns) serialize as MongoDB Extended JSON (`$oid` / `$date`) through the dump path — now covered end-to-end against the generated configs. An aliased field (`field :ctry, as: :country`) is emitted by its **stored** document key (`ctry`), never the Ruby accessor (`country`), so masking and projection target the key that actually appears in the document; the accessor is additionally surfaced as `mongoid_field_name` on that field so the otherwise cryptic short key stays understandable (association aliases such as `shop => shop_id` and the built-in `id => _id` are not field renames and are not annotated).
 

data/README.md

@@ -37,25 +37,41 @@ gem install exwiw
 
 ## Supported Databases
 
-- mysql2
+- mysql
 - postgresql
-- sqlite3
+- sqlite
 - mongodb (experimental, see [MongoDB notes](#mongodb-notes))
 
+Adapter names are driver-agnostic — they name the database, not the Ruby driver
+or Rails ActiveRecord adapter. For backward compatibility and to absorb the Rails
+adapter spelling, the following aliases are also accepted (case-insensitive):
+
+| `--adapter` value | Aliases accepted |
+| --- | --- |
+| `mysql` | `mysql2` |
+| `sqlite` | `sqlite3` |
+
+So `--adapter=mysql2` and `--adapter=mysql` both select the same MySQL adapter.
+
+For MySQL, exwiw connects through whichever of the `mysql2` or `trilogy` gem is
+available (preferring `mysql2`), so an app on either driver works without any
+extra setup. There is no separate `trilogy` adapter name — pass `--adapter=mysql`
+either way.
+
 ## Usage
 
 exwiw has two subcommands:
 
-- `dump` (default) — generate INSERT/COPY SQL files. This is the existing behavior; if the subcommand is omitted, `dump` is assumed for backwards compatibility.
-- `explain` — print the compiled SQL and its `EXPLAIN` output for each query that `dump` would run, without executing the SELECTs.
+- `export` (default) — generate INSERT/COPY SQL files. If the subcommand is omitted, `export` is assumed.
+- `explain` — print the compiled SQL and its `EXPLAIN` output for each query that `export` would run, without executing the SELECTs.
 
-### `exwiw dump`
+### `exwiw export`
 
 ```bash
 # dump & masking all records from database to dump.sql based on schema.json
 # pass database password as an environment variable 'DATABASE_PASSWORD'
 exwiw \
-  --adapter=mysql2 \
+  --adapter=mysql \
   --host=localhost \
   --port=3306 \
   --user=reader \
@@ -92,7 +108,7 @@ This command will generate sql files in the `dump` directory.
 idx means the order of the dump. bigger idx might depend on smaller idx,
 so you should import the dump in order.
 
-`insert-000-schema.sql` is generated by shelling out to the database client tools (`mysqldump` for `mysql2`, `pg_dump` for `postgresql`, and the sqlite3 driver for `sqlite3`), so the corresponding client must be available on PATH when running exwiw. The output is post-processed to make it idempotent: `CREATE TABLE IF NOT EXISTS`, `CREATE INDEX IF NOT EXISTS` (where the engine supports it), and PostgreSQL's `ALTER TABLE ... ADD CONSTRAINT` statements are wrapped in `DO $$ ... EXCEPTION WHEN duplicate_object`.
+`insert-000-schema.sql` is generated by shelling out to the database client tools (`mysqldump` for `mysql`, `pg_dump` for `postgresql`, and the sqlite3 driver for `sqlite`), so the corresponding client must be available on PATH when running exwiw. The output is post-processed to make it idempotent: `CREATE TABLE IF NOT EXISTS`, `CREATE INDEX IF NOT EXISTS` (where the engine supports it), and PostgreSQL's `ALTER TABLE ... ADD CONSTRAINT` statements are wrapped in `DO $$ ... EXCEPTION WHEN duplicate_object`.
 
 you need to delete the records before importing the dump,
 `delete-{idx}-{table_name}.sql` will help you to do that.
@@ -101,7 +117,7 @@ idx meaning is the same as insert sql.
 
 ### `exwiw explain`
 
-Print the compiled SQL and its `EXPLAIN` output (estimate-only; `EXPLAIN QUERY PLAN` on SQLite) for each query that `dump` would run, to stdout. No SELECT is executed. Supported for `mysql2`, `postgresql`, and `sqlite3`. The `mongodb` adapter is not yet supported.
+Print the compiled SQL and its `EXPLAIN` output (estimate-only; `EXPLAIN QUERY PLAN` on SQLite) for each query that `export` would run, to stdout. No SELECT is executed. Supported for `mysql`, `postgresql`, and `sqlite`. The `mongodb` adapter is not yet supported.
 
 ```bash
 # preview the queries exwiw would run, without executing the SELECTs

data/lib/exwiw/adapter/{mysql2_adapter.rb → mysql_adapter.rb}

@@ -2,7 +2,7 @@
 
 module Exwiw
   module Adapter
-    class Mysql2Adapter < Base
+    class MysqlAdapter < Base
       def build_query(table, dump_target, table_by_name)
         Exwiw::QueryAstBuilder.run(table.name, table_by_name, dump_target, @logger)
       end
@@ -11,17 +11,17 @@ module Exwiw
         sql = commented_sql(query_ast)
 
         @logger.debug("  Executing SQL: \n#{sql}")
-        connection.query(sql, cast: false, as: :array).to_a
+        connection.query(sql).rows
       end
 
       def explain(query_ast)
         sql = commented_sql(query_ast)
 
         @logger.debug("  Executing EXPLAIN: \n#{sql}")
-        rows = connection.query("EXPLAIN #{sql}", cast: false).to_a
-        rows.each_with_index.flat_map do |row, i|
+        result = connection.query("EXPLAIN #{sql}")
+        result.rows.each_with_index.flat_map do |row, i|
           ["*************************** #{i + 1}. row ***************************"] +
-            row.map { |k, v| "#{k}: #{v}" }
+            result.fields.zip(row).map { |k, v| "#{k}: #{v}" }
         end.join("\n")
       end
 
@@ -138,10 +138,11 @@ module Exwiw
         subquery_sql = compile_ast(subquery_ast)
         sql += "\nWHERE #{select_query_ast.from_table_name}.#{foreign_key} IN (#{subquery_sql})"
 
-        # first_join.base_where_clauses は外側の削除対象テーブル
-        # (from_table_name) 上の条件 (polymorphic 型カラム等)。subquery には
-        # 含まれないため、外側の WHERE に追加する。これにより、別の
-        # polymorphic 型に属する行まで削除してしまうのを防ぐ。
+        # first_join.base_where_clauses holds conditions on the outer
+        # delete-target table (from_table_name), such as a polymorphic type
+        # column. They are not part of the subquery, so add them to the outer
+        # WHERE. This prevents deleting rows that belong to a different
+        # polymorphic type.
         first_join.base_where_clauses.each do |where|
           next unless where.is_a?(Exwiw::QueryAst::WhereClause)
 
@@ -171,8 +172,9 @@ module Exwiw
             sql += " AND #{compiled_where_condition}"
           end
 
-          # base_where_clauses は結合元テーブル (base_table_name) に対して
-          # コンパイルする。polymorphic な結合元テーブルの型カラム絞り込み等。
+          # base_where_clauses is compiled against the joined-from table
+          # (base_table_name), e.g. the type-column filter on a polymorphic
+          # source table.
           join.base_where_clauses.each do |where|
             compiled_where_condition = compile_where_condition(where, join.base_table_name)
             sql += " AND #{compiled_where_condition}"
@@ -255,17 +257,7 @@ module Exwiw
       end
 
       private def connection
-        @connection ||=
-          begin
-            require 'mysql2'
-            Mysql2::Client.new(
-              host: @connection_config.host,
-              port: @connection_config.port,
-              username: @connection_config.user,
-              password: @connection_config.password,
-              database: @connection_config.database_name
-            )
-          end
+        @connection ||= MysqlClient.new(@connection_config)
       end
     end
   end

data/lib/exwiw/adapter/mysql_client.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Exwiw
+  module Adapter
+    # Thin wrapper over the MySQL driver so MysqlAdapter does not care whether the
+    # host app ships the `mysql2` gem or the `trilogy` gem. exwiw only runs simple
+    # SELECT / EXPLAIN queries, so both drivers are normalized to the same shape:
+    # rows as arrays of String|nil plus the column names.
+    #
+    # Values are normalized to strings to match mysql2's `cast: false` mode, where
+    # every column comes back as a raw string and is quoted uniformly downstream
+    # (see MysqlAdapter#escape_value). mysql2 already returns strings in that mode;
+    # trilogy always casts to Ruby types (Integer / BigDecimal / Time / Date / ...),
+    # so its values are stringified back into the same literal form here.
+    class MysqlClient
+      # Immutable value object: a query's column names and its rows.
+      Result = Data.define(:fields, :rows)
+
+      # Pick the available driver, preferring mysql2 (exwiw's historical default).
+      # require returns false when already loaded, so this is safe to call repeatedly.
+      def self.detect_driver
+        require 'mysql2'
+        :mysql2
+      rescue LoadError
+        begin
+          require 'trilogy'
+          :trilogy
+        rescue LoadError
+          raise LoadError,
+                "exwiw needs the 'mysql2' or 'trilogy' gem to connect to MySQL. " \
+                "Add `gem \"mysql2\"` (or `gem \"trilogy\"`) to your Gemfile."
+        end
+      end
+
+      # Render a driver-returned value as the raw string mysql2's `cast: false`
+      # would have produced, so trilogy's typed values quote identically.
+      def self.stringify_value(value)
+        case value
+        when nil then nil
+        when String then value
+        when Time
+          # Emit fractional seconds only when present. A Time can't tell us the
+          # column's declared precision, so a zero fraction on a DATETIME(6)
+          # column comes out as "...:00" here whereas mysql2's `cast: false`
+          # echoes the raw "...:00.000000"; both re-insert to the same instant.
+          value.nsec.zero? ? value.strftime('%Y-%m-%d %H:%M:%S') : value.strftime('%Y-%m-%d %H:%M:%S.%6N')
+        when Date then value.strftime('%Y-%m-%d')
+        when true then '1'
+        when false then '0'
+        else
+          if defined?(BigDecimal) && value.is_a?(BigDecimal)
+            value.to_s('F')
+          else
+            value.to_s
+          end
+        end
+      end
+
+      attr_reader :driver
+
+      # `driver:` is mainly a test seam to force a specific driver; in normal use
+      # it is auto-detected.
+      def initialize(connection_config, driver: nil)
+        @connection_config = connection_config
+        @driver = (driver || self.class.detect_driver).to_sym
+        ensure_driver_loaded!
+      end
+
+      # @param sql [String]
+      # @return [Result] fields (Array<String>) and rows (Array<Array<String|nil>>)
+      def query(sql)
+        case @driver
+        when :mysql2
+          res = raw.query(sql, cast: false, as: :array)
+          Result.new(res.fields, res.to_a)
+        when :trilogy
+          res = raw.query(sql)
+          rows = res.rows.map { |row| row.map { |value| self.class.stringify_value(value) } }
+          Result.new(res.fields, rows)
+        else
+          raise "Unsupported MySQL driver: #{@driver.inspect}"
+        end
+      end
+
+      private def ensure_driver_loaded!
+        case @driver
+        when :mysql2 then require 'mysql2'
+        when :trilogy then require 'trilogy'
+        else raise "Unsupported MySQL driver: #{@driver.inspect}"
+        end
+      end
+
+      private def raw
+        @raw ||= build_raw
+      end
+
+      private def build_raw
+        options = {
+          host: @connection_config.host,
+          port: @connection_config.port&.to_i,
+          username: @connection_config.user,
+          password: @connection_config.password,
+          database: @connection_config.database_name,
+        }.compact
+
+        case @driver
+        when :mysql2 then Mysql2::Client.new(options)
+        when :trilogy then Trilogy.new(options)
+        end
+      end
+    end
+  end
+end

data/lib/exwiw/adapter/postgresql_adapter.rb

@@ -180,10 +180,11 @@ module Exwiw
         subquery_sql = compile_ast(subquery_ast)
         sql += "\nWHERE #{select_query_ast.from_table_name}.#{foreign_key} IN (#{subquery_sql})"
 
-        # first_join.base_where_clauses は外側の削除対象テーブル
-        # (from_table_name) 上の条件 (polymorphic 型カラム等)。subquery には
-        # 含まれないため、外側の WHERE に追加する。これにより、別の
-        # polymorphic 型に属する行まで削除してしまうのを防ぐ。
+        # first_join.base_where_clauses holds conditions on the outer
+        # delete-target table (from_table_name), such as a polymorphic type
+        # column. They are not part of the subquery, so add them to the outer
+        # WHERE. This prevents deleting rows that belong to a different
+        # polymorphic type.
         first_join.base_where_clauses.each do |where|
           next unless where.is_a?(Exwiw::QueryAst::WhereClause)
 
@@ -213,8 +214,9 @@ module Exwiw
             sql += " AND #{compiled_where_condition}"
           end
 
-          # base_where_clauses は結合元テーブル (base_table_name) に対して
-          # コンパイルする。polymorphic な結合元テーブルの型カラム絞り込み等。
+          # base_where_clauses is compiled against the joined-from table
+          # (base_table_name), e.g. the type-column filter on a polymorphic
+          # source table.
           join.base_where_clauses.each do |where|
             compiled_where_condition = compile_where_condition(where, join.base_table_name)
             sql += " AND #{compiled_where_condition}"

data/lib/exwiw/adapter/{sqlite3_adapter.rb → sqlite_adapter.rb}

@@ -2,7 +2,7 @@
 
 module Exwiw
   module Adapter
-    class Sqlite3Adapter < Base
+    class SqliteAdapter < Base
       def build_query(table, dump_target, table_by_name)
         Exwiw::QueryAstBuilder.run(table.name, table_by_name, dump_target, @logger)
       end
@@ -53,7 +53,7 @@ module Exwiw
         end
 
         File.open(output_path, 'w') do |file|
-          file.puts("-- Auto-generated by exwiw. Idempotent CREATE statements for sqlite3.")
+          file.puts("-- Auto-generated by exwiw. Idempotent CREATE statements for SQLite.")
           file.puts(statements.join("\n"))
         end
         @logger.info("  Wrote #{statements.size} schema statement(s) to #{output_path}.")
@@ -125,10 +125,11 @@ module Exwiw
         subquery_sql = compile_ast(subquery_ast)
         sql += "\nWHERE #{select_query_ast.from_table_name}.#{foreign_key} IN (#{subquery_sql})"
 
-        # first_join.base_where_clauses は外側の削除対象テーブル
-        # (from_table_name) 上の条件 (polymorphic 型カラム等)。subquery には
-        # 含まれないため、外側の WHERE に追加する。これにより、別の
-        # polymorphic 型に属する行まで削除してしまうのを防ぐ。
+        # first_join.base_where_clauses holds conditions on the outer
+        # delete-target table (from_table_name), such as a polymorphic type
+        # column. They are not part of the subquery, so add them to the outer
+        # WHERE. This prevents deleting rows that belong to a different
+        # polymorphic type.
         first_join.base_where_clauses.each do |where|
           next unless where.is_a?(Exwiw::QueryAst::WhereClause)
 
@@ -158,8 +159,9 @@ module Exwiw
             sql += " AND #{compiled_where_condition}"
           end
 
-          # base_where_clauses は結合元テーブル (base_table_name) に対して
-          # コンパイルする。polymorphic な結合元テーブルの型カラム絞り込み等。
+          # base_where_clauses is compiled against the joined-from table
+          # (base_table_name), e.g. the type-column filter on a polymorphic
+          # source table.
           join.base_where_clauses.each do |where|
             compiled_where_condition = compile_where_condition(where, join.base_table_name)
             sql += " AND #{compiled_where_condition}"

data/lib/exwiw/adapter.rb

@@ -2,6 +2,36 @@
 
 module Exwiw
   module Adapter
+    # The adapter names exwiw uses internally. Deliberately driver-agnostic
+    # (e.g. `mysql`, not `mysql2`) so they describe the database, not the Ruby
+    # driver or Rails ActiveRecord adapter that happens to talk to it.
+    CANONICAL_ADAPTERS = %w[mysql sqlite postgresql mongodb].freeze
+
+    # Maps the older driver-flavored spellings onto exwiw's canonical adapter
+    # name, so the CLI stays backward compatible (`--adapter=mysql2` still works)
+    # and a Rails app's `connection.adapter_name` (e.g. "Mysql2", "SQLite") is
+    # absorbed — lookup is case-insensitive (see .normalize_name).
+    #
+    # NOTE: this only normalizes the *name*; exwiw always connects with the
+    # `mysql2` gem (see MysqlAdapter#connection). It is deliberately not aliased
+    # from `trilogy`: a source app using the trilogy driver still needs the
+    # `mysql2` gem available for exwiw to connect, so accepting `--adapter=trilogy`
+    # would falsely imply trilogy support. Use `--adapter=mysql` in that case.
+    ADAPTER_ALIASES = {
+      "mysql2" => "mysql",
+      "sqlite3" => "sqlite",
+    }.freeze
+
+    # Normalize an adapter name to its canonical form. Unknown names are passed
+    # through (downcased) so the caller can reject them with a clear message.
+    # Returns nil for nil input.
+    def self.normalize_name(name)
+      return nil if name.nil?
+
+      key = name.to_s.downcase
+      ADAPTER_ALIASES.fetch(key, key)
+    end
+
     class Base
       attr_reader :connection_config
 
@@ -129,17 +159,17 @@ module Exwiw
     end
 
     def self.build(connection_config, logger)
-      case connection_config.adapter
-      when 'sqlite3'
-        Adapter::Sqlite3Adapter.new(connection_config, logger)
-      when 'mysql2'
-        Adapter::Mysql2Adapter.new(connection_config, logger)
+      case normalize_name(connection_config.adapter)
+      when 'sqlite'
+        Adapter::SqliteAdapter.new(connection_config, logger)
+      when 'mysql'
+        Adapter::MysqlAdapter.new(connection_config, logger)
       when 'postgresql'
         Adapter::PostgresqlAdapter.new(connection_config, logger)
       when 'mongodb'
         Adapter::MongodbAdapter.new(connection_config, logger)
       else
-        raise 'Unsupported adapter'
+        raise "Unsupported adapter: #{connection_config.adapter.inspect}"
       end
     end
   end

data/lib/exwiw/belongs_to.rb

@@ -6,9 +6,10 @@ module Exwiw
 
     attribute :foreign_key, String
     attribute :table_name, String
-    # polymorphic 関連の場合のみ設定される。`foreign_type` は型を格納するカラム名
-    # (例: `reviewable_type`)、`type_value` はそのカラムに入る値 (例: `"Product"`)。
-    # 非 polymorphic の belongs_to では両方とも nil。
+    # Set only for a polymorphic association. `foreign_type` is the name of the
+    # column storing the type (e.g. `reviewable_type`), and `type_value` is the
+    # value held in that column (e.g. `"Product"`). Both are nil for a
+    # non-polymorphic belongs_to.
     attribute :foreign_type, optional(String), skip_serializing_if_nil: true
     attribute :type_value, optional(String), skip_serializing_if_nil: true
 

data/lib/exwiw/cli.rb

@@ -10,7 +10,7 @@ require 'exwiw'
 
 module Exwiw
   class CLI
-    KNOWN_SUBCOMMANDS = %w[dump explain].freeze
+    KNOWN_SUBCOMMANDS = %w[export explain].freeze
 
     def self.start(argv)
       new(argv).run
@@ -23,7 +23,7 @@ module Exwiw
         if !@argv.empty? && !@argv.first.start_with?("-") && KNOWN_SUBCOMMANDS.include?(@argv.first)
           @argv.shift
         else
-          "dump"
+          "export"
         end
 
       @help = @argv.empty?
@@ -75,7 +75,7 @@ module Exwiw
       logger = build_logger
 
       case @subcommand
-      when "dump"
+      when "export"
         Runner.new(
           connection_config: connection_config,
           output_dir: @output_dir,
@@ -99,6 +99,19 @@ module Exwiw
     end
 
     private def validate_options!
+      # Fold driver/Rails adapter spellings (mysql2, sqlite3) into exwiw's
+      # canonical names up front, so every check below — and the
+      # EXWIW_DATABASE_ADAPTER passed to hooks — sees the canonical name.
+      @database_adapter = Adapter.normalize_name(@database_adapter)
+
+      # Reject an unknown adapter up front, before checking adapter-specific
+      # options like host/port/password, so the error points at the real problem.
+      unless Adapter::CANONICAL_ADAPTERS.include?(@database_adapter)
+        $stderr.puts "Invalid adapter. Available options are: #{Adapter::CANONICAL_ADAPTERS.join(', ')} " \
+                     "(aliases also accepted: #{Adapter::ADAPTER_ALIASES.keys.join(', ')})"
+        exit 1
+      end
+
       resolve_target_collection_alias!
       resolve_ids_column_alias!
 
@@ -106,7 +119,7 @@ module Exwiw
         validate_explain_only!
       end
 
-      if @database_adapter != "sqlite3"
+      if @database_adapter != "sqlite"
         required_options = {
           "Target database host" => @database_host,
           "Target database port" => @database_port,
@@ -126,13 +139,7 @@ module Exwiw
         end
       end
 
-      valid_adapters = ["mysql2", "postgresql", "sqlite3", "mongodb"]
-      unless valid_adapters.include?(@database_adapter)
-        $stderr.puts "Invalid adapter. Available options are: #{valid_adapters.join(', ')}"
-        exit 1
-      end
-
-      if @subcommand == "dump"
+      if @subcommand == "export"
         @output_dir ||= "dump"
         @output_format ||= "insert"
         @insert_only = @insert_only ? true : false
@@ -227,7 +234,7 @@ module Exwiw
       end
 
       if @ids_column
-        sql_adapters = ["mysql2", "postgresql", "sqlite3"]
+        sql_adapters = ["mysql", "postgresql", "sqlite"]
         unless sql_adapters.include?(@database_adapter)
           $stderr.puts "--ids-column is only supported by the sql adapters (use --ids-field)"
           exit 1
@@ -306,7 +313,7 @@ module Exwiw
           Usage: exwiw [SUBCOMMAND] [options]
 
           Subcommands:
-            dump      Generate INSERT/COPY SQL files (default when omitted).
+            export    Generate INSERT/COPY SQL files (default when omitted).
             explain   Print EXPLAIN output for each extraction query to stdout.
                       (not yet supported for the mongodb adapter)
         BANNER
@@ -315,7 +322,7 @@ module Exwiw
         opts.on("-h", "--host=HOST", "Target database host") { |v| @database_host = v }
         opts.on("-p", "--port=PORT", "Target database port") { |v| @database_port = v }
         opts.on("-u", "--user=USERNAME", "Target database user") { |v| @database_user = v }
-        opts.on("-o", "--output-dir=[DUMP_DIR_PATH]", "Output file path. default is dump/ (dump subcommand only)") do |v|
+        opts.on("-o", "--output-dir=[DUMP_DIR_PATH]", "Output file path. default is dump/ (export subcommand only)") do |v|
           v = v.end_with?("/") ? v[0..-2] : v
           @output_dir = File.expand_path(v)
         end
@@ -323,16 +330,16 @@ module Exwiw
           v = v.end_with?("/") ? v[0..-2] : v
           @config_dir = File.expand_path(v)
         end
-        opts.on("-a", "--adapter=ADAPTER", "Database adapter") { |v| @database_adapter = v }
+        opts.on("-a", "--adapter=ADAPTER", "Database adapter: mysql, sqlite, postgresql, mongodb (aliases: mysql2, sqlite3)") { |v| @database_adapter = v }
         opts.on("--database=DATABASE", "Target database name") { |v| @database_name = v }
         opts.on("--target-table=[TABLE]", "Target table for extraction. If omitted, dump all tables.") { |v| @target_table_name = v }
         opts.on("--target-collection=[COLLECTION]", "Alias of --target-table for the mongodb adapter.") { |v| @target_collection_name = v }
         opts.on("--ids=[IDS]", "Comma-separated list of identifiers. Required when --target-table is given.") { |v| @ids = v.split(',') }
         opts.on("--ids-field=[FIELD]", "Field on the target collection that --ids is matched against. Defaults to the primary key. (mongodb adapter only)") { |v| @ids_field = v }
         opts.on("--ids-column=[COLUMN]", "Column on the target table that --ids is matched against. Defaults to the primary key. (sql adapters only)") { |v| @ids_column = v }
-        opts.on("--output-format=[FORMAT]", "Output format: insert (default) or copy (PostgreSQL only, dump subcommand only)") { |v| @output_format = v }
-        opts.on("--insert-only", "Do not generate DELETE SQL files (dump subcommand only)") { @insert_only = true }
-        opts.on("--after-insert-hook=PATH", "Path to a .rb or .sh post-processing hook executed after all insert/delete files are written (dump subcommand only)") do |v|
+        opts.on("--output-format=[FORMAT]", "Output format: insert (default) or copy (PostgreSQL only, export subcommand only)") { |v| @output_format = v }
+        opts.on("--insert-only", "Do not generate DELETE SQL files (export subcommand only)") { @insert_only = true }
+        opts.on("--after-insert-hook=PATH", "Path to a .rb or .sh post-processing hook executed after all insert/delete files are written (export subcommand only)") do |v|
           @after_insert_hook_path = File.expand_path(v)
         end
         opts.on("--log-level=LEVEL", "Log level (debug, info). default is info") { |v| @log_level = v.to_sym }

data/lib/exwiw/mongoid_schema_generator.rb

@@ -159,11 +159,13 @@ module Exwiw
         end
       end
 
-      # polymorphic belongs_to (`belongs_to :reviewable, polymorphic: true`) は
-      # 単一の対象コレクションを持たないため現状未対応。誤った FK を出力しないよう
-      # ここでは除外する (将来 ActiveRecord 版と同様に展開する余地を残す)。
+      # A polymorphic belongs_to (`belongs_to :reviewable, polymorphic: true`)
+      # has no single target collection, so it is not supported yet. Exclude it
+      # here to avoid emitting an incorrect FK (leaving room to expand it later,
+      # like the ActiveRecord version does).
       #
-      # 継承階層では基底クラスとサブクラスが同じ belongs_to を二重に持つため uniq する。
+      # In an inheritance hierarchy the base class and its subclasses carry the
+      # same belongs_to twice, so uniq them.
       belongs_to_assocs
         .reject(&:polymorphic?)
         .map { |assoc| { table_name: assoc.klass.collection_name.to_s, foreign_key: assoc.foreign_key } }

data/lib/exwiw/query_ast.rb

@@ -3,11 +3,11 @@
 module Exwiw
   module QueryAst
     class JoinClause
-      # `where_clauses` はこの join の join_table_name (= 結合先テーブル) に対して
-      # コンパイルされる。一方 `base_where_clauses` は base_table_name (= 結合元
-      # テーブル) に対してコンパイルされる。後者は、結合元テーブルが結合先へ
-      # polymorphic belongs_to していて型カラム (foreign_type) が結合元テーブル
-      # 側に存在するケースのために使う。
+      # `where_clauses` is compiled against this join's join_table_name (the
+      # joined-to table). `base_where_clauses`, on the other hand, is compiled
+      # against base_table_name (the joined-from table). The latter is used for
+      # the case where the source table polymorphically belongs_to the joined-to
+      # table and the type column (foreign_type) lives on the source table.
       attr_reader :base_table_name, :foreign_key, :join_table_name, :primary_key, :where_clauses, :base_where_clauses
 
       def initialize(base_table_name:, foreign_key:, join_table_name:, primary_key:, where_clauses: [], base_where_clauses: [])

data/lib/exwiw/query_ast_builder.rb

@@ -58,12 +58,12 @@ module Exwiw
           base_where_clauses: []
         )
 
-        # この hop 自体が polymorphic belongs_to の場合 (例: comments が
-        # commentable として posts へ polymorphic belongs_to)、型カラム
-        # (foreign_type) は結合元テーブル (from_table = base_table_name) 側に
-        # 存在する。外部キーだけでは reviewable_id=1 のような値が別モデルの
-        # 行と衝突しうるため、base_where_clauses に型条件を追加して結合元
-        # テーブルを絞り込む。
+        # When this hop itself is a polymorphic belongs_to (e.g. comments
+        # polymorphically belongs_to posts as commentable), the type column
+        # (foreign_type) lives on the source table (from_table = base_table_name).
+        # The foreign key alone is not enough — a value like reviewable_id=1 can
+        # collide with rows of another model — so add the type condition to
+        # base_where_clauses to narrow down the source table.
         if relation.polymorphic?
           join_clause.base_where_clauses.push QueryAst::WhereClause.new(
             column_name: relation.foreign_type,
@@ -75,10 +75,11 @@ module Exwiw
         if relation_to_dump_target
           join_clause.where_clauses.push dump_target_fk_clause(relation_to_dump_target.foreign_key)
 
-          # 中間テーブルが dump target へ polymorphic belongs_to している場合は、
-          # 型カラム (foreign_type) も join 条件に追加する。型カラムは to_table
-          # (= join_table_name) 上に存在するため、JoinClause の where_clauses が
-          # join_table_name に対してコンパイルされる仕組みにそのまま乗せられる。
+          # When the intermediate table polymorphically belongs_to the dump
+          # target, also add the type column (foreign_type) to the join
+          # condition. The type column lives on to_table (= join_table_name), so
+          # it rides on the existing mechanism where a JoinClause's where_clauses
+          # are compiled against join_table_name.
           if relation_to_dump_target.polymorphic?
             join_clause.where_clauses.push QueryAst::WhereClause.new(
               column_name: relation_to_dump_target.foreign_type,
@@ -121,9 +122,9 @@ module Exwiw
 
       clauses.push dump_target_fk_clause(belongs_to.foreign_key)
 
-      # polymorphic belongs_to の場合は外部キーだけでは型を区別できないため
-      # (例: reviewable_id=1 が Product なのか別モデルなのか判別できない)、
-      # 型カラム (foreign_type) を type_value で絞り込む条件を追加する。
+      # For a polymorphic belongs_to the foreign key alone cannot distinguish the
+      # type (e.g. reviewable_id=1 could be a Product or another model), so add a
+      # condition filtering the type column (foreign_type) by type_value.
       if belongs_to.polymorphic?
         clauses.push Exwiw::QueryAst::WhereClause.new(
           column_name: belongs_to.foreign_type,

data/lib/exwiw/schema_generator.rb

@@ -78,11 +78,12 @@ module Exwiw
         representative = model_group.first
         primary_key = representative.primary_key
 
-        # 複合主キー (`representative.primary_key` が Array) のテーブルは現状未対応。
-        # primary_key を省略し、type で非対応である旨を明示したうえで skip:true を
-        # 付与して出力する。type を付けておくことで将来対応する際の目印になる。
-        # 利用者が必要に応じて手動で skip を外して設定し直せるよう、設定ファイル
-        # 自体は生成しておく。
+        # Tables with a composite primary key (`representative.primary_key` is an
+        # Array) are not supported yet. Emit them with `primary_key` omitted,
+        # `skip: true`, and a `type` that marks them as unsupported — the `type`
+        # acts as a signpost for adding support later. The config file itself is
+        # still generated so a user can manually remove `skip` and wire it up when
+        # needed.
         if primary_key.is_a?(Array)
           TableConfig.from_symbol_keys(
             name: table_name,
@@ -110,12 +111,13 @@ module Exwiw
       @models.reject(&:abstract_class?).select(&:table_exists?)
     end
 
-    # rails-managed テーブル (`schema_migrations` / `ar_internal_metadata`) は
-    # モデルクラスを持たないため `ActiveRecord::Base.descendants` からは拾えない。
-    # multi-DB 構成では各 connection が独立した migration 履歴テーブルを持つので、
-    # 対象 connection を受け取り、その connection 上に該当テーブルが存在する場合のみ
-    # エントリを生成する。テーブル名そのものは prefix/suffix を含むグローバル設定
-    # (`ActiveRecord::Base.schema_migrations_table_name` 等) から得る。
+    # The rails-managed tables (`schema_migrations` / `ar_internal_metadata`)
+    # have no model class, so they cannot be picked up from
+    # `ActiveRecord::Base.descendants`. In a multi-DB setup each connection has
+    # its own migration history table, so we take the target connection and only
+    # emit an entry when the table actually exists on that connection. The table
+    # name itself (including any prefix/suffix) comes from the global settings
+    # (`ActiveRecord::Base.schema_migrations_table_name`, etc.).
     private def build_rails_managed_tables(conn)
       result = []
 
@@ -151,11 +153,11 @@ module Exwiw
         .reject(&:polymorphic?)
         .map { |assoc| { table_name: assoc.table_name, foreign_key: assoc.foreign_key } }
 
-      # polymorphic な belongs_to (`belongs_to :reviewable, polymorphic: true`) は
-      # 単一の対象テーブルを持たない。対象になりうるテーブルは、他モデルで
-      # `has_many/has_one ..., as: <association_name>` と宣言されている側から逆引き
-      # する。各候補テーブルごとに、型カラム (`foreign_type`) と格納される型の値
-      # (`type_value`) を添えた belongs_to を 1 件ずつ展開する。
+      # A polymorphic belongs_to (`belongs_to :reviewable, polymorphic: true`)
+      # has no single target table. The candidate tables are found by looking up
+      # the other models that declare `has_many/has_one ..., as: <association_name>`.
+      # For each candidate table, expand one belongs_to entry carrying the type
+      # column (`foreign_type`) and the stored type value (`type_value`).
       polymorphic = belongs_to_assocs
         .select(&:polymorphic?)
         .flat_map do |assoc|
@@ -172,11 +174,12 @@ module Exwiw
       (non_polymorphic + polymorphic).uniq
     end
 
-    # polymorphic 関連 `association_name` の対象となりうる具象モデルを、全モデルの
-    # `has_many` / `has_one` の `as:` オプションから逆引きして列挙する。
-    # `concrete_models` の並びは `ActiveRecord::Base.descendants` の順に依存し、
-    # Ruby バージョンによって変わりうるため、生成される belongs_to の並びが安定する
-    # よう `table_name` でソートして決定的に返す。
+    # Enumerate the concrete models that can be targets of the polymorphic
+    # association `association_name`, by looking them up from every model's
+    # `has_many` / `has_one` `as:` option. The order of `concrete_models` depends
+    # on `ActiveRecord::Base.descendants`, which can vary by Ruby version, so sort
+    # by `table_name` to return a deterministic order and keep the generated
+    # belongs_to ordering stable.
     private def polymorphic_target_models(association_name)
       concrete_models.select do |model|
         (model.reflect_on_all_associations(:has_many) +

data/lib/exwiw/table_config.rb

@@ -11,9 +11,10 @@ module Exwiw
       RAILS_MANAGED_INTERNAL_METADATA,
     ].freeze
 
-    # exwiw が現状サポートしていない複合主キーのテーブルを表す type。
-    # schema:generate が skip:true と併せて付与する。将来サポートする際の
-    # 目印になるよう、rails-managed とは異なり columns/belongs_tos は保持する。
+    # type marking a table with a composite primary key, which exwiw does not
+    # support yet. schema:generate attaches it together with skip:true. Unlike
+    # rails-managed tables, columns/belongs_tos are retained so it can serve as a
+    # signpost for adding support later.
     UNSUPPORTED_COMPOSITE_PRIMARY_KEY = "unsupported_composite_primary_key"
 
     attribute :name, String
@@ -143,8 +144,8 @@ module Exwiw
                 "Table '#{name}' has type=#{type}; columns must not be defined."
         end
       else
-        # skip:true のテーブルはデータ抽出を行わないため primary_key を要求しない。
-        # (例: exwiw 非対応の複合主キーテーブル)
+        # A skip:true table is not extracted, so primary_key is not required
+        # (e.g. a composite-primary-key table that exwiw does not support).
         if primary_key.nil? && !skip
           raise ArgumentError, "Table '#{name}' requires primary_key."
         end

data/lib/exwiw/version.rb

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

data/lib/exwiw.rb

@@ -13,8 +13,9 @@ require_relative "exwiw/mongodb_field"
 require_relative "exwiw/mongodb_collection_config"
 require_relative "exwiw/ddl_postprocessor"
 require_relative "exwiw/adapter"
-require_relative "exwiw/adapter/sqlite3_adapter"
-require_relative "exwiw/adapter/mysql2_adapter"
+require_relative "exwiw/adapter/sqlite_adapter"
+require_relative "exwiw/adapter/mysql_client"
+require_relative "exwiw/adapter/mysql_adapter"
 require_relative "exwiw/adapter/postgresql_adapter"
 require_relative "exwiw/adapter/mongodb_adapter"
 require_relative "exwiw/determine_table_processing_order"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: exwiw
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Shia
@@ -45,9 +45,10 @@ files:
 - lib/exwiw.rb
 - lib/exwiw/adapter.rb
 - lib/exwiw/adapter/mongodb_adapter.rb
-- lib/exwiw/adapter/mysql2_adapter.rb
+- lib/exwiw/adapter/mysql_adapter.rb
+- lib/exwiw/adapter/mysql_client.rb
 - lib/exwiw/adapter/postgresql_adapter.rb
-- lib/exwiw/adapter/sqlite3_adapter.rb
+- lib/exwiw/adapter/sqlite_adapter.rb
 - lib/exwiw/after_insert_hook.rb
 - lib/exwiw/belongs_to.rb
 - lib/exwiw/cli.rb