db_schema 0.4.1 → 0.5.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a24b0939afdbb0a33cfc0b34f76a70059a22c995513c1c4fec7111b4b7096b2
-  data.tar.gz: 28c50f5ea2b03c1464bcff2dfc95e58569b1a2f08e4193e04336fec57295d600
+  metadata.gz: 1609672a54947a93c2953044d09ae26e4e5653105ca76455364e0746d0157372
+  data.tar.gz: 00c069c16b8f8414cacb529e2857c9cbd785e1534786282b6d89bfa966c31cde
 SHA512:
-  metadata.gz: c52517e5394f962f6121fd6728a9764055fb1d6ba0dc78817360106f986f2feca1c7e0dd992f7dc4e168112126656934e838132c0a780a4b6de154c4b6d05c73
-  data.tar.gz: be7a87847222b9bb7e23b6883f844d0923cc0538dd6c456be6facc6d03d0216b6ac21345089e2d1e910752e3712533ac808b980cadfc9c0339584994394723c4
+  metadata.gz: 22568b1fd6eeda2a067aec451d9c5e8a2e6ad88fa5cc5801bd4d90a9016394baa00e0b821dcb714d6ec8291462f07d3aebdd68525ad4b37b4b1b323cd641e6b7
+  data.tar.gz: d1ad3e5f0d74706bf1aefb41004d8b08cfd9e1d4e61db3a13fde05bdb18c707d52c277f3210fbd0d89f3453a4c9369fca02264ff9b1ed1a94d6aa1a4db5de07a

data/.travis.yml

@@ -2,9 +2,10 @@ dist: trusty
 sudo: false
 language: ruby
 rvm:
-  - 2.2.8
-  - 2.3.5
-  - 2.4.2
+  - 2.3.8
+  - 2.4.5
+  - 2.5.3
+  - 2.6.0
 services:
   - postgresql
 addons:

data/Gemfile

@@ -1,4 +1,7 @@
 source 'https://rubygems.org'
 
+gem 'db_schema-definitions', github: 'db-schema/definitions', branch: 'primary_keys'
+gem 'db_schema-reader-postgres', github: 'db-schema/reader-postgres', branch: 'primary_keys'
+
 # Specify your gem's dependencies in db_schema.gemspec
 gemspec

data/README.md

@@ -53,8 +53,8 @@ But you would lose it even with manual migrations.
 Add these lines to your application's Gemfile:
 
 ``` ruby
-gem 'db_schema', '~> 0.4.1'
-gem 'db_schema-reader-postgres', '~> 0.1.1'
+gem 'db_schema', '= 0.5.rc1'
+gem 'db_schema-reader-postgres', '= 0.2.rc1'
 ```
 
 And then execute:

data/db_schema.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency 'sequel'
   spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
-  spec.add_runtime_dependency 'db_schema-definitions', '~> 0.1.1'
+  spec.add_runtime_dependency 'db_schema-definitions', '= 0.2.rc1'
 
   spec.add_development_dependency 'bundler', '~> 1.11'
   spec.add_development_dependency 'rake', '~> 10.0'
@@ -32,5 +32,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'terminal-notifier'
   spec.add_development_dependency 'terminal-notifier-guard'
 
-  spec.add_development_dependency 'db_schema-reader-postgres', '~> 0.1.1'
+  spec.add_development_dependency 'db_schema-reader-postgres', '= 0.2.rc1'
 end

data/lib/db_schema/awesome_print.rb

@@ -13,33 +13,6 @@ if defined?(AwesomePrint)
 
       def cast_with_dbschema(object, type)
         case object
