db_schema 0.1.3 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f262094701b7ff8ff410c8854af2676daff44f4f
-  data.tar.gz: 0ba850facc23b85c344314a7e1e8b567ac762e4a
+  metadata.gz: 3851833bd5308ba174d2d70c217b6fc73c7d583b
+  data.tar.gz: 95071a258ce6202862e38a64d0d57fee8a0cfea9
 SHA512:
-  metadata.gz: 6fb1c3a34728124816899da8c6f67d82d70a38a0f40228cb65fca5597db8db9984fa5490554c64f0484e4160f33da94220fc385cc4b78298c6103aad189b9a6e
-  data.tar.gz: daeb82268ecfa4202dee52f97d92c8f4e2c6cd01a0af5c24ebb8391f16128836137a8914b8ed752eef3a4d07a478853dc75a1315358e2bc2b51df447e9d451a1
+  metadata.gz: 424334e2045a9cf08bdf6fedddbc8710c05f1d101ac2bd22350191e71e8dccc201118bb3511590ff56d67610c80494e6c7aed98d2d2e263b582343f910179567
+  data.tar.gz: cac4af5351c520d8610a98c54e57d7c93a884bcc0f0b33e953eedb45291e43e9cfd5fccfef47ee791e3ab07dcde72a546c6c3f0d22959c3acdf8f9b24fe1f1c6

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.1.3'
+gem 'db_schema', '~> 0.2.0'
 ```
 
 And then execute:
@@ -207,7 +207,7 @@ db.table :people do |t|
 end
 ```
 
-Passing `null: false` to the field definition makes it `NOT NULL`; passing some value under the `:default` key makes it the default value. A symbol passed as a default is interpreted as a function call so `t.timestamp :created_at, default: :now` defines a field with a default value of `NOW()`; strings, numbers, timestamps etc are evaluated "as is".
+Passing `null: false` to the field definition makes it `NOT NULL`; passing some value under the `:default` key makes it the default value. You can use `String`s as SQL strings, `Fixnum`s as integers, `Float`s as floating point numbers, `true` & `false` as their SQL counterparts, `Date`s as SQL dates and `Time`s as timestamps. A symbol passed as a default is a special case: it is interpreted as an SQL expression so `t.timestamp :created_at, default: :'now()'` defines a field with a default value of `NOW()`.
 
 Other attributes are type specific, like `:length` for varchars; the following table lists them all (values in parentheses are default attribute values).
 
@@ -354,8 +354,6 @@ db.table :users do |t|
 end
 ```
 
-Be warned though that you have to specify the condition exactly as PostgreSQL outputs it in `psql` with `\d table_name` command; otherwise your index will be recreated on each DbSchema run. This will be fixed in a later DbSchema version.
-
 If you need an index on expression you can use the same syntax replacing column names with SQL strings containing the expressions:
 
 ``` ruby
@@ -367,8 +365,6 @@ end
 
 Expression indexes syntax allows specifying an order exactly like in a common index on table fields - just use a hash form like `t.index 'date(created_at)' => :desc`. You can also use an expression in a multiple index.
 
-As with partial index condition (and all other SQL segments in `db_schema`), you must write the expression in a way `psql` outputs it, so instead of `lower(email)` you should use `lower(email::text)` (assuming that `email` is a varchar field).
-
 #### Foreign keys
 
 The `#foreign_key` method defines a foreign key. In it's minimal form it takes a referencing field name and referenced table name:
