db_schema 0.3 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 216fab4c9e20545d7653f46cdb5fe9ce5528a68a
-  data.tar.gz: a3115a63fd0a6da8289d1b7e6848e57620785563
+  metadata.gz: 92f4601dd7a4513014fd782391bfe69f8400f06d
+  data.tar.gz: 291caae43bf4582dbf0636b8601de86ebdcf3c25
 SHA512:
-  metadata.gz: 2ef95f7dcf532b83a288423f0626943479a4353797e281e0df5aa0788508811b19de3382576a7ed78f40c0b664bcd7f455ce12c335cf8c7a59cbdf33eccf093c
-  data.tar.gz: 660d11cc3e03fb68b2227ebe4f6febb544d17454d842daa6ad6d8d5cc8ec8af550f3e6ef936c8a7cf18f177ec1edfc56c792e4c0f51407b509868acd39b16b0d
+  metadata.gz: 7a8af71a493a89113166e8a1ee0fa1808ba8bbbcbb07b263fa0d9f0884eafe4d297e64d79815a854f460ad78af3bd0c847c82741c96d5175e127452a1333120d
+  data.tar.gz: 41fb922d5f307c481f3595d27983c39a13640cd2c5cdc5e9e6a395ad34c509cf712f4d08f79825c730462855c9d66d178961bb1d48d77b599386e10ab90b831a

data/.rspec

@@ -1,2 +1,3 @@
 --format documentation
 --color
+--require spec_helper

data/README.md

@@ -1,4 +1,4 @@
-# DbSchema [![Build Status](https://travis-ci.org/7even/db_schema.svg?branch=master)](https://travis-ci.org/7even/db_schema) [![Gem Version](https://badge.fury.io/rb/db_schema.svg)](https://badge.fury.io/rb/db_schema) [![Join the chat at https://gitter.im/7even/db_schema](https://badges.gitter.im/7even/db_schema.svg)](https://gitter.im/7even/db_schema?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+# DbSchema [![Build Status](https://travis-ci.org/db-schema/core.svg?branch=master)](https://travis-ci.org/db-schema/core) [![Gem Version](https://badge.fury.io/rb/db_schema.svg)](https://badge.fury.io/rb/db_schema) [![Join the chat at https://gitter.im/7even/db_schema](https://badges.gitter.im/7even/db_schema.svg)](https://gitter.im/7even/db_schema?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 DbSchema is an opinionated database schema management tool that lets you maintain your DB schema with a single ruby file.
 
@@ -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.3.0'
+gem 'db_schema', '~> 0.3.1'
 ```
 
 And then execute:
@@ -83,7 +83,7 @@ DbSchema.configure(
 ```
 
 There is also a Rails' `database.yml`-compatible `configure_from_yaml` method. DbSchema configuration
