db_schema 0.2.5 → 0.3.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fd3abbf119d7700e83eedf09b10b100cfc744f9e
-  data.tar.gz: d3e8cfd07c1fdcd902e705b337eed52f2bdf8829
+  metadata.gz: 60b581e6c318ed7bf979417435dce0ec4960a978
+  data.tar.gz: 0f296ac7525965a1bd3026e76cfa0cd2bb24b821
 SHA512:
-  metadata.gz: 251c126151289b49ea663c2d57c46334d9ba98c9419110121acbb436aee006871eec48aeabbe3ea1a6e6369b1a76fd4ff07e5e9d3cbb0c88e12e13ba609269b2
-  data.tar.gz: a6163f3a147938bad96b7d891f26990fc9c86068f716ec236e4647dda13019c1af9bf1a2ba566fe3c4c8f0b46d5edd6db29ed002eb3212d56590e62fc6baf84f
+  metadata.gz: 19375ec9fac1576a3c8164de6584ceacc21019d111bb2e584850713d89936a3714c394c0338c16eb5873c2f86d319286136690fad8cb28b2748dc911c625f3e8
+  data.tar.gz: b80cb8b4a448e5f0014763d89b1e2e2e376d48cd84f03380c55c823a71efe952d7187242888f021b27ccdbf3f85191b5286cefa11fd31d40ce7a3757f3d7dff4

data/.travis.yml

@@ -1,10 +1,12 @@
+dist: trusty
+sudo: false
 language: ruby
 rvm:
-  - 2.3.1
-before_install: gem install bundler -v 1.12.5
+  - 2.3.3
 services:
   - postgresql
 addons:
-  postgresql: 9.4
+  postgresql: 9.6
 before_script:
   - psql -c 'CREATE DATABASE db_schema_test;' -U postgres
+  - psql -c 'CREATE DATABASE db_schema_test2;' -U postgres

data/README.md

@@ -53,7 +53,7 @@ But you would lose it even with manual migrations.
 Add this line to your application's Gemfile:
 
 ``` ruby
-gem 'db_schema', '~> 0.2.5'
+gem 'db_schema', '~> 0.3.rc1'
 ```
 
 And then execute:
@@ -65,7 +65,7 @@ $ bundle
 Or install it yourself as:
 
 ``` sh
-$ gem install db_schema
+$ gem install db_schema --prerelease
 ```
 
 ## Usage

data/lib/db_schema.rb

@@ -4,53 +4,51 @@ require 'yaml'
 require 'db_schema/configuration'
 require 'db_schema/utils'
 require 'db_schema/definitions'
+require 'db_schema/migration'
+require 'db_schema/operations'
 require 'db_schema/awesome_print'
 require 'db_schema/dsl'
 require 'db_schema/validator'
 require 'db_schema/normalizer'
 require 'db_schema/reader'
+require 'db_schema/migrator'
 require 'db_schema/changes'
 require 'db_schema/runner'
 require 'db_schema/version'
 
 module DbSchema
   class << self
-    def describe(&block)
-      desired_schema = DSL.new(block).schema
-      validate(desired_schema)
-      Normalizer.new(desired_schema).normalize_tables
-
-      actual_schema = Reader.read_schema
-      changes = Changes.between(desired_schema, actual_schema)
-      return if changes.empty?
-
-      log_changes(changes) if configuration.log_changes?
-      return if configuration.dry_run?
-
-      Runner.new(changes).run!
-
-      if configuration.post_check_enabled?
-        perform_post_check(desired_schema)
-      end
-    end
+    attr_reader :current_schema
 
-    def connection
-      @connection ||= Sequel.connect(
-        adapter:  configuration.adapter,
-        host:     configuration.host,
-        port:     configuration.port,
-        database: configuration.database,
-        user:     configuration.user,
-        password: configuration.password
-      ).tap do |db|
-        db.extension :pg_enum
-        db.extension :pg_array
+    def describe(&block)
+      with_connection do |connection|
+        desired = DSL.new(block)
+        validate(desired.schema)
+        Normalizer.new(desired.schema, connection).normalize_tables
+
+        connection.transaction do
+          actual_schema = run_migrations(desired.migrations, connection)
+          changes = Changes.between(desired.schema, actual_schema)
+          log_changes(changes) if configuration.log_changes?
+
+          if configuration.dry_run?
+            raise Sequel::Rollback
+          else
+            @current_schema = desired.schema
+            return if changes.empty?
+          end
+
+          Runner.new(changes, connection).run!
+
+          if configuration.post_check_enabled?
+            perform_post_check(desired.schema, connection)
+          end
+        end
       end
     end
 