@@ -439,8 +435,6 @@ db.table :users do |t|
 end
 ```
 
-As with partial index conditions, for now you have to specify the SQL exactly as `psql` outputs it (otherwise the constraint will be recreated on each run).
-
 ### Enum types
 
 PostgreSQL allows developers to create custom enum types; value of enum type is one of a fixed set of values stored in the type definition.
@@ -532,9 +526,7 @@ All configuration options are described in the following table:
 
 By default DbSchema logs the changes it applies to your database; you can disable that by setting `log_changes` to false.
 
-DbSchema provides an opt-out post-run schema check; it ensures that there are no remaining differences between your `schema.rb` and the actual database schema. If DbSchema still sees any differences it will keep applying them on each run - usually this is harmless (because it does not really change your schema) but in the case of a partial index with a complex condition or an index on some expression it may rebuild the index which is an expensive operation on a large table. You can set `post_check` to false if you are 100% sure that your persistent changes are not a problem for you but I strongly recommend that you turn it on from time to time just to make sure nothing dangerous appears in these persistent changes.
-
-The `post_check` option is likely to become off by default when DbSchema becomes more stable and battle-tested, and when the partial index problem will be solved.
+DbSchema provides an opt-out post-run schema check; it ensures that the schema was applied correctly and there are no remaining differences between your `schema.rb` and the actual database schema. The corresponding `post_check` option is likely to become off by default when DbSchema becomes more stable and battle-tested.
 
 There is also a dry run mode which does not apply the changes to your database - it just logs the necessary changes (if you leave `log_changes` set to `true`). Post check is also skipped in that case.
 
@@ -543,12 +535,8 @@ Dry run may be useful while you are building your schema definition for an exist
 ## Known problems and limitations
 
 * primary keys are hardcoded to a single NOT NULL integer field with a postgres sequence attached
-* "partial index problem": some conditions of partial indexes and check constraints can cause
-  a false positive result of checking for differences between `schema.rb` and actual database schema,
-  resulting in unwanted operations on each run (the worst of them being the recreation of an index
-  on a large table)
 * array element type attributes are not supported
-* precision in time & datetime types isn't supported
+* precision in all date/time types isn't supported
 * no support for databases other than PostgreSQL
 * no support for renaming tables & columns
 

data/lib/db_schema/awesome_print.rb

@@ -13,6 +13,8 @@ if defined?(AwesomePrint)
 
       def cast_with_dbschema(object, type)
         case object
+        when ::DbSchema::Definitions::Schema
+          :dbschema_schema
         when ::DbSchema::Definitions::Table
           :dbschema_table
         when ::DbSchema::Definitions::Field::Custom
@@ -79,6 +81,15 @@ 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 << "indices: #{object.indices.ai}" if object.indices.any?
@@ -92,7 +103,12 @@ if defined?(AwesomePrint)
       def awesome_dbschema_field(object)
         options = object.options.map do |k, v|
           key = colorize("#{k}:", :symbol)
-          "#{key} #{v.ai}"
+
+          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?
@@ -107,7 +123,12 @@ if defined?(AwesomePrint)
       def awesome_dbschema_custom_field(object)
         options = object.options.map do |k, v|
           key = colorize("#{k}:", :symbol)
-          "#{key} #{v.ai}"
+
+          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?
@@ -212,7 +233,13 @@ if defined?(AwesomePrint)
       end
 
       def awesome_dbschema_alter_column_default(object)
-        "#<DbSchema::Changes::AlterColumnDefault #{object.name.ai}, #{object.new_default.ai}>"
+        new_default = if object.new_default.is_a?(Symbol)
+          colorize(object.new_default.to_s, :string)
+        else
+          object.new_default.ai
+        end
+
+        "#<DbSchema::Changes::AlterColumnDefault #{object.name.ai}, #{new_default}>"
       end
 
       def awesome_dbschema_create_foreign_key(object)

data/lib/db_schema/changes.rb

@@ -5,14 +5,11 @@ module DbSchema
   module Changes
     class << self
       def between(desired_schema, actual_schema)
-        desired_tables = extract_tables(desired_schema)
-        actual_tables  = extract_tables(actual_schema)
-
-        table_names = [desired_tables, actual_tables].flatten.map(&:name).uniq
+        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_tables.find { |table| table.name == table_name }
-          actual  = actual_tables.find  { |table| table.name == table_name }
+          desired = desired_schema.tables.find { |table| table.name == table_name }
+          actual  = actual_schema.tables.find  { |table| table.name == table_name }
 
           if desired && !actual
             changes << CreateTable.new(
@@ -51,14 +48,11 @@ module DbSchema
           end
         end
 
-        desired_enums = extract_enums(desired_schema)
-        actual_enums  = extract_enums(actual_schema)
-
-        enum_names = [desired_enums, actual_enums].flatten.map(&:name).uniq
+        enum_names = [desired_schema.enums, actual_schema.enums].flatten.map(&:name).uniq
 
         enum_changes = enum_names.each_with_object([]) do |enum_name, changes|
-          desired = desired_enums.find { |enum| enum.name == enum_name }
-          actual  = actual_enums.find  { |enum| enum.name == enum_name }
+          desired = desired_schema.enums.find { |enum| enum.name == enum_name }
+          actual  = actual_schema.enums.find  { |enum| enum.name == enum_name }
 
           if desired && !actual
             changes << CreateEnum.new(enum_name, desired.values)
@@ -89,12 +83,9 @@ module DbSchema
           end
         end
 
-        desired_extensions = extract_extensions(desired_schema)
-        actual_extensions  = extract_extensions(actual_schema)
-
-        extension_changes = (desired_extensions - actual_extensions).map do |extension|
+        extension_changes = (desired_schema.extensions - actual_schema.extensions).map do |extension|
           CreateExtension.new(extension.name)
-        end + (actual_extensions - desired_extensions).map do |extension|
+        end + (actual_schema.extensions - desired_schema.extensions).map do |extension|
           DropExtension.new(extension.name)
         end
 
@@ -226,18 +217,6 @@ module DbSchema
           end
         end
       end
-
-      def extract_tables(schema)
-        Utils.filter_by_class(schema, Definitions::Table)
-      end
-
-      def extract_enums(schema)
-        Utils.filter_by_class(schema, Definitions::Enum)
-      end
-
-      def extract_extensions(schema)
-        Utils.filter_by_class(schema, Definitions::Extension)
-      end
     end
 
     class CreateTable

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

@@ -9,7 +9,7 @@ module DbSchema
           @name        = name
           @primary_key = primary_key
           @null        = null
-          @default     = process_default(default)
+          @default     = default
           @attributes  = attributes
         end
 
@@ -21,6 +21,10 @@ module DbSchema
           !primary_key? && @null
         end
 
+        def default_is_expression?
+          default.is_a?(Symbol)
+        end
+
         def options
           attributes.tap do |options|
             options[:null] = false unless null?
@@ -48,14 +52,6 @@ module DbSchema
           self.class.type
         end
 
-        def process_default(default)
-          if default.is_a?(Symbol)
-            Sequel.function(default)
-          else
-            default
-          end
-        end
-
         class << self
           def register(*types)
             types.each do |type|

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

@@ -23,7 +23,7 @@ module DbSchema
 
       class Interval < Base
         register :interval
-        attributes :fields, :precision
+        attributes :fields
       end
     end
   end

data/lib/db_schema/definitions.rb

@@ -2,6 +2,37 @@ require 'dry/equalizer'
 
 module DbSchema
   module Definitions
+    class Schema
+      include Dry::Equalizer(:tables, :enums, :extensions)
+      attr_reader :tables, :enums, :extensions
+      attr_writer :tables
+
+      def initialize(tables: [], enums: [], extensions: [])
+        @tables     = tables
+        @enums      = enums
+        @extensions = extensions
+      end
+    end
+
+    class Table
+      include Dry::Equalizer(:name, :fields, :indices, :checks, :foreign_keys)
+      attr_reader :name, :fields, :indices, :checks, :foreign_keys
+
+      def initialize(name, fields: [], indices: [], checks: [], foreign_keys: [])
+        @name         = name.to_sym
+        @fields       = fields
+        @indices      = indices
+        @checks       = checks
+        @foreign_keys = foreign_keys
+      end
+
+      def has_expressions?
+        fields.any?(&:default_is_expression?) ||
+          indices.any?(&:has_expressions?) ||
+          checks.any?
+      end
+    end
+
     class Index
       include Dry::Equalizer(:name, :columns, :unique?, :type, :condition)
       attr_reader :name, :columns, :type, :condition
@@ -30,6 +61,10 @@ module DbSchema
         end
       end
 
+      def has_expressions?
+        !condition.nil? || columns.any?(&:expression?)
+      end
+
       class Column
         include Dry::Equalizer(:name, :order, :nulls)
         attr_reader :name, :order, :nulls
@@ -130,19 +165,6 @@ module DbSchema
       end
     end
 
-    class Table
-      include Dry::Equalizer(:name, :fields, :indices, :checks, :foreign_keys)
-      attr_reader :name, :fields, :indices, :checks, :foreign_keys
-
-      def initialize(name, fields: [], indices: [], checks: [], foreign_keys: [])
-        @name         = name.to_sym
-        @fields       = fields
-        @indices      = indices
-        @checks       = checks
-        @foreign_keys = foreign_keys
-      end
-    end
-
     class Enum
       include Dry::Equalizer(:name, :values)
       attr_reader :name, :values

data/lib/db_schema/dsl.rb

@@ -4,7 +4,7 @@ module DbSchema
 
     def initialize(block)
       @block  = block
-      @schema = []
+      @schema = Definitions::Schema.new
     end
 
     def schema
@@ -16,7 +16,7 @@ module DbSchema
     def table(name, &block)
       table_yielder = TableYielder.new(name, block)
 
-      @schema << Definitions::Table.new(
+      @schema.tables << Definitions::Table.new(
         name,
         fields:       table_yielder.fields,
         indices:      table_yielder.indices,
@@ -26,11 +26,11 @@ module DbSchema
     end
 
     def enum(name, values)
-      @schema << Definitions::Enum.new(name.to_sym, values.map(&:to_sym))
+      @schema.enums << Definitions::Enum.new(name.to_sym, values.map(&:to_sym))
     end
 
     def extension(name)
-      @schema << Definitions::Extension.new(name.to_sym)
+      @schema.extensions << Definitions::Extension.new(name.to_sym)
     end
 
     class TableYielder

data/lib/db_schema/normalizer.rb

@@ -0,0 +1,89 @@
+require 'digest/md5'
+
+module DbSchema
+  class Normalizer
+    attr_reader :table
+
+    def initialize(table)
+      @table = table
+    end
+
+    def normalized_table
+      create_temporary_table!
+      read_temporary_table
+    ensure
+      cleanup!
+    end
+
+  private
+    def create_temporary_table!
+      operation = Changes::CreateTable.new(
+        temporary_table_name,
+        fields:  table.fields,
+        indices: rename_indices(table.indices),
+        checks:  table.checks
+      )
+
+      Runner.new([operation]).run!
+    end
+
+    def read_temporary_table
+      temporary_table = Reader.read_table(temporary_table_name)
+
+      Definitions::Table.new(
+        remove_hash(temporary_table.name),
+        fields:       temporary_table.fields,
+        indices:      rename_indices_back(temporary_table.indices),
+        checks:       temporary_table.checks,
+        foreign_keys: table.foreign_keys
+      )
+    end
+
+    def cleanup!
+      DbSchema.connection.drop_table(temporary_table_name, if_exists: true)
+    end
+
+    def rename_indices(indices)
+      indices.map do |index|
+        Definitions::Index.new(
+          name:      append_hash(index.name),
+          columns:   index.columns,
+          unique:    index.unique?,
+          type:      index.type,
+          condition: index.condition
+        )
+      end
+    end
+
+    def rename_indices_back(indices)
+      indices.map do |index|
+        Definitions::Index.new(
+          name:      remove_hash(index.name),
+          columns:   index.columns,
+          unique:    index.unique?,
+          type:      index.type,
+          condition: index.condition
+        )
+      end
+    end
+
+    def temporary_table_name
+      append_hash(table.name)
+    end
+
+    def append_hash(name)
+      "#{name}_#{hash}"
+    end
+
+    def remove_hash(name)
+      name.to_s.sub(/_#{Regexp.escape(hash)}$/, '').to_sym
+    end
+
+    def hash
+      @hash ||= begin
+        names = [table.name] + table.fields.map(&:name) + table.indices.map(&:name) + table.checks.map(&:name)
+        Digest::MD5.hexdigest(names.join(','))[0..9]
+      end
+    end
+  end
+end

data/lib/db_schema/reader.rb

@@ -5,6 +5,10 @@ module DbSchema
         adapter.read_schema
       end
 
+      def read_table(table_name)
+        adapter.read_table(table_name)
+      end
+
       def adapter
         adapter_name = DbSchema.configuration.adapter
         registry.fetch(adapter_name) do |adapter_name|
@@ -19,7 +23,19 @@ module DbSchema
     end
 
     module Postgres
-      DEFAULT_VALUE = /\A(('(?<string>.*)')|(?<float>\d+\.\d+)|(?<integer>\d+)|(?<boolean>true|false)|((?<function>[A-Za-z_]+)\(\)))/
+      DEFAULT_VALUE = /\A(
+        ('(?<date>\d{4}-\d{2}-\d{2})'::date)
+          |
+        ('(?<time>\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}([+-]\d{2})?)'::timestamp)
+          |
+        ('(?<string>.*)')
+          |
+        (?<float>\d+\.\d+)
+          |
+        (?<integer>\d+)
+          |
+        (?<boolean>true|false)
+      )/x
 
       COLUMN_NAMES_QUERY = <<-SQL.freeze
    SELECT c.column_name AS name,
@@ -104,6 +120,10 @@ SELECT extname
 
       class << self
         def read_schema
+          tables = DbSchema.connection.tables.map do |table_name|
+            read_table(table_name)
+          end
+
           enums = DbSchema.connection[ENUMS_QUERY].map do |enum_data|
             Definitions::Enum.new(enum_data[:name].to_sym, enum_data[:values].map(&:to_sym))
           end
@@ -112,38 +132,38 @@ SELECT extname
             Definitions::Extension.new(extension_data[:extname].to_sym)
           end
 
-          tables = DbSchema.connection.tables.map do |table_name|
-            primary_key_name = DbSchema.connection.primary_key(table_name)
+          Definitions::Schema.new(tables: tables, enums: enums, extensions: extensions)
+        end
 
-            fields = DbSchema.connection[COLUMN_NAMES_QUERY, table_name.to_s].map do |column_data|
-              build_field(column_data, primary_key: column_data[:name] == primary_key_name)
-            end
+        def read_table(table_name)
+          primary_key_name = DbSchema.connection.primary_key(table_name)
 
-            indices = indices_data_for(table_name).map do |index_data|
-              Definitions::Index.new(index_data)
-            end.sort_by(&:name)
+          fields = DbSchema.connection[COLUMN_NAMES_QUERY, table_name.to_s].map do |column_data|
+            build_field(column_data, primary_key: column_data[:name] == primary_key_name)
+          end
 
-            foreign_keys = DbSchema.connection.foreign_key_list(table_name).map do |foreign_key_data|
-              build_foreign_key(foreign_key_data)
-            end
+          indices = indices_data_for(table_name).map do |index_data|
+            Definitions::Index.new(index_data)
+          end.sort_by(&:name)
 
-            checks = DbSchema.connection[CONSTRAINTS_QUERY, table_name.to_s].map do |check_data|
-              Definitions::CheckConstraint.new(
-                name:      check_data[:name].to_sym,
-                condition: check_data[:condition]
-              )
-            end
+          foreign_keys = DbSchema.connection.foreign_key_list(table_name).map do |foreign_key_data|
+            build_foreign_key(foreign_key_data)
+          end
 
-            Definitions::Table.new(
-              table_name,
-              fields:       fields,
-              indices:      indices,
-              checks:       checks,
-              foreign_keys: foreign_keys
+          checks = DbSchema.connection[CONSTRAINTS_QUERY, table_name.to_s].map do |check_data|
+            Definitions::CheckConstraint.new(
+              name:      check_data[:name].to_sym,
+              condition: check_data[:condition]
             )
           end
 
-          enums + extensions + tables
+          Definitions::Table.new(
+            table_name,
+            fields:       fields,
+            indices:      indices,
+            checks:       checks,
+            foreign_keys: foreign_keys
+          )
         end
 
         def indices_data_for(table_name)
@@ -227,8 +247,12 @@ SELECT extname
           nullable = (data[:null] != 'NO')
 
           unless primary_key || data[:default].nil?
-            if match = DEFAULT_VALUE.match(data[:default])
-              default = if match[:string]
+            default = if match = DEFAULT_VALUE.match(data[:default])
+              if match[:date]
+                Date.parse(match[:date])
+              elsif match[:time]
+                Time.parse(match[:time])
+              elsif match[:string]
                 match[:string]
               elsif match[:integer]
                 match[:integer].to_i
@@ -236,9 +260,9 @@ SELECT extname
                 match[:float].to_f
               elsif match[:boolean]
                 match[:boolean] == 'true'
-              elsif match[:function]
-                match[:function].to_sym
               end
+            else
+              data[:default].to_sym
             end
           end
 

data/lib/db_schema/runner.rb

@@ -133,7 +133,7 @@ module DbSchema
             when Changes::DisallowNull
               set_column_not_null(element.name)
             when Changes::AlterColumnDefault
-              set_column_default(element.name, element.new_default)
+              set_column_default(element.name, Runner.default_to_sequel(element.new_default))
             when Changes::CreateIndex
               add_index(
                 element.columns_to_sequel,
@@ -216,6 +216,20 @@ module DbSchema
         else
           options
         end
+
+        if mapping.key?(:default)
+          mapping.merge(default: default_to_sequel(mapping[:default]))
+        else
+          mapping
+        end
+      end
+
+      def default_to_sequel(default)
+        if default.is_a?(Symbol)
+          Sequel.lit(default.to_s)
+        else
+          default
+        end
       end
     end
   end

data/lib/db_schema/validator.rb

@@ -2,10 +2,7 @@ module DbSchema
   module Validator
     class << self
       def validate(schema)
-        tables = Utils.filter_by_class(schema, Definitions::Table)
-        enums  = Utils.filter_by_class(schema, Definitions::Enum)
-
-        table_errors = tables.each_with_object([]) do |table, errors|
+        table_errors = schema.tables.each_with_object([]) do |table, errors|
           primary_keys_count = table.fields.select(&:primary_key?).count
           if primary_keys_count > 1
             error_message = %(Table "#{table.name}" has #{primary_keys_count} primary keys)
@@ -14,7 +11,7 @@ module DbSchema
 
           table.fields.each do |field|
             if field.is_a?(Definitions::Field::Custom)
-              unless enums.map(&:name).include?(field.type_name)
+              unless schema.enums.map(&:name).include?(field.type_name)
                 error_message = %(Field "#{table.name}.#{field.name}" has unknown type "#{field.type_name}")
                 errors << error_message
               end
@@ -40,7 +37,7 @@ module DbSchema
               end
             end
 
-            if referenced_table = schema.find { |table| table.name == fkey.table }
+            if referenced_table = schema.tables.find { |table| table.name == fkey.table }
               if fkey.references_primary_key?
                 unless referenced_table.fields.any?(&:primary_key?)
                   error_message = %(Foreign key "#{fkey.name}" refers to primary key of table "#{fkey.table}" which does not have a primary key)
@@ -63,7 +60,7 @@ module DbSchema
           end
         end
 
-        enum_errors = enums.each_with_object([]) do |enum, errors|
+        enum_errors = schema.enums.each_with_object([]) do |enum, errors|
           if enum.values.empty?
             error_message = %(Enum "#{enum.name}" contains no values)
             errors << error_message

data/lib/db_schema/version.rb

@@ -1,3 +1,3 @@
 module DbSchema
-  VERSION = '0.1.3'
+  VERSION = '0.2'
 end

data/lib/db_schema.rb

@@ -7,6 +7,7 @@ require 'db_schema/definitions'
 require 'db_schema/awesome_print'
 require 'db_schema/dsl'
 require 'db_schema/validator'
+require 'db_schema/normalizer'
 require 'db_schema/reader'
 require 'db_schema/changes'
 require 'db_schema/runner'
@@ -17,6 +18,7 @@ module DbSchema
     def describe(&block)
       desired_schema = DSL.new(block).schema
       validate(desired_schema)
+      normalize(desired_schema)
 
       actual_schema = Reader.read_schema
       changes = Changes.between(desired_schema, actual_schema)
@@ -88,6 +90,18 @@ module DbSchema
       end
     end
 
+    def normalize(schema)
+      normalized_tables = schema.tables.map do |table|
+        if table.has_expressions?
+          Normalizer.new(table).normalized_table
+        else
+          table
+        end
+      end
+
+      schema.tables = normalized_tables
+    end
+
     def log_changes(changes)
       return if changes.empty?
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: db_schema
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: '0.2'
 platform: ruby
 authors:
 - Vsevolod Romashov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-10-18 00:00:00.000000000 Z
+date: 2016-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -214,6 +214,7 @@ files:
 - lib/db_schema/definitions/field/text_search.rb
 - lib/db_schema/definitions/field/uuid.rb
 - lib/db_schema/dsl.rb
+- lib/db_schema/normalizer.rb
 - lib/db_schema/reader.rb
 - lib/db_schema/runner.rb
 - lib/db_schema/utils.rb