convergence 1.0.6 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c5b9f06840ed6ef0686f00bfb8d677fc0ad0e389398ae30a5e20b86ca2cdf15
-  data.tar.gz: 5f9f77898685d66e68d2c110ba53e4709fd45fffba9f5a13f77c8aa30b4605a0
+  metadata.gz: 75c8ae12a9ee346dd376ff2dfe6f03451a96aa4dc58acf414f9c0447c3e79bab
+  data.tar.gz: 57e2096d724239594acd415001e801f89f22bba706e3382ccca46dd3309cd5b9
 SHA512:
-  metadata.gz: 587acb6716a2358a4babb9468473c65fcd0f61f5f81ead163aefe615bc81b547b0e487d9dbc558600a922d5c5bb4356c2ae7e153d837bcb1b865c1258c23b109
-  data.tar.gz: 7c87a0849716fce53dea625c05532357bc9c92076f7658cdad1c29c0ee44a7eb48a1d3c32233c519e36d1f592e1d9c13c4cecde7ee586e16f307e6c9fda54d6e
+  metadata.gz: ca8171ecd7a63c898401fb316be440a1cee97b4cd44d52bda5ac449c608dd54432574aa5ce6e2222fe0d65acac0e89d4ec092eecd6e83cb6a3e9874ffb382cbc
+  data.tar.gz: 3b7ca04775d9e8800a69f6b70034d9d906b8ba679a575603b8d7d5283db2dd031215d50c42e4d16993f2e686c38ba4bb04ffa4d1028eac2f896f52df05c99f31

data/.github/workflows/ruby.yml

@@ -4,21 +4,52 @@ on: [push, pull_request]
 
 jobs:
   test:
+    name: Test with MySQL ${{ matrix.mysql }} / PostgreSQL 16, Ruby ${{ matrix.ruby }}
     runs-on: ubuntu-latest
     strategy:
+      fail-fast: false
       matrix:
-        ruby: ['2.4', '2.5', '2.6', '2.7', '3.0', '3.1']
+        mysql: ['5.7', '8.0']
+        ruby: ['3.1', '3.2', '3.3', '3.4']
+    services:
+      mysql:
+        image: mysql:${{ matrix.mysql }}
+        env:
+          MYSQL_ROOT_PASSWORD: root
+        ports:
+          - 3306:3306
+        options: >-
+          --health-cmd "mysqladmin ping"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+      postgres:
+        image: postgres:16
+        env:
+          POSTGRES_PASSWORD: postgres
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
+    - name: Install PostgreSQL and SQLite client libraries
+      run: sudo apt-get update && sudo apt-get install -y libpq-dev libsqlite3-dev sqlite3
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true
     - name: Install dependencies
       run: bundle install
-    - name: Start MySQL
-      run: sudo systemctl start mysql.service
     - name: Prepare database
       run: bundle exec rake db:convergence:prepare
+    - name: Prepare PostgreSQL database
+      run: bundle exec rake db:convergence:postgres:prepare
+    - name: Prepare SQLite database
+      run: bundle exec rake db:convergence:sqlite:prepare
     - name: Run tests
       run: bundle exec rake spec

data/.gitignore

@@ -2,6 +2,7 @@ tmp/
 tags
 database.yml
 pkg/
+spec/fixtures/sqlite_test_db.sqlite3
 
 .bundle
 .ruby-version

data/CHANGELOG.md