-    def configure(connection_parameters)
-      @configuration = Configuration.new(connection_parameters)
-      @connection    = nil
+    def configure(params)
+      @configuration = configuration.merge(params)
     end
 
     def configure_from_yaml(yaml_path, environment, **other_options)
@@ -64,18 +62,43 @@ module DbSchema
       configure(renamed_data.merge(other_options))
     end
 
-    def configuration
-      raise 'You must call DbSchema.configure in order to connect to the database.' if @configuration.nil?
+    def connection=(external_connection)
+      @external_connection = external_connection
+    end
 
-      @configuration
+    def configuration
+      @configuration ||= Configuration.new
     end
 
     def reset!
+      @external_connection = nil
       @configuration = nil
-      @connection    = nil
+      @current_schema = nil
     end
 
   private
+    def with_connection
+      raise ArgumentError unless block_given?
+
+      if @external_connection
+        yield @external_connection
+      else
+        Sequel.connect(
+          adapter:  configuration.adapter,
+          host:     configuration.host,
+          port:     configuration.port,
+          database: configuration.database,
+          user:     configuration.user,
+          password: configuration.password
+        ) do |db|
+          db.extension :pg_enum
+          db.extension :pg_array
+
+          yield db
+        end
+      end
+    end
+
     def validate(schema)
       validation_result = Validator.validate(schema)
 
@@ -90,6 +113,26 @@ module DbSchema
       end
     end
 
+    def run_migrations(migrations, connection)
+      @current_schema = Reader.read_schema(connection)
+
+      migrations.reduce(@current_schema) do |schema, migration|
+        migrator = Migrator.new(migration)
+
+        if migrator.applicable?(schema)
+          log_migration(migration) if configuration.log_changes?
+          migrator.run!(connection)
+          Reader.read_schema(connection)
+        else
+          schema
+        end
+      end
+    end
+
+    def log_migration(migration)
+      puts "DbSchema is running migration #{migration.name.ai}"
+    end
+
     def log_changes(changes)
       return if changes.empty?
 
@@ -101,8 +144,8 @@ module DbSchema
       end
     end
 
-    def perform_post_check(desired_schema)
-      unapplied_changes = Changes.between(desired_schema, Reader.read_schema)
+    def perform_post_check(desired_schema, connection)
+      unapplied_changes = Changes.between(desired_schema, Reader.read_schema(connection))
       return if unapplied_changes.empty?
 
       readable_changes = if unapplied_changes.respond_to?(:ai)

data/lib/db_schema/awesome_print.rb

@@ -35,48 +35,49 @@ if defined?(AwesomePrint)
           :dbschema_enum
         when ::DbSchema::Definitions::Extension
           :dbschema_column_operation
-        when ::DbSchema::Changes::CreateTable
+        when ::DbSchema::Operations::CreateTable
           :dbschema_create_table
-        when ::DbSchema::Changes::DropTable
+        when ::DbSchema::Operations::DropTable
           :dbschema_drop_table
-        when ::DbSchema::Changes::AlterTable
+        when ::DbSchema::Operations::AlterTable
           :dbschema_alter_table
-        when ::DbSchema::Changes::CreateColumn
+        when ::DbSchema::Operations::CreateColumn
           :dbschema_create_column
-        when ::DbSchema::Changes::DropColumn
+        when ::DbSchema::Operations::DropColumn
           :dbschema_column_operation
-        when ::DbSchema::Changes::RenameColumn
-          :dbschema_rename_column
-        when ::DbSchema::Changes::AlterColumnType
+        when ::DbSchema::Operations::RenameTable,
+             ::DbSchema::Operations::RenameColumn
+          :dbschema_rename
+        when ::DbSchema::Operations::AlterColumnType
           :dbschema_alter_column_type
-        when ::DbSchema::Changes::CreatePrimaryKey,
-             ::DbSchema::Changes::DropPrimaryKey,
-             ::DbSchema::Changes::AllowNull,
-             ::DbSchema::Changes::DisallowNull
+        when ::DbSchema::Operations::CreatePrimaryKey,
+             ::DbSchema::Operations::DropPrimaryKey,
+             ::DbSchema::Operations::AllowNull,
+             ::DbSchema::Operations::DisallowNull
           :dbschema_column_operation