-        when ::DbSchema::Definitions::Schema
-          :dbschema_schema
-        when ::DbSchema::Definitions::NullTable,
-             ::DbSchema::Definitions::NullField,
-             ::DbSchema::Definitions::NullIndex,
-             ::DbSchema::Definitions::NullCheckConstraint,
-             ::DbSchema::Definitions::NullForeignKey,
-             ::DbSchema::Definitions::NullEnum
-          :dbschema_null_object
-        when ::DbSchema::Definitions::Table
-          :dbschema_table
-        when ::DbSchema::Definitions::Field::Custom
-          :dbschema_custom_field
-        when ::DbSchema::Definitions::Field::Base
-          :dbschema_field
-        when ::DbSchema::Definitions::Index
-          :dbschema_index
-        when ::DbSchema::Definitions::Index::Column
-          :dbschema_index_column
-        when ::DbSchema::Definitions::CheckConstraint
-          :dbschema_check_constraint
-        when ::DbSchema::Definitions::ForeignKey
-          :dbschema_foreign_key
-        when ::DbSchema::Definitions::Enum
-          :dbschema_enum
-        when ::DbSchema::Definitions::Extension
-          :dbschema_column_operation
         when ::DbSchema::Operations::CreateTable
           :dbschema_create_table
         when ::DbSchema::Operations::DropTable
@@ -58,6 +31,8 @@ if defined?(AwesomePrint)
           :dbschema_alter_column_default
         when ::DbSchema::Operations::CreateIndex
           :dbschema_create_index
+        when ::DbSchema::Operations::DropIndex
+          :dbschema_drop_index
         when ::DbSchema::Operations::CreateCheckConstraint
           :dbschema_create_check_constraint
         when ::DbSchema::Operations::CreateForeignKey
@@ -76,118 +51,6 @@ if defined?(AwesomePrint)
       end
 
     private
-      def awesome_dbschema_schema(object)
-        data = ["tables: #{object.tables.ai}"]
-        data << "enums: #{object.enums.ai}" if object.enums.any?
-        data << "extensions: #{object.extensions.ai}" if object.extensions.any?
-
-        data_string = data.join(', ')
-        "#<DbSchema::Definitions::Schema #{data_string}>"
-      end
-
-      def awesome_dbschema_table(object)
-        data = ["fields: #{object.fields.ai}"]
-        data << "indexes: #{object.indexes.ai}" if object.indexes.any?
-        data << "checks: #{object.checks.ai}" if object.checks.any?
-        data << "foreign_keys: #{object.foreign_keys.ai}" if object.foreign_keys.any?
-
-        data_string = indent_lines(data.join(', '))
-        "#<DbSchema::Definitions::Table #{object.name.ai} #{data_string}>"
-      end
-
-      def awesome_dbschema_null_object(object)
-        "#<#{object.class}>"
-      end
-
-      def awesome_dbschema_field(object)
-        options = object.options.map do |k, v|
-          key = colorize("#{k}:", :symbol)
-
-          if (k == :default) && v.is_a?(Symbol)
-            "#{key} #{colorize(v.to_s, :string)}"
-          else
-            "#{key} #{v.ai}"
-          end
-        end.unshift(nil).join(', ')
-
-        primary_key = if object.primary_key?
-          ', ' + colorize('primary key', :nilclass)
-        else
-          ''
-        end
-
-        "#<#{object.class} #{object.name.ai}#{options}#{primary_key}>"
-      end
-
-      def awesome_dbschema_custom_field(object)
-        options = object.options.map do |k, v|
-          key = colorize("#{k}:", :symbol)
-
-          if (k == :default) && v.is_a?(Symbol)
-            "#{key} #{colorize(v.to_s, :string)}"
-          else
-            "#{key} #{v.ai}"
-          end
-        end.unshift(nil).join(', ')
-
-        primary_key = if object.primary_key?
-          ', ' + colorize('primary key', :nilclass)
-        else
-          ''
-        end
-
-        "#<DbSchema::Definitions::Field::Custom (#{object.type.ai}) #{object.name.ai}#{options}#{primary_key}>"
-      end
-
-      def awesome_dbschema_index(object)
-        columns = format_dbschema_fields(object.columns)
-        using = ' using ' + colorize(object.type.to_s, :symbol) unless object.btree?
-
-        data = [nil]
-        data << colorize('unique', :nilclass) if object.unique?
-        data << colorize('condition: ', :symbol) + object.condition.ai unless object.condition.nil?
-
-        "#<#{object.class} #{object.name.ai} on #{columns}#{using}#{data.join(', ')}>"
-      end
-
-      def awesome_dbschema_index_column(object)
-        data = [object.name.ai]
-
-        if object.desc?
-          data << colorize('desc', :nilclass)
-          data << colorize('nulls last', :symbol) if object.nulls == :last
-        else
-          data << colorize('nulls first', :symbol) if object.nulls == :first
-        end
-
-        data.join(' ')
-      end
-
-      def awesome_dbschema_check_constraint(object)
-        "#<#{object.class} #{object.name.ai} #{object.condition.ai}>"
-      end
-
-      def awesome_dbschema_foreign_key(object)
-        fields = format_dbschema_fields(object.fields)
-        references = "#{colorize('references', :class)} #{object.table.ai}"
-        references << ' ' + format_dbschema_fields(object.keys) unless object.references_primary_key?
-
-        data = [nil]
-        data << colorize("on_update:", :symbol) + " #{object.on_update.ai}" unless object.on_update == :no_action
-        data << colorize("on_delete:", :symbol) + " #{object.on_delete.ai}" unless object.on_delete == :no_action
-        data << colorize('deferrable', :nilclass) if object.deferrable?
-
-        "#<#{object.class} #{object.name.ai} on #{fields} #{references}#{data.join(', ')}>"
-      end
-
-      def awesome_dbschema_enum(object)
-        values = object.values.map do |value|
-          colorize(value.to_s, :string)
-        end.join(', ')
-
-        "#<#{object.class} #{object.name.ai} (#{values})>"
-      end
-
       def awesome_dbschema_create_table(object)
         data = ["fields: #{object.table.fields.ai}"]
         data << "indexes: #{object.table.indexes.ai}" if object.table.indexes.any?
