rom-sql 1.3.5 → 2.0.0.beta1

data/lib/rom/sql/errors.rb

@@ -12,6 +12,8 @@ module ROM
     CheckConstraintError      = Class.new(ConstraintError)
     UnknownDBTypeError        = Class.new(StandardError)
     MissingPrimaryKeyError    = Class.new(StandardError)
+    MigrationError            = Class.new(StandardError)
+    UnsupportedConversion     = Class.new(MigrationError)
 
     ERROR_MAP = {
       Sequel::DatabaseError => DatabaseError,

data/lib/rom/sql/extensions/mysql.rb

@@ -1 +1 @@
-require 'rom/sql/extensions/mysql/inferrer'
+require 'rom/sql/extensions/mysql/attributes_inferrer'

data/lib/rom/sql/extensions/mysql/attributes_inferrer.rb

@@ -0,0 +1,10 @@
+require 'rom/sql/schema/attributes_inferrer'
+
+module ROM
+  module SQL
+    class Schema
+      class MysqlInferrer < AttributesInferrer[:mysql]
+      end
+    end
+  end
+end

data/lib/rom/sql/extensions/postgres.rb

@@ -1,3 +1,3 @@
 require 'rom/sql/extensions/postgres/commands'
 require 'rom/sql/extensions/postgres/types'
-require 'rom/sql/extensions/postgres/inferrer'
+require 'rom/sql/extensions/postgres/attributes_inferrer'

data/lib/rom/sql/extensions/postgres/{inferrer.rb → attributes_inferrer.rb}

@@ -1,11 +1,11 @@
 require 'set'
-require 'rom/sql/schema/inferrer'
+require 'rom/sql/schema/attributes_inferrer'
 require 'rom/sql/extensions/postgres/types'
 
 module ROM
   module SQL
     class Schema
-      class PostgresInferrer < Inferrer[:postgres]
+      class PostgresInferrer < AttributesInferrer[:postgres]
         defines :db_numeric_types, :db_type_mapping, :db_array_type_matcher
 
         db_numeric_types %w(
@@ -34,7 +34,7 @@ module ROM
           'path' => Types::PG::PathT
         ).freeze
 
-        db_array_type_matcher '[]'.freeze
+        db_array_type_matcher Sequel::Postgres::PGArray::EMPTY_BRACKET
 
         private
 
@@ -50,7 +50,7 @@ module ROM
 
         def map_type(ruby_type, db_type, enum_values: nil, **_)
           if db_type.end_with?(self.class.db_array_type_matcher)
-            Types::PG::Array(db_type[0...db_type.size-2])
+            Types::PG::Array(db_type)
           elsif enum_values
             Types::String.enum(*enum_values)
           else

data/lib/rom/sql/extensions/postgres/types.rb

@@ -1,7 +1,9 @@
-require 'dry-types'
+require 'dry/types'
 require 'sequel'
 require 'ipaddr'
 
+require 'rom/sql/type_extensions'
+
 Sequel.extension(*%i(pg_array pg_array_ops pg_json pg_json_ops pg_hstore))
 
 module ROM
@@ -16,16 +18,8 @@ module ROM
 
         Array = Types.Definition(Sequel::Postgres::PGArray)
 
-        @array_types = ::Hash.new do |hash, type|
-          name = "#{ type }[]"
-          array_type = Array.constructor(-> (v) { Sequel.pg_array(v, type) }).
-                         meta(type: name, db_type: name, database: 'postgres')
-          Attribute::TypeExtensions.register(array_type) { include ArrayMethods }
-          hash[type] = array_type
-        end
-
         def self.Array(db_type)
-          @array_types[db_type]
+          Array.constructor(-> (v) { Sequel.pg_array(v, db_type) }).meta(type: db_type)
         end
 
         # @!parse
@@ -117,7 +111,7 @@ module ROM
         #     #
         #     #   @api public
         #   end
-        module ArrayMethods
+        TypeExtensions.register(Array.constructor -> {  }) do
           def contain(type, expr, other)
             Attribute[Types::Bool].meta(sql_expr: expr.pg_array.contains(type[other]))
           end
@@ -155,10 +149,6 @@ module ROM
           end
         end
 
-        Attribute::TypeExtensions.register(Array.constructor -> {  }) do
-          include ArrayMethods
-        end
-
         # JSON
 
         JSONArray = Types.Constructor(Sequel::Postgres::JSONArray, &Sequel.method(:pg_json))
@@ -167,7 +157,7 @@ module ROM
 
         JSONOp = Types.Constructor(Sequel::Postgres::JSONOp, &Sequel.method(:pg_json))
 
-        JSON = (JSONArray | JSONHash | JSONOp).meta(database: 'postgres', db_type: 'jsonb')
+        JSON = JSONArray | JSONHash | JSONOp
 
         # JSONB
 
@@ -177,7 +167,7 @@ module ROM
 
         JSONBOp = Types.Constructor(Sequel::Postgres::JSONBOp, &Sequel.method(:pg_jsonb))
 
-        JSONB = (JSONBArray | JSONBHash | JSONBOp).meta(database: 'postgres', db_type: 'jsonb')
+        JSONB = JSONBArray | JSONBHash | JSONBOp
 
         # @!parse
         #   class ROM::SQL::Attribute
@@ -343,11 +333,11 @@ module ROM
           end
         end
 
-        Attribute::TypeExtensions.register(JSON) do
+        TypeExtensions.register(JSON) do
           include JSONMethods[JSON, :pg_json.to_proc]
         end
 
-        Attribute::TypeExtensions.register(JSONB) do
+        TypeExtensions.register(JSONB) do
           include JSONMethods[JSONB, :pg_jsonb.to_proc]
 
           def contain(type, expr, value)

data/lib/rom/sql/extensions/sqlite.rb

@@ -1,2 +1,2 @@
 require 'rom/sql/extensions/sqlite/types'
-require 'rom/sql/extensions/sqlite/inferrer'
+require 'rom/sql/extensions/sqlite/attributes_inferrer'

data/lib/rom/sql/extensions/sqlite/{inferrer.rb → attributes_inferrer.rb}

@@ -1,9 +1,9 @@
-require 'rom/sql/schema/inferrer'
+require 'rom/sql/schema/attributes_inferrer'
 
 module ROM
   module SQL
     class Schema
-      class SqliteInferrer < Inferrer[:sqlite]
+      class SqliteInferrer < AttributesInferrer[:sqlite]
         NO_TYPE = EMPTY_STRING
 
         def map_type(_, db_type, **_kw)

data/lib/rom/sql/gateway.rb

@@ -31,6 +31,23 @@ module ROM
       #   @return [Hash] Options used for connection
       attr_reader :options
 
+      subscribe('configuration.commands.class.before_build') do |event|
+        klass = event[:command]
+        dataset = event[:dataset]
+        type = dataset.db.database_type
+
+        if type == :postgres
+          ext =
+            if klass < Commands::Create
+              Commands::Postgres::Create
+            elsif klass < Commands::Update
+              Commands::Postgres::Update
+            end
+
+          klass.send(:include, ext) if ext
+        end
+      end
+
       # Initialize an SQL gateway
       #
       # Gateways are typically initialized via ROM::Configuration object, gateway constructor
@@ -153,31 +170,6 @@ module ROM
         schema.include?(name)
       end
 
-      # Extend the command class with database-specific behavior
-      #
-      # @param [Class] klass Command class
-      # @param [Sequel::Dataset] dataset A dataset that will be used
-      #
-      # Note: Currently, only postgres is supported.
-      #
-      # @api public
-      def extend_command_class(klass, dataset)
-        type = dataset.db.database_type
-
-        if type == :postgres
-          ext =
-            if klass < Commands::Create
-              Commands::Postgres::Create
-            elsif klass < Commands::Update
-              Commands::Postgres::Update
-            end
-
-          klass.send(:include, ext) if ext
-        end
-
-        klass
-      end
-
       # Create a table using the configured connection
       #
       # @api public
@@ -201,6 +193,15 @@ module ROM
         @schema ||= connection.tables
       end
 
+      # Underlying database type
+      #
+      # @return [Symbol]
+      #
+      # @api public
+      def database_type
+        @database_type ||= connection.database_type.to_sym
+      end
+
       private
 
       # Connect to database or reuse established connection instance
@@ -221,13 +222,11 @@ module ROM
       #
       # @api private
       def load_extensions(exts)
-        db_type = connection.database_type.to_sym
-
-        if ROM::SQL.available_extension?(db_type)
-          ROM::SQL.load_extensions(db_type)
+        if ROM::SQL.available_extension?(database_type)
+          ROM::SQL.load_extensions(database_type)
         end
 
-        extensions = (CONNECTION_EXTENSIONS.fetch(db_type, EMPTY_ARRAY) + exts).uniq
+        extensions = (CONNECTION_EXTENSIONS.fetch(database_type, EMPTY_ARRAY) + exts).uniq
         connection.extension(*extensions)
 
         # this will be default in Sequel 5.0.0 and since we don't rely

data/lib/rom/sql/index.rb

@@ -0,0 +1,13 @@
+module ROM
+  module SQL
+    # @api private
+    class Index
+      extend Initializer
+      include Dry::Equalizer(:attributes, :name)
+
+      param :attributes
+
+      option :name, optional: true
+    end
+  end
+end

data/lib/rom/sql/migration.rb

@@ -1,4 +1,5 @@
 require 'rom/sql/migration/migrator'
+require 'rom/sql/migration/schema_diff'
 
 module ROM
   module SQL
@@ -135,6 +136,15 @@ module ROM
           migrator.run(options)
         }
       end