-        when ::DbSchema::Changes::AlterColumnDefault
+        when ::DbSchema::Operations::AlterColumnDefault
           :dbschema_alter_column_default
-        when ::DbSchema::Changes::CreateIndex
+        when ::DbSchema::Operations::CreateIndex
           :dbschema_create_index
-        when ::DbSchema::Changes::DropIndex
+        when ::DbSchema::Operations::DropIndex
           :dbschema_column_operation
-        when ::DbSchema::Changes::CreateCheckConstraint
+        when ::DbSchema::Operations::CreateCheckConstraint
           :dbschema_create_check_constraint
-        when ::DbSchema::Changes::DropCheckConstraint
+        when ::DbSchema::Operations::DropCheckConstraint
           :dbschema_column_operation
-        when ::DbSchema::Changes::CreateForeignKey
+        when ::DbSchema::Operations::CreateForeignKey
           :dbschema_create_foreign_key
-        when ::DbSchema::Changes::DropForeignKey
+        when ::DbSchema::Operations::DropForeignKey
           :dbschema_drop_foreign_key
-        when ::DbSchema::Changes::CreateEnum
+        when ::DbSchema::Operations::CreateEnum
           :dbschema_create_enum
-        when ::DbSchema::Changes::DropEnum
+        when ::DbSchema::Operations::DropEnum
           :dbschema_column_operation
-        when ::DbSchema::Changes::AlterEnumValues
+        when ::DbSchema::Operations::AlterEnumValues
           :dbschema_alter_enum_values
-        when ::DbSchema::Changes::CreateExtension
+        when ::DbSchema::Operations::CreateExtension
           :dbschema_create_extension
-        when ::DbSchema::Changes::DropExtension
+        when ::DbSchema::Operations::DropExtension
           :dbschema_column_operation
         else
           cast_without_dbschema(object, type)
@@ -202,27 +203,27 @@ if defined?(AwesomePrint)
         data << "checks: #{object.table.checks.ai}" if object.table.checks.any?
 
         data_string = indent_lines(data.join(', '))
-        "#<DbSchema::Changes::CreateTable #{object.table.name.ai} #{data_string}>"
+        "#<DbSchema::Operations::CreateTable #{object.table.name.ai} #{data_string}>"
       end
 
       def awesome_dbschema_drop_table(object)
-        "#<DbSchema::Changes::DropTable #{object.name.ai}>"
+        "#<DbSchema::Operations::DropTable #{object.name.ai}>"
       end
 
       def awesome_dbschema_alter_table(object)
-        "#<DbSchema::Changes::AlterTable #{object.table_name.ai} #{indent_lines(object.changes.ai)}>"
+        "#<DbSchema::Operations::AlterTable #{object.table_name.ai} #{indent_lines(object.changes.ai)}>"
       end
 
       def awesome_dbschema_create_column(object)
-        "#<DbSchema::Changes::CreateColumn #{object.field.ai}>"
+        "#<DbSchema::Operations::CreateColumn #{object.field.ai}>"
       end
 
       def awesome_dbschema_drop_column(object)
-        "#<DbSchema::Changes::DropColumn #{object.name.ai}>"
+        "#<DbSchema::Operations::DropColumn #{object.name.ai}>"
       end
 
-      def awesome_dbschema_rename_column(object)
-        "#<DbSchema::Changes::RenameColumn #{object.old_name.ai} => #{object.new_name.ai}>"
+      def awesome_dbschema_rename(object)
+        "#<#{object.class} #{object.old_name.ai} => #{object.new_name.ai}>"
       end
 
       def awesome_dbschema_alter_column_type(object)
@@ -231,7 +232,7 @@ if defined?(AwesomePrint)
           "#{key} #{v.ai}"
         end.unshift(nil).join(', ')
 
-        "#<DbSchema::Changes::AlterColumnType #{object.name.ai}, #{object.new_type.ai}#{attributes}>"
+        "#<DbSchema::Operations::AlterColumnType #{object.name.ai}, #{object.new_type.ai}#{attributes}>"
       end
 
       def awesome_dbschema_alter_column_default(object)
@@ -241,7 +242,7 @@ if defined?(AwesomePrint)
           object.new_default.ai
         end
 