@@ -241,12 +104,20 @@ if defined?(AwesomePrint)
         using = ' using ' + colorize(object.index.type.to_s, :symbol) unless object.index.btree?
 
         data = [nil]
+        data << colorize('primary key', :nilclass) if object.index.primary?
         data << colorize('unique', :nilclass) if object.index.unique?
         data << colorize('condition: ', :symbol) + object.index.condition.ai unless object.index.condition.nil?
 
         "#<#{object.class} #{object.index.name.ai} on #{columns}#{using}#{data.join(', ')}>"
       end
 
+      def awesome_dbschema_drop_index(object)
+        data = [object.name.ai]
+        data << colorize('primary key', :nilclass) if object.primary?
+
+        "#<#{object.class} #{data.join(' ')}>"
+      end
+
       def awesome_dbschema_create_check_constraint(object)
         "#<#{object.class} #{object.check.name.ai} #{object.check.condition.ai}>"
       end

data/lib/db_schema/changes.rb

@@ -67,19 +67,12 @@ module DbSchema
               if (actual.type != desired.type) || (actual.attributes != desired.attributes)
                 operations << Operations::AlterColumnType.new(
                   actual.name,
+                  old_type: actual.type,
                   new_type: desired.type,
                   **desired.attributes
                 )
               end
 
-              if desired.primary_key? && !actual.primary_key?
-                operations << Operations::CreatePrimaryKey.new(actual.name)
-              end
-
-              if actual.primary_key? && !desired.primary_key?
-                operations << Operations::DropPrimaryKey.new(actual.name)
-              end
-
               if desired.null? && !actual.null?
                 operations << Operations::AllowNull.new(actual.name)
               end
@@ -101,10 +94,10 @@ module DbSchema
           desired_table.indexes,
           actual_table.indexes,
           create: -> (index) { Operations::CreateIndex.new(index) },
-          drop:   -> (index) { Operations::DropIndex.new(index.name) },
+          drop:   -> (index) { Operations::DropIndex.new(index.name, index.primary?) },
           change: -> (desired, actual) do
             [
-              Operations::DropIndex.new(actual.name),
+              Operations::DropIndex.new(actual.name, actual.primary?),
               Operations::CreateIndex.new(desired)
             ]
           end
@@ -220,7 +213,6 @@ module DbSchema
         Utils.sort_by_class(
           changes,
           [
-            Operations::DropPrimaryKey,
             Operations::DropCheckConstraint,
             Operations::DropIndex,
             Operations::DropColumn,
@@ -230,8 +222,7 @@ module DbSchema
             Operations::AlterColumnDefault,
             Operations::CreateColumn,
             Operations::CreateIndex,
-            Operations::CreateCheckConstraint,
-            Operations::CreatePrimaryKey
+            Operations::CreateCheckConstraint
           ]
         )
       end