+
+      # @api public
+      def auto_migrate!(conf)
+        schemas = conf.relation_classes(self).map do |klass|
+          klass.schema || klass.schema_proc.call.finalize_attributes!(gateway: self)
+        end
+
+        migrator.auto_migrate!(self, schemas)
+      end
     end
   end
 end

data/lib/rom/sql/migration/inline_runner.rb

@@ -0,0 +1,86 @@
+module ROM
+  module SQL
+    module Migration
+      class Migrator
+        # @api private
+        class InlineRunner
+          attr_reader :gateway
+
+          def initialize(gateway)
+            @gateway = gateway
+          end
+
+          def call(changes)
+            changes.each do |diff|
+              apply(diff)
+            end
+          end
+
+          def apply(diff)
+            case diff
+            when SchemaDiff::TableCreated
+              create_table(diff)
+            when SchemaDiff::TableAltered
+              alter_table(diff)
+            else
+              raise NotImplementedError
+            end
+          end
+
+          def create_table(diff)
+            gateway.create_table(diff.table_name) do
+              diff.attributes.each do |attribute|
+                if attribute.primary_key?
+                  primary_key attribute.name
+                else
+                  column attribute.name, attribute.type, null: attribute.null?
+                end
+              end
+
+              diff.indexes.each do |idx|
+                index idx.attribute
+              end
+            end
+          end
+
+          def alter_table(diff)
+            gateway.connection.alter_table(diff.table_name) do
+              diff.attribute_changes.each do |attribute|
+                case attribute
+                when SchemaDiff::AttributeAdded
+                  add_column attribute.name, attribute.type, null: attribute.null?
+                when SchemaDiff::AttributeRemoved
+                  drop_column attribute.name
+                when SchemaDiff::AttributeChanged
+                  if attribute.type_changed?
+                    from, to = attribute.to_a.map(&attribute.method(:unwrap))
+                    raise UnsupportedConversion.new(
+                            "Don't know how to convert #{ from.inspect } to #{ to.inspect }"
+                          )
+                  end
+
+                  if attribute.nullability_changed?
+                    if attribute.null?
+                      set_column_allow_null attribute.name
+                    else
+                      set_column_not_null attribute.name
+                    end
+                  end
+                end
+              end
+
+              diff.index_changes.each do |index|
+                case index
+                when SchemaDiff::IndexAdded
+                  add_index index.attribute
+                when SchemaDiff::IndexRemoved
+                  drop_index index.attribute
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/migration/migrator.rb