-        "#<DbSchema::Changes::AlterColumnDefault #{object.name.ai}, #{new_default}>"
+        "#<DbSchema::Operations::AlterColumnDefault #{object.name.ai}, #{new_default}>"
       end
 
       def awesome_dbschema_create_index(object)
@@ -260,11 +261,11 @@ if defined?(AwesomePrint)
       end
 
       def awesome_dbschema_create_foreign_key(object)
-        "#<DbSchema::Changes::CreateForeignKey #{object.foreign_key.ai} on #{object.table_name.ai}>"
+        "#<DbSchema::Operations::CreateForeignKey #{object.foreign_key.ai} on #{object.table_name.ai}>"
       end
 
       def awesome_dbschema_drop_foreign_key(object)
-        "#<DbSchema::Changes::DropForeignKey #{object.fkey_name.ai} on #{object.table_name.ai}>"
+        "#<DbSchema::Operations::DropForeignKey #{object.fkey_name.ai} on #{object.table_name.ai}>"
       end
 
       def awesome_dbschema_create_enum(object)
@@ -284,7 +285,7 @@ if defined?(AwesomePrint)
           colorize(value.to_s, :string)
         end.join(', ')
 
-        "#<DbSchema::Changes::AlterEnumValues #{object.enum_name.ai} to (#{values})>"
+        "#<DbSchema::Operations::AlterEnumValues #{object.enum_name.ai} to (#{values})>"
       end
 
       def awesome_dbschema_create_extension(object)

data/lib/db_schema/changes.rb

@@ -12,17 +12,17 @@ module DbSchema
           actual  = actual_schema.tables.find  { |table| table.name == table_name }
 
           if desired && !actual
-            changes << CreateTable.new(desired)
+            changes << Operations::CreateTable.new(desired)
 
             fkey_operations = desired.foreign_keys.map do |fkey|
-              CreateForeignKey.new(table_name, fkey)
+              Operations::CreateForeignKey.new(table_name, fkey)
             end
             changes.concat(fkey_operations)
           elsif actual && !desired
-            changes << DropTable.new(table_name)
+            changes << Operations::DropTable.new(table_name)
 
             actual.foreign_keys.each do |fkey|
-              changes << DropForeignKey.new(table_name, fkey.name)
+              changes << Operations::DropForeignKey.new(table_name, fkey.name)
             end
           elsif actual != desired
             field_operations = field_changes(desired.fields, actual.fields)
@@ -31,9 +31,9 @@ module DbSchema
             fkey_operations  = foreign_key_changes(table_name, desired.foreign_keys, actual.foreign_keys)
 
             if field_operations.any? || index_operations.any? || check_operations.any?