data/lib/db_schema/dsl.rb

@@ -16,7 +16,7 @@ module DbSchema
 
       @schema.tables << Definitions::Table.new(
         name,
-        fields:       table_yielder.fields,
+        fields:       prepare_fields(table_yielder),
         indexes:      table_yielder.indexes,
         checks:       table_yielder.checks,
         foreign_keys: table_yielder.foreign_keys
@@ -35,6 +35,20 @@ module DbSchema
       migrations << Migration.new(name, block).migration
     end
 
+  private
+    def prepare_fields(table_yielder)
+      primary_key = table_yielder.indexes.find(&:primary?)
+      return table_yielder.fields if primary_key.nil?
+
+      table_yielder.fields.map do |field|
+        if primary_key.columns.map(&:name).include?(field.name)
+          field.with_null(false)
+        else
+          field
+        end
+      end
+    end
+
     class TableYielder
       attr_reader :table_name
 
@@ -55,12 +69,19 @@ module DbSchema
         field(name, :array, element_type: of, **options)
       end
 
+      %i(smallserial serial bigserial).each do |serial_type|
+        define_method(serial_type) do |name, **options|
+          allowed_options = Utils.filter_by_keys(options, :primary_key, :unique, :index, :references, :check)
+          field(name, serial_type, null: false, **allowed_options)
+        end
+      end
+
       def method_missing(method_name, name, *args, &block)
         field(name, method_name, args.first || {})
       end
 
-      def primary_key(name)
-        field(name, :integer, primary_key: true)
+      def primary_key(*columns, name: nil)
+        index(*columns, name: name, primary: true, unique: true)
       end
 
       def index(*columns, **index_options)
@@ -83,9 +104,13 @@ module DbSchema
         )
       end
 
-      def field(name, type, unique: false, index: false, references: nil, check: nil, **options)
+      def field(name, type, primary_key: false, unique: false, index: false, references: nil, check: nil, **options)
         fields << Definitions::Field.build(name, type, options)
 
+        if primary_key
+          primary_key(name)
+        end
+
         if unique
           index(name, unique: true)
         elsif index
@@ -118,7 +143,7 @@ module DbSchema
       end
 
       class << self
-        def build_index(columns, table_name:, name: nil, unique: false, using: :btree, where: nil, **ordered_fields)
+        def build_index(columns, table_name:, name: nil, primary: false, unique: false, using: :btree, where: nil, **ordered_fields)
           if columns.last.is_a?(Hash)
             *ascending_columns, ordered_expressions = columns
           else
@@ -151,11 +176,16 @@ module DbSchema
             end
           end
 