@@ -2,6 +2,8 @@ require 'pathname'
 
 require 'rom/types'
 require 'rom/initializer'
+require 'rom/sql/migration'
+require 'rom/sql/migration/inline_runner'
 
 module ROM
   module SQL
@@ -53,6 +55,21 @@ module ROM
         def migration_file_content
           File.read(Pathname(__FILE__).dirname.join('template.rb').realpath)
         end
+
+        # @api private
+        def diff(gateway, inferrer, target)
+          empty = SQL::Schema.define(target.name)
+          current = target.with(inferrer.(empty, gateway))
+
+          SchemaDiff.new.(current, target)
+        end
+
+        def auto_migrate!(gateway, schemas)
+          runner = InlineRunner.new(gateway)
+          inferrer = ROM::SQL::Schema::Inferrer.new.suppress_errors
+          changes = schemas.map { |schema| diff(gateway, inferrer, schema) }.reject(&:empty?)
+          runner.(changes)
+        end
       end
     end
   end

data/lib/rom/sql/migration/schema_diff.rb

@@ -0,0 +1,177 @@
+module ROM
+  module SQL
+    module Migration
+      class SchemaDiff
+        class TableDiff
+          attr_reader :current_schema, :target_schema
+
+          def initialize(current_schema: nil, target_schema: nil)
+            @current_schema = current_schema
+            @target_schema = target_schema
+          end
+
+          def empty?
+            false
+          end
+
+          def table_name
+            target_schema.name.dataset
+          end
+        end
+
+        class Empty < TableDiff
+          def empty?
+            true
+          end
+        end
+
+        class TableCreated < TableDiff
+          alias_method :schema, :target_schema
+          attr_reader :attributes, :indexes
+
+          def initialize(attributes:, indexes: EMPTY_ARRAY, **rest)
+            super(rest)
+
+            @attributes = attributes
+            @indexes = indexes
+          end
+        end
+
+        class TableAltered < TableDiff
+          attr_reader :attribute_changes, :index_changes
+
+          def initialize(attribute_changes: EMPTY_ARRAY, index_changes: EMPTY_ARRAY, **rest)
+            super(rest)
+
+            @attribute_changes = attribute_changes
+            @index_changes = index_changes
+          end
+        end
+
+        class AttributeDiff
+          attr_reader :attr
+
+          def initialize(attr)
+            @attr = attr
+          end
+
+          def name
+            attr.name
+          end
+
+          def null?
+            attr.optional?
+          end
+
+          def primary_key?
+            attr.primary_key?
+          end
+
+          def unwrap(type)
+            type.optional? ? SQL::Attribute[type.right].meta(type.meta) : type
+          end
+        end
+
+        class AttributeAdded < AttributeDiff
+          def type
+            unwrap(attr).primitive
+          end
+        end
+
+        class AttributeRemoved < AttributeDiff
+        end
+
+        class AttributeChanged < AttributeDiff
+          attr_reader :current
+          alias_method :target, :attr
+
+          def initialize(current, target)
+            super(target)
+
+            @current = current
+          end
+
+          def to_a
+            [current, target]
+          end
+
+          def nullability_changed?
+            current.optional? ^ target.optional?
+          end
+
+          def type_changed?
+            unwrap(current).meta(index: Set.new) != unwrap(target).meta(index: Set.new)
+          end
+        end
+
+        class IndexDiff
+          attr_reader :index
+
+          def initialize(index)
+            @index = index
+          end
+
+          def attribute
+            index.attributes[0].name
+          end
+        end
+
+        class IndexAdded < IndexDiff
+        end
+
+        class IndexRemoved < IndexDiff
+        end
+
+        def call(current, target)
+          if current.empty?
+            TableCreated.new(
+              target_schema: target,
+              attributes: target.map { |attr| AttributeAdded.new(attr) },
+              indexes: target.indexes.map { |idx| IndexAdded.new(idx) }
+            )
+          else
+            attribute_changes = compare_attributes(current.to_h, target.to_h)
+            index_changes = compare_indexes(current, target)
+
+            if attribute_changes.empty? && index_changes.empty?
+              Empty.new(current_schema: current, target_schema: target)
+            else
+              TableAltered.new(
+                current_schema: current,
+                target_schema: target,
+                attribute_changes: attribute_changes,
+                index_changes: index_changes
+              )
+            end
+          end
+        end
+
+        def compare_attributes(current, target)
+          changed_attributes = target.select { |name, attr|
+            current.key?(name) && current[name] != attr
+          }.map { |name, target_attr|
+            [name, [current[name], target_attr]]
+          }.to_h
+          added_attributes = target.select { |name, _| !current.key?(name) }
+          removed_attributes = current.select { |name, _| !target.key?(name) }
+
+          removed_attributes.values.map { |attr| AttributeRemoved.new(attr) } +
+            added_attributes.values.map { |attr| AttributeAdded.new(attr) } +
+            changed_attributes.values.map { |attrs| AttributeChanged.new(*attrs) }
+        end
+
+        def compare_indexes(current, target)
+          added_indexes = target.indexes.reject { |idx|
+            current.indexes.any? { |curr_idx| curr_idx.attributes == idx.attributes }
+          }
+          removed_indexes = current.indexes.select { |idx|
+            target.indexes.none? { |tgt_idx| idx.attributes == tgt_idx  }
+          }
+
+          removed_indexes.map { |idx| IndexRemoved.new(idx) } +
+            added_indexes.map { |idx| IndexAdded.new(idx) }
+        end
+      end
+    end
+  end
+end