-is discussed in detail [here](https://github.com/7even/db_schema/wiki/Configuration).
+is discussed in detail [here](https://github.com/db-schema/core/wiki/Configuration).
 
 After DbSchema is configured you can load your schema definition file:
 
@@ -113,7 +113,7 @@ DbSchema.describe do |db|
 end
 ```
 
-Database schema definition DSL is documented [here](https://github.com/7even/db_schema/wiki/Schema-definition-DSL).
+Database schema definition DSL is documented [here](https://github.com/db-schema/core/wiki/Schema-definition-DSL).
 
 If you want to analyze your database structure in any way from your app (e.g. defining methods
 with `#define_method` for each enum value) you can use `DbSchema.current_schema` - it returns
@@ -121,7 +121,7 @@ a cached copy of the database structure as a `DbSchema::Definitions::Schema` obj
 can query in different ways. It is available after the schema was applied by DbSchema
 (`DbSchema.describe` remembers the current schema of the database and exposes it
 at `.current_schema`). Documentation for schema analysis DSL can be found
-[here](https://github.com/7even/db_schema/wiki/Schema-analysis-DSL).
+[here](https://github.com/db-schema/core/wiki/Schema-analysis-DSL).
 
 ### Production setup
 
@@ -217,12 +217,12 @@ instead you have to provide some conditions required to run the migration (the g
 conditions that a) will only trigger if the migration wasn't applied yet and b) are necessary for the
 migration to work) - like "rename the `users`
 table to `people` only if the database has a `users` table" (DbSchema also provides
-a [simple DSL](https://github.com/7even/db_schema/wiki/Schema-analysis-DSL) for schema analysis).
+a [simple DSL](https://github.com/db-schema/core/wiki/Schema-analysis-DSL) for schema analysis).
 This way the migration won't be applied again and the whole DbSchema process stays idempotent.
 Also you don't have to keep these migrations forever - once a migration is applied to databases
 in all environments you can safely delete it (though you can give your teammates a week or two to keep up).
 
-Conditional migrations are described [here](https://github.com/7even/db_schema/wiki/Conditional-Migrations).
+Conditional migrations are described [here](https://github.com/db-schema/core/wiki/Conditional-Migrations).
 
 ## Known problems and limitations
 
@@ -237,7 +237,7 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at [7even/db_schema](https://github.com/7even/db_schema).
+Bug reports and pull requests are welcome on GitHub at [db-schema/core](https://github.com/db-schema/core).
 
 ## License
 

data/db_schema.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
 
   spec.summary       = 'Declarative database schema definition.'
   spec.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.'
-  spec.homepage      = 'https://github.com/7even/db_schema'
+  spec.homepage      = 'https://github.com/db-schema/core'
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r(^spec/)) }

data/lib/db_schema/awesome_print.rb

@@ -87,7 +87,7 @@ if defined?(AwesomePrint)
 
       def awesome_dbschema_table(object)
         data = ["fields: #{object.fields.ai}"]
-        data << "indices: #{object.indices.ai}" if object.indices.any?
+        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?
 
@@ -190,7 +190,7 @@ if defined?(AwesomePrint)
 
       def awesome_dbschema_create_table(object)
         data = ["fields: #{object.table.fields.ai}"]
-        data << "indices: #{object.table.indices.ai}" if object.table.indices.any?
+        data << "indexes: #{object.table.indexes.ai}" if object.table.indexes.any?
         data << "checks: #{object.table.checks.ai}" if object.table.checks.any?
 
         data_string = indent_lines(data.join(', '))

data/lib/db_schema/changes.rb

@@ -5,59 +5,155 @@ module DbSchema
   module Changes
     class << self
       def between(desired_schema, actual_schema)
-        table_names = [desired_schema.tables, actual_schema.tables].flatten.map(&:name).uniq
-
-        table_changes = table_names.each.with_object([]) do |table_name, changes|
-          desired = desired_schema.tables.find { |table| table.name == table_name }
-          actual  = actual_schema.tables.find  { |table| table.name == table_name }
-
-          if desired && !actual
-            changes << Operations::CreateTable.new(desired)
+        sort_all_changes(
+          [
+            table_changes(desired_schema, actual_schema),
+            enum_changes(desired_schema, actual_schema),
+            extension_changes(desired_schema, actual_schema)
+          ].reduce(:+)
+        )
+      end
 
-            fkey_operations = desired.foreign_keys.map do |fkey|
-              Operations::CreateForeignKey.new(table_name, fkey)
+    private
+      def table_changes(desired_schema, actual_schema)
+        compare_collections(
+          desired_schema.tables,
+          actual_schema.tables,
+          create: -> (table) do
+            fkey_operations = table.foreign_keys.map do |fkey|
+              Operations::CreateForeignKey.new(table.name, fkey)
             end
-            changes.concat(fkey_operations)
-          elsif actual && !desired
-            changes << Operations::DropTable.new(table_name)
 
-            actual.foreign_keys.each do |fkey|
-              changes << Operations::DropForeignKey.new(table_name, fkey.name)
+            [Operations::CreateTable.new(table), *fkey_operations]
+          end,
+          drop: -> (table) do
+            fkey_operations = table.foreign_keys.map do |fkey|
+              Operations::DropForeignKey.new(table.name, fkey.name)
             end
-          elsif actual != desired
-            field_operations = field_changes(desired.fields, actual.fields)
-            index_operations = index_changes(desired.indices, actual.indices)
-            check_operations = check_changes(desired.checks, actual.checks)
-            fkey_operations  = foreign_key_changes(table_name, desired.foreign_keys, actual.foreign_keys)
-
-            if field_operations.any? || index_operations.any? || check_operations.any?
-              changes << Operations::AlterTable.new(
-                table_name,
-                sort_alter_table_changes(field_operations + index_operations + check_operations)
+
+            [Operations::DropTable.new(table.name), *fkey_operations]
+          end,
+          change: -> (desired, actual) do
+            fkey_operations = foreign_key_changes(desired, actual)
+
+            alter_table_operations = [
+              field_changes(desired, actual),
+              index_changes(desired, actual),
+              check_changes(desired, actual)
+            ].reduce(:+)
+
+            if alter_table_operations.any?
+              alter_table = Operations::AlterTable.new(
+                desired.name,
+                sort_alter_table_changes(alter_table_operations)
               )
+
+              [alter_table, *fkey_operations]
+            else
+              fkey_operations
             end
+          end
+        )
+      end
+
+      def field_changes(desired_table, actual_table)
+        compare_collections(
+          desired_table.fields,
+          actual_table.fields,
+          create: -> (field) { Operations::CreateColumn.new(field) },
+          drop:   -> (field) { Operations::DropColumn.new(field.name) },
+          change: -> (desired, actual) do
+            [].tap do |operations|
+              if (actual.type != desired.type) || (actual.attributes != desired.attributes)
+                operations << Operations::AlterColumnType.new(
+                  actual.name,
+                  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
 
-            changes.concat(fkey_operations)
+              if desired.null? && !actual.null?
+                operations << Operations::AllowNull.new(actual.name)
+              end
+
+              if actual.null? && !desired.null?
+                operations << Operations::DisallowNull.new(actual.name)
+              end
+
+              if actual.default != desired.default
+                operations << Operations::AlterColumnDefault.new(actual.name, new_default: desired.default)
+              end
+            end
           end
-        end
+        )
+      end
 
-        enum_names = [desired_schema.enums, actual_schema.enums].flatten.map(&:name).uniq
+      def index_changes(desired_table, actual_table)
+        compare_collections(
+          desired_table.indexes,
+          actual_table.indexes,
+          create: -> (index) { Operations::CreateIndex.new(index) },
+          drop:   -> (index) { Operations::DropIndex.new(index.name) },
+          change: -> (desired, actual) do
+            [
+              Operations::DropIndex.new(actual.name),
+              Operations::CreateIndex.new(desired)
+            ]
+          end
+        )
+      end
 
-        enum_changes = enum_names.each_with_object([]) do |enum_name, changes|
-          desired = desired_schema.enums.find { |enum| enum.name == enum_name }
-          actual  = actual_schema.enums.find  { |enum| enum.name == enum_name }
+      def check_changes(desired_table, actual_table)
+        compare_collections(
+          desired_table.checks,
+          actual_table.checks,
+          create: -> (check) { Operations::CreateCheckConstraint.new(check) },
+          drop:   -> (check) { Operations::DropCheckConstraint.new(check.name) },
+          change: -> (desired, actual) do
+            [
+              Operations::DropCheckConstraint.new(actual.name),
+              Operations::CreateCheckConstraint.new(desired)
+            ]
+          end
+        )
+      end
 
-          if desired && !actual
-            changes << Operations::CreateEnum.new(desired)
-          elsif actual && !desired
-            changes << Operations::DropEnum.new(enum_name)
-          elsif actual != desired
+      def foreign_key_changes(desired_table, actual_table)
+        compare_collections(
+          desired_table.foreign_keys,
+          actual_table.foreign_keys,
+          create: -> (foreign_key) { Operations::CreateForeignKey.new(actual_table.name, foreign_key) },
+          drop:   -> (foreign_key) { Operations::DropForeignKey.new(actual_table.name, foreign_key.name) },
+          change: -> (desired, actual) do
+            [
+              Operations::DropForeignKey.new(actual_table.name, actual.name),
+              Operations::CreateForeignKey.new(actual_table.name, desired)
+            ]
+          end
+        )
+      end
+
+      def enum_changes(desired_schema, actual_schema)
+        compare_collections(
+          desired_schema.enums,
+          actual_schema.enums,
+          create: -> (enum) { Operations::CreateEnum.new(enum) },
+          drop:   -> (enum) { Operations::DropEnum.new(enum.name) },
+          change: -> (desired, actual) do
             fields = actual_schema.tables.flat_map do |table|
               table.fields.select do |field|
                 if field.array?
-                  field.attributes[:element_type] == enum_name
+                  field.attributes[:element_type] == actual.name
                 else
-                  field.type == enum_name
+                  field.type == actual.name
                 end
               end.map do |field|
                 if desired_field = desired_schema[table.name][field.name]
@@ -73,115 +169,33 @@ module DbSchema
               end
             end
 
-            changes << Operations::AlterEnumValues.new(enum_name, desired.values, fields)
-          end
-        end
-
-        extension_changes = (desired_schema.extensions - actual_schema.extensions).map do |extension|
-          Operations::CreateExtension.new(extension)
-        end + (actual_schema.extensions - desired_schema.extensions).map do |extension|
-          Operations::DropExtension.new(extension.name)
-        end
-
-        sort_all_changes(table_changes + enum_changes + extension_changes)
-      end
-
-    private
-      def field_changes(desired_fields, actual_fields)
-        field_names = [desired_fields, actual_fields].flatten.map(&:name).uniq
-
-        field_names.each.with_object([]) do |field_name, table_changes|
-          desired = desired_fields.find { |field| field.name == field_name }
-          actual  = actual_fields.find  { |field| field.name == field_name }
-
-          if desired && !actual
-            table_changes << Operations::CreateColumn.new(desired)
-          elsif actual && !desired
-            table_changes << Operations::DropColumn.new(field_name)
-          elsif actual != desired
-            if (actual.type != desired.type) || (actual.attributes != desired.attributes)
-              table_changes << Operations::AlterColumnType.new(
-                field_name,
-                new_type: desired.type,
-                **desired.attributes
-              )
-            end
-
-            if desired.primary_key? && !actual.primary_key?
-              table_changes << Operations::CreatePrimaryKey.new(field_name)
-            end
-
-            if actual.primary_key? && !desired.primary_key?
-              table_changes << Operations::DropPrimaryKey.new(field_name)
-            end
-
-            if desired.null? && !actual.null?
-              table_changes << Operations::AllowNull.new(field_name)
-            end
-
-            if actual.null? && !desired.null?
-              table_changes << Operations::DisallowNull.new(field_name)
-            end
-
-            if actual.default != desired.default
-              table_changes << Operations::AlterColumnDefault.new(field_name, new_default: desired.default)
-            end
-          end
-        end
-      end
-
-      def index_changes(desired_indices, actual_indices)
-        index_names = [desired_indices, actual_indices].flatten.map(&:name).uniq
-
-        index_names.each.with_object([]) do |index_name, table_changes|
-          desired = desired_indices.find { |index| index.name == index_name }
-          actual  = actual_indices.find  { |index| index.name == index_name }
-
-          if desired && !actual
-            table_changes << Operations::CreateIndex.new(desired)
-          elsif actual && !desired
-            table_changes << Operations::DropIndex.new(index_name)
-          elsif actual != desired
-            table_changes << Operations::DropIndex.new(index_name)
-            table_changes << Operations::CreateIndex.new(desired)
+            Operations::AlterEnumValues.new(actual.name, desired.values, fields)
           end
-        end
+        )
       end
 
-      def check_changes(desired_checks, actual_checks)
-        check_names = [desired_checks, actual_checks].flatten.map(&:name).uniq
-
-        check_names.each.with_object([]) do |check_name, table_changes|
-          desired = desired_checks.find { |check| check.name == check_name }
-          actual  = actual_checks.find  { |check| check.name == check_name }
-
-          if desired && !actual
-            table_changes << Operations::CreateCheckConstraint.new(desired)
-          elsif actual && !desired
-            table_changes << Operations::DropCheckConstraint.new(check_name)
-          elsif actual != desired
-            table_changes << Operations::DropCheckConstraint.new(check_name)
-            table_changes << Operations::CreateCheckConstraint.new(desired)
-          end
-        end
+      def extension_changes(desired_schema, actual_schema)
+        compare_collections(
+          desired_schema.extensions,
+          actual_schema.extensions,
+          create: -> (extension) { Operations::CreateExtension.new(extension) },
+          drop:   -> (extension) { Operations::DropExtension.new(extension.name) }
+        )
       end
 
-      def foreign_key_changes(table_name, desired_foreign_keys, actual_foreign_keys)
-        key_names = [desired_foreign_keys, actual_foreign_keys].flatten.map(&:name).uniq
-
-        key_names.each.with_object([]) do |key_name, table_changes|
-          desired = desired_foreign_keys.find { |key| key.name == key_name }
-          actual  = actual_foreign_keys.find  { |key| key.name == key_name }
-
-          if desired && !actual
-            table_changes << Operations::CreateForeignKey.new(table_name, desired)
-          elsif actual && !desired
-            table_changes << Operations::DropForeignKey.new(table_name, key_name)
-          elsif actual != desired
-            table_changes << Operations::DropForeignKey.new(table_name, key_name)
-            table_changes << Operations::CreateForeignKey.new(table_name, desired)
+      def compare_collections(desired, actual, create:, drop:, change: -> (*) {})
+        desired_hash = Utils.to_hash(desired, :name)
+        actual_hash  = Utils.to_hash(actual, :name)
+
+        (desired_hash.keys + actual_hash.keys).uniq.flat_map do |name|
+          if desired_hash.key?(name) && !actual_hash.key?(name)
+            create.(desired_hash[name])
+          elsif actual_hash.key?(name) && !desired_hash.key?(name)
+            drop.(actual_hash[name])
+          elsif actual_hash[name] != desired_hash[name]
+            change.(desired_hash[name], actual_hash[name])
           end
-        end
+        end.compact
       end
 
       def sort_all_changes(changes)

data/lib/db_schema/definitions/check_constraint.rb

@@ -8,6 +8,10 @@ module DbSchema
         @name      = name.to_sym
         @condition = condition
       end
+
+      def with_condition(new_condition)
+        CheckConstraint.new(name: name, condition: new_condition)
+      end
     end
 
     class NullCheckConstraint < CheckConstraint

data/lib/db_schema/definitions/field/base.rb

@@ -64,6 +64,10 @@ module DbSchema
           Field.build(name, type, **options, primary_key: primary_key?, attr_name => attr_value)
         end
 
+        def with_default(new_default)
+          Field.build(name, type, **options, primary_key: primary_key?, default: new_default)
+        end
+
         class << self
           def register(*types)
             types.each do |type|

data/lib/db_schema/definitions/index.rb

@@ -41,6 +41,16 @@ module DbSchema
           condition: condition
         )
       end
+
+      def with_condition(new_condition)
+        Index.new(
+          name:      name,
+          columns:   columns,
+          unique:    unique?,
+          type:      type,
+          condition: new_condition
+        )
+      end
     end
 
     class NullIndex < Index

data/lib/db_schema/definitions/table.rb

@@ -1,20 +1,20 @@
 module DbSchema
   module Definitions
     class Table
-      include Dry::Equalizer(:name, :fields, :indices, :checks, :foreign_keys)
-      attr_reader :name, :fields, :indices, :checks, :foreign_keys
+      include Dry::Equalizer(:name, :fields, :indexes, :checks, :foreign_keys)
+      attr_reader :name, :fields, :indexes, :checks, :foreign_keys
 
-      def initialize(name, fields: [], indices: [], checks: [], foreign_keys: [])
+      def initialize(name, fields: [], indexes: [], checks: [], foreign_keys: [])
         @name         = name.to_sym
         @fields       = fields
-        @indices      = indices
+        @indexes      = indexes
         @checks       = checks
         @foreign_keys = foreign_keys
       end
 
       def has_expressions?
         fields.any?(&:default_is_expression?) ||
-          indices.any?(&:has_expressions?) ||
+          indexes.any?(&:has_expressions?) ||
           checks.any?
       end
 
@@ -28,7 +28,7 @@ module DbSchema
       end
 
       def index(index_name)
-        indices.find { |index| index.name == index_name } || NullIndex.new
+        indexes.find { |index| index.name == index_name } || NullIndex.new
       end
 
       def has_index?(index_name)
@@ -36,13 +36,13 @@ module DbSchema
       end
 
       def has_index_on?(*field_names)
-        indices.any? do |index|
+        indexes.any? do |index|
           index.columns.none?(&:expression?) && index.columns.map(&:name) == field_names
         end
       end
 
       def has_unique_index_on?(*field_names)
-        indices.any? do |index|
+        indexes.any? do |index|
           index.unique? && index.columns.none?(&:expression?) && index.columns.map(&:name) == field_names
         end
       end
@@ -71,7 +71,7 @@ module DbSchema
         Table.new(
           new_name,
           fields:       fields,
-          indices:      indices,
+          indexes:      indexes,
           checks:       checks,
           foreign_keys: foreign_keys
         )
@@ -81,27 +81,37 @@ module DbSchema
         Table.new(
           name,
           fields:       new_fields,
-          indices:      indices,
+          indexes:      indexes,
           checks:       checks,
           foreign_keys: foreign_keys
         )
       end
 
-      def with_indices(new_indices)
+      def with_indexes(new_indexes)
         Table.new(
           name,
           fields:       fields,
-          indices:      new_indices,
+          indexes:      new_indexes,
           checks:       checks,
           foreign_keys: foreign_keys
         )
       end
 
+      def with_checks(new_checks)
+        Table.new(
+          name,
+          fields:       fields,
+          indexes:      indexes,
+          checks:       new_checks,
+          foreign_keys: foreign_keys
+        )
+      end
+
       def with_foreign_keys(new_foreign_keys)
         Table.new(
           name,
           fields:       fields,
-          indices:      indices,
+          indexes:      indexes,
           checks:       checks,
           foreign_keys: new_foreign_keys
         )
@@ -111,7 +121,7 @@ module DbSchema
     class NullTable < Table
       def initialize
         @fields       = []
-        @indices      = []
+        @indexes      = []
         @checks       = []
         @foreign_keys = []
       end

data/lib/db_schema/dsl.rb

@@ -17,7 +17,7 @@ module DbSchema
       @schema.tables << Definitions::Table.new(
         name,
         fields:       table_yielder.fields,
-        indices:      table_yielder.indices,
+        indexes:      table_yielder.indexes,
         checks:       table_yielder.checks,
         foreign_keys: table_yielder.foreign_keys
       )
@@ -64,7 +64,7 @@ module DbSchema
       end
 
       def index(*columns, **index_options)
-        indices << TableYielder.build_index(
+        indexes << TableYielder.build_index(
           columns,
           table_name: table_name,
           **index_options
@@ -105,8 +105,8 @@ module DbSchema
         @fields ||= []
       end
 
-      def indices
-        @indices ||= []
+      def indexes
+        @indexes ||= []
       end
 
       def checks

data/lib/db_schema/migrator.rb

@@ -31,7 +31,7 @@ module DbSchema
         table = Definitions::Table.new(
           name,
           fields:       table_yielder.fields,
-          indices:      table_yielder.indices,
+          indexes:      table_yielder.indexes,
           checks:       table_yielder.checks,
           foreign_keys: table_yielder.foreign_keys
         )

data/lib/db_schema/normalizer.rb

@@ -16,7 +16,7 @@ module DbSchema
 
         schema.tables = schema.tables.map do |table|
           if table.has_expressions?
-            Table.new(table, hash, connection).normalized_table
+            Table.new(table, hash, schema.enums.map(&:name), connection).normalized_table
           else
             table
           end
@@ -50,7 +50,7 @@ module DbSchema
     def hash
       @hash ||= begin
         names = schema.tables.flat_map do |table|
-          [table.name] + table.fields.map(&:name) + table.indices.map(&:name) + table.checks.map(&:name)
+          [table.name] + table.fields.map(&:name) + table.indexes.map(&:name) + table.checks.map(&:name)
         end
 
         Digest::MD5.hexdigest(names.join(','))[0..9]
@@ -58,11 +58,12 @@ module DbSchema
     end
 
     class Table
-      attr_reader :table, :hash, :connection
+      attr_reader :table, :hash, :enum_names, :connection
 
-      def initialize(table, hash, connection)
+      def initialize(table, hash, enum_names, connection)
         @table      = table
         @hash       = hash
+        @enum_names = enum_names
         @connection = connection
       end
 
@@ -76,7 +77,8 @@ module DbSchema
         operation = Operations::CreateTable.new(
           table.with_name(temporary_table_name)
             .with_fields(rename_types(table.fields))
-            .with_indices(rename_indices(table.indices))
+            .with_indexes(rename_indexes(table.indexes))
+            .with_checks(rename_types_in_checks(table.checks))
         )
 
         Runner.new([operation], connection).run!
@@ -87,43 +89,72 @@ module DbSchema
 
         temporary_table.with_name(table.name)
           .with_fields(rename_types_back(temporary_table.fields))
-          .with_indices(rename_indices_back(temporary_table.indices))
+          .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 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
+
           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
+          end.with_default(new_default)
         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
+          end.with_default(new_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
       end
 
-      def rename_indices(indices)
-        indices.map do |index|
-          index.with_name(append_hash(index.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 rename_indices_back(indices)
-        indices.map do |index|
-          index.with_name(remove_hash(index.name))
+      def rename_types_in_checks(checks)
+        checks.map do |check|
+          check.with_condition(rename_all_types_in(check.condition))
+        end
+      end
+
+      def rename_types_in_checks_back(checks)
+        checks.map do |check|
+          check.with_condition(rename_all_types_back_in(check.condition))
         end
       end
 
@@ -138,6 +169,28 @@ module DbSchema
       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)
+
+        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)}")
+        end
+      end
     end
   end
 end

data/lib/db_schema/reader.rb

@@ -78,7 +78,7 @@ SELECT conname AS name,
    AND contype = 'c'
       SQL
 
-      INDICES_QUERY = <<-SQL.freeze
+      INDEXES_QUERY = <<-SQL.freeze
    SELECT relname AS name,
           indkey AS column_positions,
           indisunique AS unique,
@@ -102,7 +102,7 @@ LEFT JOIN pg_am
   GROUP BY name, column_positions, indisunique, index_options, condition, index_type, index_oid
       SQL
 
-      EXPRESSION_INDICES_QUERY = <<-SQL.freeze
+      EXPRESSION_INDEXES_QUERY = <<-SQL.freeze
     WITH index_ids AS (SELECT unnest(?) AS index_id),
          elements AS (SELECT unnest(?) AS element)
   SELECT index_id,
@@ -142,7 +142,7 @@ SELECT extname
             build_field(column_data, primary_key: column_data[:name] == primary_key_name)
           end
 
-          indices = indices_data_for(table_name, connection).map do |index_data|
+          indexes = indexes_data_for(table_name, connection).map do |index_data|
             Definitions::Index.new(index_data)
           end.sort_by(&:name)
 
@@ -160,21 +160,21 @@ SELECT extname
           Definitions::Table.new(
             table_name,
             fields:       fields,
-            indices:      indices,
+            indexes:      indexes,
             checks:       checks,
             foreign_keys: foreign_keys
           )
         end
 
-        def indices_data_for(table_name, connection)
+        def indexes_data_for(table_name, connection)
           column_names = connection[COLUMN_NAMES_QUERY, table_name.to_s].reduce({}) do |names, column|
             names.merge(column[:pos] => column[:name].to_sym)
           end
 
-          indices_data     = connection[INDICES_QUERY, table_name.to_s].to_a
-          expressions_data = index_expressions_data(indices_data, connection)
+          indexes_data     = connection[INDEXES_QUERY, table_name.to_s].to_a
+          expressions_data = index_expressions_data(indexes_data, connection)
 
-          indices_data.map do |index|
+          indexes_data.map do |index|
             positions = index[:column_positions].split(' ').map(&:to_i)
             options   = index[:index_options].split(' ').map(&:to_i)
 
@@ -227,10 +227,10 @@ SELECT extname
         end
 
       private
-        def index_expressions_data(indices_data, connection)
+        def index_expressions_data(indexes_data, connection)
           all_positions, max_position = {}, 0
 
-          indices_data.each do |index_data|
+          indexes_data.each do |index_data|
             positions = index_data[:column_positions].split(' ').map(&:to_i)
             expression_positions = positions.each_index.select { |i| positions[i].zero? }
 
@@ -242,7 +242,7 @@ SELECT extname
 
           if all_positions.any?
             connection[
-              EXPRESSION_INDICES_QUERY,
+              EXPRESSION_INDEXES_QUERY,
               Sequel.pg_array(all_positions.keys),
               Sequel.pg_array((1..max_position.succ).to_a)
             ].each_with_object({}) do |index_data, indexes_data|

data/lib/db_schema/runner.rb

@@ -52,7 +52,7 @@ module DbSchema
           end
         end
 
-        change.table.indices.each do |index|
+        change.table.indexes.each do |index|
           index(
             index.columns_to_sequel,
             name:   index.name,

data/lib/db_schema/utils.rb

@@ -44,6 +44,12 @@ module DbSchema
         end
       end
 
+      def to_hash(array, attribute)
+        array.reduce({}) do |hash, object|
+          hash.merge(object.public_send(attribute) => object)
+        end
+      end
+
       def sort_by_class(array, sorted_classes)
         sorted_classes.flat_map do |klass|
           array.select { |object| object.is_a?(klass) }

data/lib/db_schema/validator.rb

@@ -41,7 +41,7 @@ module DbSchema
 
           field_names = table.fields.map(&:name)
 
-          table.indices.each do |index|
+          table.indexes.each do |index|
             index.columns.reject(&:expression?).map(&:name).each do |field_name|
               unless field_names.include?(field_name)
                 error_message = %(Index "#{index.name}" refers to a missing field "#{table.name}.#{field_name}")

data/lib/db_schema/version.rb

@@ -1,3 +1,3 @@
 module DbSchema
-  VERSION = '0.3'
+  VERSION = '0.3.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: db_schema
 version: !ruby/object:Gem::Version
-  version: '0.3'
+  version: 0.3.1
 platform: ruby
 authors:
 - Vsevolod Romashov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-10-24 00:00:00.000000000 Z
+date: 2017-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -234,7 +234,7 @@ files:
 - lib/db_schema/utils.rb
 - lib/db_schema/validator.rb
 - lib/db_schema/version.rb
-homepage: https://github.com/7even/db_schema
+homepage: https://github.com/db-schema/core
 licenses:
 - MIT
 metadata: {}