-          index_name = name || "#{table_name}_#{index_columns.map(&:index_name_segment).join('_')}_index"
+          index_name = name || if primary
+            "#{table_name}_pkey"
+          else
+            "#{table_name}_#{index_columns.map(&:index_name_segment).join('_')}_index"
+          end
 
           Definitions::Index.new(
             name:      index_name,
             columns:   index_columns,
+            primary:   primary,
             unique:    unique,
             type:      using,
             condition: where

data/lib/db_schema/migrator.rb

@@ -86,6 +86,7 @@ module DbSchema
         def alter_column_type(name, new_type, using: nil, **new_attributes)
           alter_table.changes << Operations::AlterColumnType.new(
             name,
+            old_type: nil,
             new_type: new_type,
             using: using,
             **new_attributes
@@ -104,6 +105,16 @@ module DbSchema
           alter_table.changes << Operations::AlterColumnDefault.new(name, new_default: new_default)
         end
 
+        def add_primary_key(*columns)
+          alter_table.changes << Operations::CreateIndex.new(
+            DSL::TableYielder.build_index(columns, table_name: alter_table.table_name, primary: true)
+          )
+        end
+
+        def drop_primary_key
+          alter_table.changes << Operations::DropIndex.new(:"#{alter_table.table_name}_pkey", true)
+        end
+
         def add_index(*columns, **index_options)
           alter_table.changes << Operations::CreateIndex.new(
             DSL::TableYielder.build_index(
@@ -115,7 +126,7 @@ module DbSchema
         end
 
         def drop_index(name)
-          alter_table.changes << Operations::DropIndex.new(name)
+          alter_table.changes << Operations::DropIndex.new(name, false)
         end
 
         def add_check(name, condition)

data/lib/db_schema/normalizer.rb

@@ -13,10 +13,12 @@ module DbSchema
       connection.transaction do
         create_extensions!
         create_enums!
+        create_temporary_tables!
+        normalized_tables = read_temporary_tables
 
         schema.tables = schema.tables.map do |table|
           if table.has_expressions?
-            Table.new(table, hash, schema.enums.map(&:name), connection).normalized_table
+            normalized_tables.fetch(table.name)
           else
             table
           end
@@ -43,37 +45,10 @@ module DbSchema
       Runner.new(operations, connection).run!
     end
 
-    def append_hash(name)
-      "#{name}_#{hash}"
-    end
-
-    def hash
-      @hash ||= begin
-        names = schema.tables.flat_map do |table|
-          [table.name] + table.fields.map(&:name) + table.indexes.map(&:name) + table.checks.map(&:name)
-        end
-
-        Digest::MD5.hexdigest(names.join(','))[0..9]
-      end
-    end
-
-    class Table
-      attr_reader :table, :hash, :enum_names, :connection
-
-      def initialize(table, hash, enum_names, connection)
-        @table      = table
-        @hash       = hash
-        @enum_names = enum_names
-        @connection = connection
-      end
+    def create_temporary_tables!
+      schema.tables.select(&:has_expressions?).each do |table|
+        temporary_table_name = append_hash(table.name)
 
-      def normalized_table
-        create_temporary_table!
-        read_temporary_table
-      end
-
-    private
-      def create_temporary_table!
         operation = Operations::CreateTable.new(
           table.with_name(temporary_table_name)
             .with_fields(rename_types(table.fields))
@@ -83,113 +58,127 @@ module DbSchema
 
         Runner.new([operation], connection).run!
       end
+    end
 
-      def read_temporary_table
-        temporary_table = Reader.reader_for(connection).read_table(temporary_table_name)
-
-        temporary_table.with_name(table.name)
-          .with_fields(rename_types_back(temporary_table.fields))
-          .with_indexes(rename_indexes_back(temporary_table.indexes))
-          .with_checks(rename_types_in_checks_back(temporary_table.checks))
-          .with_foreign_keys(table.foreign_keys)
-      end
+    def read_temporary_tables
+      all_tables = Reader.reader_for(connection).read_tables
 
-      def rename_types(fields)
-        fields.map do |field|
-          new_default = if field.default_is_expression?
-            rename_all_types_in(field.default.to_s).to_sym
-          else
-            field.default
-          end
+      schema.tables.select(&:has_expressions?).reduce({}) do |normalized_tables, table|
+        temporary_table = all_tables.find do |t|
+          t.name == append_hash(table.name).to_sym
+        end || raise
 
-          if field.custom?
-            field.with_type(append_hash(field.type))
-          elsif field.array? && field.custom_element_type?
-            field.with_attribute(:element_type, append_hash(field.element_type.type).to_sym)
-          else
-            field
-          end.with_default(new_default)
-        end
+        normalized_tables.merge(
+          table.name => temporary_table.with_name(table.name)
+                          .with_fields(rename_types_back(temporary_table.fields))
+                          .with_indexes(rename_indexes_back(temporary_table.indexes))
+                          .with_checks(rename_types_in_checks_back(temporary_table.checks))
+                          .with_foreign_keys(table.foreign_keys)
+        )
       end
+    end
 
-      def rename_types_back(fields)
-        fields.map do |field|
-          new_default = if field.default_is_expression?
-            rename_all_types_back_in(field.default.to_s).to_sym
-          else
-            field.default
-          end
-
-          if field.custom?
-            field.with_type(remove_hash(field.type))
-          elsif field.array? && field.custom_element_type?
-            field.with_attribute(:element_type, remove_hash(field.element_type.type).to_sym)
-          else
-            field
-          end.with_default(new_default)
+    def rename_types(fields)
+      fields.map do |field|
+        new_default = if field.default_is_expression?
+          rename_all_types_in(field.default.to_s).to_sym
+        else
+          field.default
         end
-      end
 
-      def rename_indexes(indexes)
-        indexes.map do |index|
-          index
-            .with_name(append_hash(index.name))
-            .with_condition(rename_all_types_in(index.condition))
-        end
+        if field.custom?
+          field.with_type(append_hash(field.type))
+        elsif field.array? && field.custom_element_type?
+          field.with_attribute(:element_type, append_hash(field.element_type.type).to_sym)
+        else
+          field
+        end.with_default(new_default)
       end
+    end
 
-      def rename_indexes_back(indexes)
-        indexes.map do |index|
-          index
-            .with_name(remove_hash(index.name))
-            .with_condition(rename_all_types_back_in(index.condition))
+    def rename_types_back(fields)
+      fields.map do |field|
+        new_default = if field.default_is_expression?
+          rename_all_types_back_in(field.default.to_s).to_sym
+        else
+          field.default
         end
-      end
 
-      def rename_types_in_checks(checks)
-        checks.map do |check|
-          check.with_condition(rename_all_types_in(check.condition))
-        end
+        if field.custom?
+          field.with_type(remove_hash(field.type))
+        elsif field.array? && field.custom_element_type?
+          field.with_attribute(:element_type, remove_hash(field.element_type.type).to_sym)
+        else
+          field
+        end.with_default(new_default)
       end
+    end
 
-      def rename_types_in_checks_back(checks)
-        checks.map do |check|
-          check.with_condition(rename_all_types_back_in(check.condition))
-        end
+    def rename_indexes(indexes)
+      indexes.map do |index|
+        index
+          .with_name(append_hash(index.name))
+          .with_condition(rename_all_types_in(index.condition))
       end
+    end
 
-      def temporary_table_name
-        append_hash(table.name)
+    def rename_indexes_back(indexes)
+      indexes.map do |index|
+        index
+          .with_name(remove_hash(index.name))
+          .with_condition(rename_all_types_back_in(index.condition))
       end
+    end
 
-      def append_hash(name)
-        "#{name}_#{hash}"
+    def rename_types_in_checks(checks)
+      checks.map do |check|
+        check.with_condition(rename_all_types_in(check.condition))
       end
+    end
 
-      def remove_hash(name)
-        name.to_s.sub(/_#{Regexp.escape(hash)}$/, '').to_sym
+    def rename_types_in_checks_back(checks)
+      checks.map do |check|
+        check.with_condition(rename_all_types_back_in(check.condition))
       end
+    end
 
-      def rename_all_types_in(string)
-        return string unless string.is_a?(String)
+    def append_hash(name)
+      "#{name}_#{hash}"
+    end
 
-        enum_renaming.reduce(string) do |new_string, (from, to)|
-          new_string.gsub(from, to)
-        end
+    def remove_hash(name)
+      name.to_s.sub(/_#{Regexp.escape(hash)}$/, '').to_sym
+    end
+
+    def rename_all_types_in(string)
+      return string unless string.is_a?(String)
+
+      enum_renaming.reduce(string) do |new_string, (from, to)|
+        new_string.gsub(from, to)
       end
+    end
 
-      def rename_all_types_back_in(string)
-        return string unless string.is_a?(String)
+    def rename_all_types_back_in(string)
+      return string unless string.is_a?(String)
 
-        enum_renaming.invert.reduce(string) do |new_string, (from, to)|
-          new_string.gsub(from, to)
-        end
+      enum_renaming.invert.reduce(string) do |new_string, (from, to)|
+        new_string.gsub(from, to)
       end
+    end
 
-      def enum_renaming
-        enum_names.reduce({}) do |hash, enum_name|
-          hash.merge("::#{enum_name}" => "::#{append_hash(enum_name)}")
+    def enum_renaming
+      schema.enums.reduce({}) do |hash, enum|
+        hash.merge("::#{enum.name}" => "::#{append_hash(enum.name)}")
+      end
+    end
+
+    def hash
+      @hash ||= begin
+        names = schema.tables.flat_map do |table|
+          [table.name] + table.fields.map(&:name) + table.indexes.map(&:name) + table.checks.map(&:name)
         end
+
+        Digest::MD5.hexdigest(names.join(','))[0..9]
       end
     end
   end

data/lib/db_schema/operations.rb

@@ -68,10 +68,6 @@ module DbSchema
         field.type
       end
 
-      def primary_key?
-        field.primary_key?
-      end
-
       def options
         field.options
       end
@@ -84,21 +80,26 @@ module DbSchema
     end
 
     class AlterColumnType
-      include Dry::Equalizer(:name, :new_type, :using, :new_attributes)
-      attr_reader :name, :new_type, :using, :new_attributes
+      SERIAL_TYPES = [:smallserial, :serial, :bigserial].freeze
+
+      include Dry::Equalizer(:name, :old_type, :new_type, :using, :new_attributes)
+      attr_reader :name, :old_type, :new_type, :using, :new_attributes
 
-      def initialize(name, new_type:, using: nil, **new_attributes)
+      def initialize(name, old_type:, new_type:, using: nil, **new_attributes)
         @name           = name
+        @old_type       = old_type
         @new_type       = new_type
         @using          = using
         @new_attributes = new_attributes
       end
-    end
 
-    class CreatePrimaryKey < ColumnOperation
-    end
+      def from_serial?
+        SERIAL_TYPES.include?(old_type)
+      end
 
-    class DropPrimaryKey < ColumnOperation
+      def to_serial?
+        SERIAL_TYPES.include?(new_type)
+      end
     end
 
     class AllowNull < ColumnOperation
@@ -124,9 +125,32 @@ module DbSchema
       def initialize(index)
         @index = index
       end
+
+      def primary?
+        index.primary?
+      end
+
+      def name
+        index.name
+      end
+
+      def columns
+        index.columns
+      end
     end
 
-    class DropIndex < ColumnOperation
+    class DropIndex
+      include Dry::Equalizer(:name, :primary?)
+      attr_reader :name
+
+      def initialize(name, primary)
+        @name    = name
+        @primary = primary
+      end
+
+      def primary?
+        @primary
+      end
     end
 
     class CreateCheckConstraint

data/lib/db_schema/runner.rb

@@ -44,24 +44,22 @@ module DbSchema
     def create_table(change)
       connection.create_table(change.table.name) do
         change.table.fields.each do |field|
-          if field.primary_key? && field.type == :integer
-            primary_key(field.name)
-          else
-            options = Runner.map_options(field.class.type, field.options)
-            column(field.name, field.type.capitalize, options)
-
-            primary_key([field.name]) if field.primary_key?
-          end
+          options = Runner.map_options(field.class.type, field.options)
+          column(field.name, field.type.capitalize, options)
         end
 
         change.table.indexes.each do |index|
-          index(
-            index.columns_to_sequel,
-            name:   index.name,
-            unique: index.unique?,
-            type:   index.type,
-            where:  index.condition
-          )
+          if index.primary?
+            primary_key(index.columns.map(&:name), name: index.name)
+          else
+            index(
+              index.columns_to_sequel,
+              name:   index.name,
+              unique: index.unique?,
+              type:   index.type,
+              where:  index.condition
+            )
+          end
         end
 
         change.table.checks.each do |check|
@@ -83,25 +81,23 @@ module DbSchema
         change.changes.each do |element|
           case element
           when Operations::CreateColumn
-            if element.primary_key? && element.type == :integer
-              add_primary_key(element.name)
-            else
-              options = Runner.map_options(element.type, element.options)
-              add_column(element.name, element.type.capitalize, options)
-
-              add_primary_key([element.name]) if element.primary_key?
-            end
+            options = Runner.map_options(element.type, element.options)
+            add_column(element.name, element.type.capitalize, options)
           when Operations::DropColumn
             drop_column(element.name)
           when Operations::RenameColumn
             rename_column(element.old_name, element.new_name)
           when Operations::AlterColumnType
+            if element.from_serial?
+              raise NotImplementedError, 'Changing a SERIAL column to another type is not supported'
+            end
+
+            if element.to_serial?
+              raise NotImplementedError, 'Changing a column type to SERIAL is not supported'
+            end
+
             attributes = Runner.map_options(element.new_type, element.new_attributes)
             set_column_type(element.name, element.new_type.capitalize, using: element.using, **attributes)
-          when Operations::CreatePrimaryKey
-            raise NotImplementedError, 'Converting an existing column to primary key is currently unsupported'
-          when Operations::DropPrimaryKey
-            raise NotImplementedError, 'Removing a primary key while leaving the column is currently unsupported'
           when Operations::AllowNull
             set_column_allow_null(element.name)
           when Operations::DisallowNull
@@ -109,15 +105,23 @@ module DbSchema
           when Operations::AlterColumnDefault
             set_column_default(element.name, Runner.default_to_sequel(element.new_default))
           when Operations::CreateIndex
-            add_index(
-              element.index.columns_to_sequel,
-              name:   element.index.name,
-              unique: element.index.unique?,
-              type:   element.index.type,
-              where:  element.index.condition
-            )
+            if element.primary?
+              add_primary_key(element.columns.map(&:name), name: element.name)
+            else
+              add_index(
+                element.index.columns_to_sequel,
+                name:   element.index.name,
+                unique: element.index.unique?,
+                type:   element.index.type,
+                where:  element.index.condition
+              )
+            end
           when Operations::DropIndex
-            drop_index([], name: element.name)
+            if element.primary?
+              drop_constraint(element.name)
+            else
+              drop_index([], name: element.name)
+            end
           when Operations::CreateCheckConstraint
             add_constraint(element.check.name, element.check.condition)
           when Operations::DropCheckConstraint

data/lib/db_schema/validator.rb

@@ -5,7 +5,7 @@ module DbSchema
     class << self
       def validate(schema)
         table_errors = schema.tables.each_with_object([]) do |table, errors|
-          primary_keys_count = table.fields.select(&:primary_key?).count
+          primary_keys_count = table.indexes.select(&:primary?).count
           if primary_keys_count > 1
             error_message = %(Table "#{table.name}" has #{primary_keys_count} primary keys)
             errors << error_message
@@ -60,7 +60,7 @@ module DbSchema
 
             if referenced_table = schema.tables.find { |table| table.name == fkey.table }
               if fkey.references_primary_key?
-                unless referenced_table.fields.any?(&:primary_key?)
+                unless referenced_table.indexes.any?(&:primary?)
                   error_message = %(Foreign key "#{fkey.name}" refers to primary key of table "#{fkey.table}" which does not have a primary key)
                   errors << error_message
                 end

data/lib/db_schema/version.rb

@@ -1,3 +1,3 @@
 module DbSchema
-  VERSION = '0.4.1'
+  VERSION = '0.5.rc1'
 end

data/lib/db_schema.rb

@@ -114,8 +114,7 @@ module DbSchema
     end
 
     def run_migrations(migrations, connection)
-      reader = Reader.reader_for(connection)
-      @current_schema = reader.read_schema
+      @current_schema = Reader.reader_for(connection).read_schema
 
       migrations.reduce(@current_schema) do |schema, migration|
         migrator = Migrator.new(migration)
@@ -123,7 +122,7 @@ module DbSchema
         if migrator.applicable?(schema)
           log_migration(migration) if configuration.log_changes?
           migrator.run!(connection)
-          reader.read_schema
+          Reader.reader_for(connection).read_schema
         else
           schema
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: db_schema
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.rc1
 platform: ruby
 authors:
 - Vsevolod Romashov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-04 00:00:00.000000000 Z
+date: 2019-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -42,16 +42,16 @@ dependencies:
   name: db_schema-definitions
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.1.1
+        version: 0.2.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.1.1
+        version: 0.2.rc1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -168,16 +168,16 @@ dependencies:
   name: db_schema-reader-postgres
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.1.1
+        version: 0.2.rc1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.1.1
+        version: 0.2.rc1
 description: A database schema management tool that reads a "single-source-of-truth"
   schema definition from a ruby file and auto-migrates the database to conform to
   it.
@@ -228,12 +228,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Declarative database schema definition.