-              changes << AlterTable.new(
+              changes << Operations::AlterTable.new(
                 table_name,
-                field_operations + index_operations + check_operations
+                sort_alter_table_changes(field_operations + index_operations + check_operations)
               )
             end
 
@@ -48,9 +48,9 @@ module DbSchema
           actual  = actual_schema.enums.find  { |enum| enum.name == enum_name }
 
           if desired && !actual
-            changes << CreateEnum.new(desired)
+            changes << Operations::CreateEnum.new(desired)
           elsif actual && !desired
-            changes << DropEnum.new(enum_name)
+            changes << Operations::DropEnum.new(enum_name)
           elsif actual != desired
             fields = actual_schema.tables.flat_map do |table|
               table.fields.select do |field|
@@ -73,17 +73,17 @@ module DbSchema
               end
             end
 
-            changes << AlterEnumValues.new(enum_name, desired.values, fields)
+            changes << Operations::AlterEnumValues.new(enum_name, desired.values, fields)
           end
         end
 
         extension_changes = (desired_schema.extensions - actual_schema.extensions).map do |extension|
-          CreateExtension.new(extension)
+          Operations::CreateExtension.new(extension)
         end + (actual_schema.extensions - desired_schema.extensions).map do |extension|
-          DropExtension.new(extension.name)
+          Operations::DropExtension.new(extension.name)
         end
 
-        table_changes + enum_changes + extension_changes
+        sort_all_changes(table_changes + enum_changes + extension_changes)
       end
 
     private
@@ -95,12 +95,12 @@ module DbSchema
           actual  = actual_fields.find  { |field| field.name == field_name }
 
           if desired && !actual
-            table_changes << CreateColumn.new(desired)
+            table_changes << Operations::CreateColumn.new(desired)
           elsif actual && !desired
-            table_changes << DropColumn.new(field_name)
+            table_changes << Operations::DropColumn.new(field_name)
           elsif actual != desired
             if (actual.type != desired.type) || (actual.attributes != desired.attributes)
-              table_changes << AlterColumnType.new(
+              table_changes << Operations::AlterColumnType.new(
                 field_name,
                 new_type: desired.type,
                 **desired.attributes
@@ -108,23 +108,23 @@ module DbSchema
             end
 
             if desired.primary_key? && !actual.primary_key?
-              table_changes << CreatePrimaryKey.new(field_name)
+              table_changes << Operations::CreatePrimaryKey.new(field_name)
             end
 
             if actual.primary_key? && !desired.primary_key?
-              table_changes << DropPrimaryKey.new(field_name)
+              table_changes << Operations::DropPrimaryKey.new(field_name)
             end
 
             if desired.null? && !actual.null?
-              table_changes << AllowNull.new(field_name)
+              table_changes << Operations::AllowNull.new(field_name)
             end
 
             if actual.null? && !desired.null?
-              table_changes << DisallowNull.new(field_name)
+              table_changes << Operations::DisallowNull.new(field_name)
             end
 
             if actual.default != desired.default
-              table_changes << AlterColumnDefault.new(field_name, new_default: desired.default)
+              table_changes << Operations::AlterColumnDefault.new(field_name, new_default: desired.default)
             end
           end
         end
@@ -138,12 +138,12 @@ module DbSchema
           actual  = actual_indices.find  { |index| index.name == index_name }
 
           if desired && !actual
-            table_changes << CreateIndex.new(desired)
+            table_changes << Operations::CreateIndex.new(desired)
           elsif actual && !desired
-            table_changes << DropIndex.new(index_name)
+            table_changes << Operations::DropIndex.new(index_name)
           elsif actual != desired
-            table_changes << DropIndex.new(index_name)
-            table_changes << CreateIndex.new(desired)
+            table_changes << Operations::DropIndex.new(index_name)
+            table_changes << Operations::CreateIndex.new(desired)
           end
         end
       end
@@ -156,12 +156,12 @@ module DbSchema
           actual  = actual_checks.find  { |check| check.name == check_name }
 
           if desired && !actual
-            table_changes << CreateCheckConstraint.new(desired)
+            table_changes << Operations::CreateCheckConstraint.new(desired)
           elsif actual && !desired
-            table_changes << DropCheckConstraint.new(check_name)
+            table_changes << Operations::DropCheckConstraint.new(check_name)
           elsif actual != desired
-            table_changes << DropCheckConstraint.new(check_name)
-            table_changes << CreateCheckConstraint.new(desired)
+            table_changes << Operations::DropCheckConstraint.new(check_name)
+            table_changes << Operations::CreateCheckConstraint.new(desired)
           end
         end
       end
@@ -174,202 +174,53 @@ module DbSchema
           actual  = actual_foreign_keys.find  { |key| key.name == key_name }
 
           if desired && !actual
-            table_changes << CreateForeignKey.new(table_name, desired)
+            table_changes << Operations::CreateForeignKey.new(table_name, desired)
           elsif actual && !desired
-            table_changes << DropForeignKey.new(table_name, key_name)
+            table_changes << Operations::DropForeignKey.new(table_name, key_name)
           elsif actual != desired
-            table_changes << DropForeignKey.new(table_name, key_name)
-            table_changes << CreateForeignKey.new(table_name, desired)
+            table_changes << Operations::DropForeignKey.new(table_name, key_name)
+            table_changes << Operations::CreateForeignKey.new(table_name, desired)
           end
         end
       end
-    end
-
-    class CreateTable
-      include Dry::Equalizer(:table)
-      attr_reader :table
-
-      def initialize(table)
-        @table = table
-      end
-    end
-
-    class DropTable
-      include Dry::Equalizer(:name)
-      attr_reader :name
-
-      def initialize(name)
-        @name = name
-      end
-    end
-
-    class AlterTable
-      include Dry::Equalizer(:table_name, :changes)
-      attr_reader :table_name, :changes
-
-      def initialize(table_name, changes)
-        @table_name = table_name
-        @changes    = changes
-      end
-    end
-
-    # Abstract base class for single-column toggle operations.
-    class ColumnOperation
-      include Dry::Equalizer(:name)
-      attr_reader :name
-
-      def initialize(name)
-        @name = name
-      end
-    end
-
-    class CreateColumn
-      include Dry::Equalizer(:field)
-      attr_reader :field
-
-      def initialize(field)
-        @field = field
-      end
-
-      def name
-        field.name
-      end
-
-      def type
-        field.type
-      end
-
-      def primary_key?
-        field.primary_key?
-      end
-
-      def options
-        field.options
-      end
-    end
-
-    class DropColumn < ColumnOperation
-    end
-
-    class RenameColumn
-      attr_reader :old_name, :new_name
-
-      def initialize(old_name:, new_name:)
-        @old_name = old_name
-        @new_name = new_name
-      end
-    end
-
-    class AlterColumnType
-      include Dry::Equalizer(:name, :new_type, :new_attributes)
-      attr_reader :name, :new_type, :new_attributes
-
-      def initialize(name, new_type:, **new_attributes)
-        @name           = name
-        @new_type       = new_type
-        @new_attributes = new_attributes
-      end
-    end
-
-    class CreatePrimaryKey < ColumnOperation
-    end
-
-    class DropPrimaryKey < ColumnOperation
-    end
-
-    class AllowNull < ColumnOperation
-    end
-
-    class DisallowNull < ColumnOperation
-    end
-
-    class AlterColumnDefault
-      include Dry::Equalizer(:name, :new_default)
-      attr_reader :name, :new_default
-
-      def initialize(name, new_default:)
-        @name        = name
-        @new_default = new_default
-      end
-    end
-
-    class CreateIndex
-      include Dry::Equalizer(:index)
-      attr_reader :index
-
-      def initialize(index)
-        @index = index
-      end
-    end
-
-    class DropIndex < ColumnOperation
-    end
-
-    class CreateCheckConstraint
-      include Dry::Equalizer(:check)
-      attr_reader :check
-
-      def initialize(check)
-        @check = check
-      end
-    end
-
-    class DropCheckConstraint < ColumnOperation
-    end
 
-    class CreateForeignKey
-      include Dry::Equalizer(:table_name, :foreign_key)
-      attr_reader :table_name, :foreign_key
-
-      def initialize(table_name, foreign_key)
-        @table_name  = table_name
-        @foreign_key = foreign_key
-      end
-    end
-
-    class DropForeignKey
-      include Dry::Equalizer(:table_name, :fkey_name)
-      attr_reader :table_name, :fkey_name
-
-      def initialize(table_name, fkey_name)
-        @table_name = table_name
-        @fkey_name  = fkey_name
+      def sort_all_changes(changes)
+        Utils.sort_by_class(
+          changes,
+          [
+            Operations::CreateExtension,
+            Operations::DropForeignKey,
+            Operations::AlterEnumValues,
+            Operations::CreateEnum,
+            Operations::CreateTable,
+            Operations::AlterTable,
+            Operations::DropTable,
+            Operations::DropEnum,
+            Operations::CreateForeignKey,
+            Operations::DropExtension
+          ]
+        )
+      end
+
+      def sort_alter_table_changes(changes)
+        Utils.sort_by_class(
+          changes,
+          [
+            Operations::DropPrimaryKey,
+            Operations::DropCheckConstraint,
+            Operations::DropIndex,
+            Operations::DropColumn,
+            Operations::AlterColumnType,
+            Operations::AllowNull,
+            Operations::DisallowNull,
+            Operations::AlterColumnDefault,
+            Operations::CreateColumn,
+            Operations::CreateIndex,
+            Operations::CreateCheckConstraint,
+            Operations::CreatePrimaryKey
+          ]
+        )
       end
     end
-
-    class CreateEnum
-      include Dry::Equalizer(:enum)
-      attr_reader :enum
-
-      def initialize(enum)
-        @enum = enum
-      end
-    end
-
-    class DropEnum < ColumnOperation
-    end
-
-    class AlterEnumValues
-      include Dry::Equalizer(:enum_name, :new_values, :enum_fields)
-      attr_reader :enum_name, :new_values, :enum_fields
-
-      def initialize(enum_name, new_values, enum_fields)
-        @enum_name   = enum_name
-        @new_values  = new_values
-        @enum_fields = enum_fields
-      end
-    end
-
-    class CreateExtension
-      include Dry::Equalizer(:extension)
-      attr_reader :extension
-
-      def initialize(extension)
-        @extension = extension
-      end
-    end
-
-    class DropExtension < ColumnOperation
-    end
   end
 end