@@ -1,3 +1,49 @@
+## Convergence 1.1.0 (August 25, 2026) ##
+
+* Add PostgreSQL support (PR: #93)
+
+  *nishio-dens*
+
+* Add SQLite support (PR: #95)
+
+  *nishio-dens*
+
+* Support ENUM/SET column types (PR: #92)
+
+  *nishio-dens*
+
+* Add `execute()` DSL method to run raw SQL (PR: #94)
+
+  *nishio-dens*
+
+* Add `--dump-rails-migration` option to export DB schema as a Rails migration file (PR: #96)
+
+  *nishio-dens*
+
+* Add `--safe-migration` option to skip DROP TABLE queries (PR: #91)
+
+  *nishio-dens*
+
+* Add `--ignore-auto-increment` option (PR: #90)
+
+  *nishio-dens*
+
+* Fix MySQL 8.0 test failure and modernize CI Ruby matrix (PR: #89)
+
+  *nishio-dens*
+
+* Bump diffy to >= 3.4.2, fixing CVE-2022-33127 (PR: #100)
+
+  *nishio-dens*
+
+* Add specs for previously untested classes/commands (PR: #97)
+
+  *nishio-dens*
+
+* Add CONTRIBUTING.md (PR: #98)
+
+  *nishio-dens*
+
 ## Convergence 1.0.6 (April 28, 2022) ##
 
 * Fixes YAML.safe_load arguments (PR: #84)

data/CONTRIBUTING.md

@@ -0,0 +1,80 @@
+# Contributing to Convergence
+
+Thanks for considering a contribution! This document covers everything you need to get a development
+environment running, test your change, and open a pull request.
+
+## Development setup
+
+Convergence supports MySQL, PostgreSQL, and SQLite, so the test suite exercises all three. You don't need
+every adapter running to work on a change that's scoped to one of them, but `rake spec` runs the whole suite
+regardless of which adapter you touched.
+
+1. Install Ruby (see `required_ruby_version` in `convergence.gemspec` for the minimum version) and Bundler.
+2. Install dependencies:
+
+   ```
+   $ bundle install
+   ```
+
+   `sqlite3`, `mysql2`, and `pg` are native extensions; if a gem fails to build, make sure the corresponding
+   client library/headers are installed for your OS (e.g. `libmysqlclient-dev`, `libpq-dev`, `libsqlite3-dev`
+   on Debian/Ubuntu, or the Homebrew equivalents on macOS).
+3. Start MySQL and PostgreSQL (locally, in Docker, however you prefer) and set connection details for all
+   three adapters in `spec/config/spec_database.yml` if the defaults don't match your setup.
+4. Prepare the test databases:
+
+   ```
+   $ bundle exec rake db:convergence:prepare           # MySQL
+   $ bundle exec rake db:convergence:postgres:prepare  # PostgreSQL
+   $ bundle exec rake db:convergence:sqlite:prepare     # SQLite (no server needed, just a file)
+   ```
+
+## Running the tests
+
+```
+$ bundle exec rspec
+```
+
+or, equivalently:
+
+```
+$ bundle exec rake spec
+```
+
+If you change the schema of the shared test fixtures (`spec/fixtures/test_db.sql`,
+`spec/fixtures/postgres_test_db.sql`, `spec/fixtures/sqlite_test_db.sql`), rebuild the affected database with
+the corresponding `overhaul` task (e.g. `rake db:convergence:overhaul`) before rerunning the suite.
+
+## Code style
+
+The project uses RuboCop (see `.rubocop.yml` for the enabled/disabled cops); there's no dedicated Rake task
+wired up, so run it directly if you want to check your changes:
+
+```
+$ bundle exec rubocop
+```
+
+## Adding support for a new adapter capability
+
+Convergence's DSL uses MySQL terminology for column types so that schema files stay close to portable across
+adapters. If you're adding a feature to an existing adapter (or a new adapter entirely), the adapter-specific
+logic lives in four places per adapter:
+
+- `lib/convergence/database_connector/*_connector.rb` — opens the DB connection.
+- `lib/convergence/dumper/*_schema_dumper.rb` — reads the current schema from the database.
+- `lib/convergence/sql_generator/*_generator.rb` — turns a diff into `CREATE`/`ALTER`/`DROP` SQL.
+- `lib/convergence/default_parameter/*_default_parameter.rb` — fills in / strips adapter-specific defaults
+  (e.g. MySQL's default charset) so diffing doesn't produce spurious noise.
+
+All four are dispatched by adapter name in `lib/convergence/database_connector.rb`, `lib/convergence/command.rb`,
+`lib/convergence/command/apply.rb`, and `lib/convergence/default_parameter.rb` respectively — a new adapter
+needs a `when` branch added to each. Add a parallel fixture database/schema files under `spec/fixtures/` and a
+matching test suite (see the existing `spec/postgres_integrations/` or `spec/sqlite_integrations/` for the
+pattern) so the new adapter is covered end-to-end.
+
+## Opening a pull request
+
+- Keep pull requests focused on a single change; it makes review (and `CHANGELOG.md`/release notes) easier.
+- Add or update specs for any behavior change.
+- Update `README.md` if you're adding a user-facing option or adapter capability.
+- Reference the issue you're addressing (e.g. `Closes #123`) in the pull request description.

data/Gemfile.lock

@@ -1,19 +1,22 @@
 PATH
   remote: .
   specs:
-    convergence (1.0.6)
+    convergence (1.1.0)
       diff-lcs
-      diffy
+      diffy (>= 3.4.2)
       mysql2
+      pg
+      sqlite3
       thor
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.1)
+    bigdecimal (4.1.2)
     coderay (1.1.3)
     diff-lcs (1.4.4)
-    diffy (3.4.0)
+    diffy (3.4.4)
     ffi (1.14.2)
     formatador (0.2.5)
     guard (2.16.2)
@@ -30,12 +33,15 @@ GEM
       guard (~> 2.1)
       guard-compat (~> 1.1)
       rspec (>= 2.99.0, < 4.0)
+    io-console (0.9.2)
     listen (3.3.3)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
     lumberjack (1.2.8)
-    method_source (1.0.0)
-    mysql2 (0.5.3)
+    method_source (1.1.0)
+    mini_portile2 (2.8.9)
+    mysql2 (0.5.7)
+      bigdecimal
     nenv (0.3.0)
     notiffany (0.1.3)
       nenv (~> 0.1)
@@ -43,15 +49,20 @@ GEM
     parallel (1.20.1)
     parser (3.0.0.0)
       ast (~> 2.4.1)
-    pry (0.13.1)
+    pg (1.6.3)
+    pg (1.6.3-x86_64-linux)
+    pry (0.16.0)
       coderay (~> 1.1)
       method_source (~> 1.0)
+      reline (>= 0.6.0)
     rainbow (3.0.0)
-    rake (13.0.3)
+    rake (13.4.2)
     rb-fsevent (0.10.4)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
     regexp_parser (2.0.3)
+    reline (0.7.0)
+      io-console (~> 0.5)
     rexml (3.2.5)
     rspec (3.10.0)
       rspec-core (~> 3.10.0)
@@ -79,11 +90,15 @@ GEM
       parser (>= 2.7.1.5)
     ruby-progressbar (1.11.0)
     shellany (0.0.1)
+    sqlite3 (2.8.1)
+      mini_portile2 (~> 2.8.0)
+    sqlite3 (2.8.1-x86_64-linux-gnu)
     thor (1.0.1)
     unicode-display_width (1.7.0)
 
 PLATFORMS
   ruby
+  x86_64-linux
 
 DEPENDENCIES
   convergence!
@@ -95,4 +110,4 @@ DEPENDENCIES
   rubocop
 
 BUNDLED WITH
-   2.2.32
+   4.0.19

data/README.md

@@ -1,7 +1,7 @@
 # Convergence
 
 Convergence is a pure-Ruby database schema migration tool.
-Currently, This tool is support only MySQL.
+Currently, This tool supports MySQL, PostgreSQL, and SQLite.
 
 It defines DB Schema using Convergence DSL(like Rails DSL).
 For more information about Convergence DSL, See below ['Detail About Convergence DSL'](#detail-about-convergence-dsl)
@@ -133,8 +133,10 @@ Create Table: CREATE TABLE `test_tables` (
 ```
 Commands:
   convergence apply FILE -c, --config=CONFIG   # execute sql to your database
+                                                # [--dry-run], [--rollback-dry-run], [--safe-migration], [--ignore-auto-increment]
   convergence diff FILE1 FILE2                 # print diff of DSLs
   convergence export -c, --config=CONFIG       # export db schema to dsl
+                                                # [--dump-rails-migration], [--filename=FILENAME]
   convergence help [COMMAND]                   # Describe available commands or one specific command
   convergence version                          # print the version
 ```
@@ -152,6 +154,49 @@ username: root
 password:
 ```
 
+To use PostgreSQL instead, set `adapter: postgresql` (`postgres`/`pg` also work):
+
+```
+$ cat database.yml
+adapter: postgresql
+database: convergence_test
+host: 127.0.0.1
+username: postgres
+password:
+```
+
+#### PostgreSQL notes
+
+The Convergence DSL uses MySQL terminology for column types (`tinyint`, `mediumint`, `datetime`, ...) so the
+same schema files stay close to portable across adapters; the PostgreSQL adapter maps them to their closest
+native PostgreSQL type (e.g. `mediumint`/`int` → `integer`, `datetime` → `timestamp`, `json` → `jsonb`,
+`extra: 'auto_increment'` → `GENERATED BY DEFAULT AS IDENTITY`, requiring PostgreSQL 10+).
+
+A few MySQL-specific concepts have no PostgreSQL equivalent and are ignored on that adapter: `engine`,
+`row_format`, `default_charset`/`character_set`, and `collate`. `enum`/`set` column types are not supported yet
+on PostgreSQL.
+
+To use SQLite instead, set `adapter: sqlite3` (`sqlite` also works) and point `database` at a file path:
+
+```
+$ cat database.yml
+adapter: sqlite3
+database: /path/to/development.sqlite3
+```
+
+#### SQLite notes
+
+SQLite's `ALTER TABLE` support is intentionally limited by SQLite itself: it can only add/drop columns and
+create/drop indexes on an existing table. Changing a column's type/null/default, and adding or removing a
+foreign key or primary key on an existing table, all require SQLite's own "rebuild the table" procedure
+(create a new table, copy the data over, drop the old one, rename it), which this adapter does not implement
+yet -- it raises `NotImplementedError` instead of generating SQL that SQLite would reject. Creating a brand new
+table with any of the above (including foreign keys) works fine.
+
+Like PostgreSQL, MySQL-only table options (`engine`, `row_format`, `default_charset`/`character_set`, `collate`,
+table/column `comment`) have no SQLite equivalent and are ignored. `extra: 'auto_increment'` maps to SQLite's
+`INTEGER PRIMARY KEY AUTOINCREMENT`.
+
 #### Use SSL connection
 
 If you would like to use SSL connection, you can specify SSL options in database.yml
@@ -216,6 +261,43 @@ create_table "paper_authors", collate: "utf8_general_ci", comment: "Paper Author
 end
 ```
 
+### Export as a Rails migration file
+
+If you're migrating to (or working alongside) a Rails app, pass `--dump-rails-migration` to export the schema as an
+ActiveRecord migration instead of a Convergence DSL file. `--filename` sets the base filename/class name (Rails'
+usual `snake_case` filename / `CamelCase` class name convention applies).
+
+```
+$ convergence export -c database.yml --dump-rails-migration --filename create_initial_tables
+```
+
+```ruby
+# Filename: 20240101000000_create_initial_tables.rb
+class CreateInitialTables < ActiveRecord::Migration[7.0]
+  def change
+    create_table :authors do |t|
+      t.string :name, limit: 110
+      t.timestamps
+
+      t.index :created_at, name: "index_authors_on_created_at"
+    end
+  end
+end
+```
+
+The output is written to stdout with a `# Filename: ...` comment on top (including a timestamp prefix in the usual
+Rails migration filename format) — redirect it to that file yourself, e.g.
+`convergence export ... > db/migrate/$(date +%Y%m%d%H%M%S)_create_initial_tables.rb`.
+
+A few notes on the conversion:
+* An `id` column that matches Rails' implicit auto-incrementing primary key (`int`/`bigint`, `primary_key: true`,
+  `extra: 'auto_increment'`) is omitted, since `create_table` adds it automatically.
+* `created_at`/`updated_at` columns with matching `datetime`/`null` options are collapsed into `t.timestamps`.
+* Column types use Rails' type names (e.g. `varchar` → `string`, `datetime`/`timestamp` → `datetime`); `enum`/`set`
+  have no ActiveRecord equivalent and fall back to `string`.
+* MySQL-only concepts with no `create_table` DSL equivalent (`character_set`, `collate`, `extra`, `after`) are
+  dropped from column definitions.
+
 ### Dry run
 
 ```
@@ -235,6 +317,29 @@ $ convergence apply example.schema -c database.yml --rollback-dry-run
 $ convergence apply example.schema -c database.yml
 ```
 
+### Ignore AUTO_INCREMENT changes
+
+If you dump your schema from a database with a high AUTO_INCREMENT value (e.g. a dev/staging box you've been testing on)
+and apply it to another database, convergence will normally generate a query that bumps AUTO_INCREMENT to match, which
+can jump/skip a large range of ids. Pass `--ignore-auto-increment` to skip generating AUTO_INCREMENT change queries entirely.
+
+```
+$ convergence apply example.schema -c database.yml --ignore-auto-increment
+```
+
+This also applies to `--dry-run` and `--rollback-dry-run`.
+
+### Safe migration
+
+If you want to prevent convergence from ever dropping a table (e.g. when the DSL file removed a table that still
+has important data), pass `--safe-migration`. It skips generating `DROP TABLE` queries; every other change is still applied.
+
+```
+$ convergence apply example.schema -c database.yml --safe-migration
+```
+
+This also applies to `--dry-run` and `--rollback-dry-run`.
+
 ### Include Other Schema files
 
 ```
@@ -242,6 +347,20 @@ include 'first_schema.schema'
 include 'other_file.schema'
 ```
 
+### Execute raw SQL
+
+For things the DSL has no dedicated syntax for (views, triggers, stored procedures, data backfills, grants, ...),
+use `execute` to run an arbitrary SQL statement. Unlike `create_table`, statements passed to `execute` are **not**
+diffed against the current schema: they run every time the schema file is applied, so make sure the SQL itself is
+idempotent (e.g. `CREATE OR REPLACE VIEW ...`, `CREATE TABLE IF NOT EXISTS ...`).
+
+```
+execute "CREATE OR REPLACE VIEW active_users AS SELECT * FROM users WHERE active = 1"
+```
+
+`execute` statements always run after the generated schema changes, and are skipped by `--rollback-dry-run` (there's
+no way to know how to reverse an arbitrary SQL statement).
+
 
 ## Detail About Convergence DSL
 
@@ -273,6 +392,8 @@ Convergence is currently support column types below.
 - timestamp
 - year
 - json
+- enum
+- set
 
 ```
 create_table "tests", comment: 'Column type example' do |t|
@@ -282,6 +403,8 @@ create_table "tests", comment: 'Column type example' do |t|
   t.varchar 'test_string', null: true, default: 'hello', limit: 300
   t.text 'text_col'
   t.datetime 'created_at'
+  t.enum 'status', values: %w(active inactive pending), default: 'active'
+  t.set 'flags', values: %w(a b c)
 end
 ```
 
@@ -344,9 +467,16 @@ end
 
 ```
 $ bundle exec rake db:convergence:prepare
+$ bundle exec rake db:convergence:postgres:prepare
+$ bundle exec rake db:convergence:sqlite:prepare
 $ bundle exec rspec
 ```
 
+## Contributing
+
+Bug reports and pull requests are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md) for how to set up a
+development environment, run the test suite, and what to include in a pull request.
+
 ## Copyright
 
 Copyright © 2014-2018 S.nishio. See LICENSE.txt for further details.

data/Rakefile

@@ -5,8 +5,10 @@ require 'yaml'
 RSpec::Core::RakeTask.new('spec')
 task default: :spec
 
-mysql_settings = YAML.load_file("#{File.dirname(__FILE__)}/spec/config/spec_database.yml")['mysql']
-mysql_settings = Hash[mysql_settings.map { |k, v| [k.to_sym, v] }]
+spec_database_settings = YAML.load_file("#{File.dirname(__FILE__)}/spec/config/spec_database.yml")
+mysql_settings = Hash[spec_database_settings['mysql'].map { |k, v| [k.to_sym, v] }]
+postgres_settings = Hash[spec_database_settings['postgresql'].map { |k, v| [k.to_sym, v] }]
+sqlite_db_path = File.expand_path("#{File.dirname(__FILE__)}/spec/fixtures/#{spec_database_settings['sqlite3']['database']}")
 
 namespace :db do
   namespace :convergence do
@@ -30,5 +32,46 @@ namespace :db do
     desc 'Prepare the test databases'
     task prepare: [:build_databases, :create_tables]
     task overhaul: [:drop_databases, :build_databases, :create_tables]
+
+    namespace :postgres do
+      desc 'Build the PostgreSQL database for tests'
+      task :build_databases do
+        ENV['PGPASSWORD'] = postgres_settings[:password].to_s
+        system("psql -U #{postgres_settings[:username]} -h #{postgres_settings[:host]} -p #{postgres_settings[:port]} -d postgres -c 'create database #{postgres_settings[:database]};'")
+      end
+
+      task :drop_databases do
+        ENV['PGPASSWORD'] = postgres_settings[:password].to_s
+        system("psql -U #{postgres_settings[:username]} -h #{postgres_settings[:host]} -p #{postgres_settings[:port]} -d postgres -c 'drop database if exists #{postgres_settings[:database]};'")
+      end
+
+      desc 'Create tables on the PostgreSQL test database'
+      task :create_tables do
+        ENV['PGPASSWORD'] = postgres_settings[:password].to_s
+        query_path = "#{File.dirname(__FILE__)}/spec/fixtures/postgres_test_db.sql"
+        system("psql -U #{postgres_settings[:username]} -h #{postgres_settings[:host]} -p #{postgres_settings[:port]} -d #{postgres_settings[:database]} -f #{query_path}")
+      end
+
+      desc 'Prepare the PostgreSQL test database'
+      task prepare: [:build_databases, :create_tables]
+      task overhaul: [:drop_databases, :build_databases, :create_tables]
+    end
+
+    namespace :sqlite do
+      desc 'Remove the SQLite test database file'
+      task :drop_databases do
+        File.delete(sqlite_db_path) if File.exist?(sqlite_db_path)
+      end
+
+      desc 'Create tables on the SQLite test database'
+      task :create_tables do
+        query_path = "#{File.dirname(__FILE__)}/spec/fixtures/sqlite_test_db.sql"
+        system("sqlite3 #{sqlite_db_path} < #{query_path}")
+      end
+
+      desc 'Prepare the SQLite test database'
+      task prepare: [:drop_databases, :create_tables]
+      task overhaul: [:drop_databases, :create_tables]
+    end
   end
 end

data/convergence.gemspec

@@ -19,8 +19,10 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'mysql2'
+  spec.add_dependency 'pg'
+  spec.add_dependency 'sqlite3'
   spec.add_dependency 'diff-lcs'
-  spec.add_dependency 'diffy'
+  spec.add_dependency 'diffy', '>= 3.4.2'
   spec.add_dependency 'thor'
 
   spec.required_ruby_version = ">= 2.4.0"

data/lib/convergence/cli.rb

@@ -11,13 +11,19 @@ class Convergence::CLI < Thor
   method_option :config, aliases: '-c', type: :string, required: true, desc: 'Database Yaml Setting'
   method_option :dry_run, type: :boolean
   method_option :rollback_dry_run, type: :boolean
+  method_option :ignore_auto_increment, type: :boolean, desc: 'Do not generate AUTO_INCREMENT change queries'
+  method_option :safe_migration, type: :boolean, desc: 'Do not generate DROP TABLE queries'
 
   def self.exit_on_failure?
     true
   end
 
   def apply(file)
-    opts = { input: file }
+    opts = {
+      input: file,
+      ignore_auto_increment: options[:ignore_auto_increment],
+      safe_migration: options[:safe_migration]
+    }
     if options[:dry_run]
       require 'convergence/command/dryrun'
       Convergence::Command::Dryrun.new(opts, config: config).execute
@@ -39,9 +45,11 @@ class Convergence::CLI < Thor
 
   desc 'export', 'export db schema to dsl'
   method_option :config, aliases: '-c', type: :string, required: true, desc: 'Database Yaml Setting'
+  method_option :dump_rails_migration, type: :boolean, desc: 'Output an ActiveRecord migration file instead of a Convergence DSL file'
+  method_option :filename, type: :string, desc: 'Base filename (without timestamp/extension) used for --dump-rails-migration'
   def export
     require 'convergence/command/export'
-    opts = {}
+    opts = { dump_rails_migration: options[:dump_rails_migration], filename: options[:filename] }
     Convergence::Command::Export.new(opts, config: config).execute
   end
 

data/lib/convergence/command/apply.rb

@@ -8,40 +8,69 @@ require 'convergence/diff'
 class Convergence::Command::Apply < Convergence::Command
   def execute
     current_dir_path = Pathname.new(@opts[:input]).realpath.dirname
-    input_tables = Convergence::DSL.parse(File.open(@opts[:input]).read, current_dir_path)
+    dsl = Convergence::DSL.parse_dsl(File.open(@opts[:input]).read, current_dir_path)
     current_tables = dumper.dump
-    execute_sql(input_tables, current_tables)
+    execute_sql(dsl.tables, current_tables, dsl.raw_sqls)
   end
 
-  def generate_sql(input_tables, current_tables)
+  def generate_sql(input_tables, current_tables, raw_sqls = [])
     current_tables_with_full_option =
       Convergence::DefaultParameter.append_database_default_parameter(current_tables, database_adapter)
     input_tables_with_full_option =
       Convergence::DefaultParameter.append_database_default_parameter(input_tables, database_adapter)
-    delta = Convergence::Diff.new.diff(current_tables_with_full_option, input_tables_with_full_option)
-    sql_generator.generate(input_tables_with_full_option, delta, current_tables_with_full_option)
+    delta = Convergence::Diff
+      .new(ignore_auto_increment: @opts[:ignore_auto_increment])
+      .diff(current_tables_with_full_option, input_tables_with_full_option)
+    sql = sql_generator.generate(
+      input_tables_with_full_option,
+      delta,
+      current_tables_with_full_option,
+      safe_migration: @opts[:safe_migration]
+    )
+    append_raw_sqls(sql, raw_sqls)
   end
 
   private
 
+  def append_raw_sqls(sql, raw_sqls)
+    return sql if raw_sqls.empty?
+    raw_sql_block = raw_sqls.map { |q| q.strip.end_with?(';') ? q.strip : "#{q.strip};" }.join("\n")
+    [sql, raw_sql_block].reject(&:empty?).join("\n")
+  end
+
   def sql_generator
     @sql_generator ||= case database_adapter
                        when 'mysql', 'mysql2'
                          require 'convergence/sql_generator/mysql_generator'
                          SQLGenerator::MysqlGenerator.new
+                       when 'postgresql', 'postgres', 'pg'
+                         require 'convergence/sql_generator/postgres_generator'
+                         SQLGenerator::PostgresGenerator.new
+                       when 'sqlite3', 'sqlite'
+                         require 'convergence/sql_generator/sqlite_generator'
+                         SQLGenerator::SqliteGenerator.new
                        else
                          fail NotImplementedError.new('unknown database adapter')
                        end
   end
 
-  def execute_sql(input_tables, current_tables)
-    sql = generate_sql(input_tables, current_tables)
-    unless sql.strip.empty?
-      sql = <<-SQL
+  def wrap_with_constraint_pragma(sql)
+    case database_adapter
+    when 'mysql', 'mysql2'
+      <<-SQL
 SET FOREIGN_KEY_CHECKS=0;
       #{sql}
 SET FOREIGN_KEY_CHECKS=1;
       SQL
+    else
+      sql
+    end
+  end
+
+  def execute_sql(input_tables, current_tables, raw_sqls = [])
+    sql = generate_sql(input_tables, current_tables, raw_sqls)
+    unless sql.strip.empty?
+      sql = wrap_with_constraint_pragma(sql)
     end
     sql.split(';').each do |q2|
       q = q2.strip