rom-sql 2.0.0.beta2 → 2.0.0.beta3

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

@@ -0,0 +1,15 @@
+require 'ipaddr'
+
+module ROM
+  module SQL
+    module Postgres
+      module Types
+        IPAddress = Type('inet') do
+          read = SQL::Types.Constructor(IPAddr) { |ip| IPAddr.new(ip.to_s) }
+
+          SQL::Types.Constructor(IPAddr, &:to_s).meta(read: read)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -1,19 +1,19 @@
-require 'rom/sql/schema/attributes_inferrer'
-
 module ROM
   module SQL
-    class Schema
-      class SqliteInferrer < AttributesInferrer[:sqlite]
+    module SQLite
+      class TypeBuilder < Schema::TypeBuilder
         NO_TYPE = EMPTY_STRING
 
         def map_type(_, db_type, **_kw)
           if db_type.eql?(NO_TYPE)
-            ROM::SQL::Types::SQLite::Object
+            ROM::SQL::Types::SQLite::Any
           else
             super
           end
         end
       end
     end
+
+    Schema::TypeBuilder.register(:sqlite, SQLite::TypeBuilder.new.freeze)
   end
 end

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

@@ -2,10 +2,15 @@ require 'dry-types'
 
 module ROM
   module SQL
-    module Types
-      module SQLite
-        Object = ::ROM::SQL::Types::Object
+    module SQLite
+      module Types
+        Any = ::ROM::SQL::Types::Any
+        Object = Any
       end
     end
+
+    module Types
+      SQLite = ::ROM::SQL::SQLite::Types
+    end
   end
 end

data/lib/rom/sql/foreign_key.rb

@@ -0,0 +1,17 @@
+module ROM
+  module SQL
+    # @api private
+    class ForeignKey
+      extend Initializer
+      include Dry::Equalizer(:attributes, :parent_table, :options)
+
+      DEFAULT_PARENT_KEYS = %i(id).freeze
+
+      param :attributes
+
+      param :parent_table, type: Dry::Types['strict.symbol']
+
+      option :parent_keys, default: -> { DEFAULT_PARENT_KEYS }
+    end
+  end
+end

data/lib/rom/sql/function.rb

@@ -1,9 +1,41 @@
-require 'rom/schema/attribute'
+require 'rom/attribute'
 
 module ROM
   module SQL
-    # @api private
-    class Function < ROM::Schema::Attribute
+    # @api public
+    class Function < ROM::Attribute
+      class << self
+        # @api private
+        def frame_limit(value)
+          case value
+          when :current then 'CURRENT ROW'
+          when :start then 'UNBOUNDED PRECEDING'
+          when :end then 'UNBOUNDED FOLLOWING'
+          else
+            if value > 0
+              "#{ value } FOLLOWING"
+            else
+              "#{ value.abs } PRECEDING"
+            end
+          end
+        end
+
+        private :frame_limit
+      end
+
+      # @api private
+      WINDOW_FRAMES = Hash.new do |cache, frame|
+        type = frame.key?(:rows) ? 'ROWS' : 'RANGE'
+        bounds = frame[:rows] || frame[:range]
+        cache[frame] = "#{ type } BETWEEN #{ frame_limit(bounds[0]) } AND #{ frame_limit(bounds[1])  }"
+      end
+
+      WINDOW_FRAMES[nil] = nil
+      WINDOW_FRAMES[:all] = WINDOW_FRAMES[rows: [:start, :end]]
+      WINDOW_FRAMES[:rows] = WINDOW_FRAMES[rows: [:start, :current]]
+      WINDOW_FRAMES[range: :current] = WINDOW_FRAMES[range: [:current, :current]]
+
+      # @api private
       def sql_literal(ds)
         if name
           ds.literal(func.as(name))
@@ -12,41 +44,87 @@ module ROM
         end
       end
 
+      # @api private
       def name
         meta[:alias] || super
       end
 
-      def qualified
+      # @api private
+      def qualified(table_alias = nil)
         meta(
-          func: ::Sequel::SQL::Function.new(func.name, *func.args.map { |arg| arg.respond_to?(:qualified) ? arg.qualified : arg })
+          func: ::Sequel::SQL::Function.new(func.name, *func.args.map { |arg| arg.respond_to?(:qualified) ? arg.qualified(table_alias) : arg })
         )
       end
 
+      # @api private
       def is(other)
         ::Sequel::SQL::BooleanExpression.new(:'=', func, other)
       end
 
+      # Add an OVER clause making a window function call
+      # @see https://www.postgresql.org/docs/9.6/static/tutorial-window.html
+      #
+      # @example
+      #   users.select { [id, int::row_number().over(partition: name, order: id).as(:row_no)] }
+      #   users.select { [id, int::row_number().over(partition: [first_name, last_name], order: id).as(:row_no)] }
+      #
+      # @example frame variants
+      #   # ROWS BETWEEN 3 PRECEDING AND CURRENT ROW
+      #   row_number.over(frame: { rows: [-3, :current] })
+      #
+      #   # ROWS BETWEEN 3 PRECEDING AND 3 FOLLOWING
+      #   row_number.over(frame: { rows: [-3, 3] })
+      #
+      #   # ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
+      #   row_number.over(frame: { rows: [:start, :current] })
+      #
+      #   # ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
+      #   row_number.over(frame: { rows: [:current, :end] })
+      #
+      # @example frame shortcuts
+      #   # ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
+      #   row_number.over(frame: :all)
+      #
+      #   # ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
+      #   row_number.over(frame: :rows)
+      #
+      #   # RANGE BETWEEN CURRENT ROW AND CURRENT ROW
+      #   row_number.over(frame: { range: :current} )
+      #
+      # @option :partition [Array<SQL::Attribute>,SQL::Attribute] A PARTITION BY part
+      # @option :order [Array<SQL::Attribute>,SQL::Attribute] An ORDER BY part
+      # @option :frame [Hash,Symbol] A frame part (RANGE or ROWS, see examples)
+      # @return [SQL::Function]
+      #
+      # @api public
+      def over(partition: nil, order: nil, frame: nil)
+        super(partition: partition, order: order, frame: WINDOW_FRAMES[frame])
+      end
+
       # Convert an expression result to another data type
       #
       # @example
       #   users.select { bool::cast(json_data.get_text('activated'), :boolean).as(:activated) }
+      #   users.select { bool::cast(json_data.get_text('activated')).as(:activated) }
       #
       # @param [ROM::SQL::Attribute] expr Expression to be cast
-      # @param [String] db_type Target database type
+      # @param [String] db_type Target database type (usually can be inferred from the target data type)
       #
       # @return [ROM::SQL::Attribute]
       #
-      # @api private
-      def cast(expr, db_type)
+      # @api public
+      def cast(expr, db_type = TypeSerializer[:default].call(type))
         Attribute[type].meta(sql_expr: ::Sequel.cast(expr, db_type))
       end
 
       private
 
+      # @api private
       def func
         meta[:func]
       end
 
+      # @api private
       def method_missing(meth, *args)
         if func
           if func.respond_to?(meth)

data/lib/rom/sql/gateway.rb

@@ -1,4 +1,5 @@
 require 'logger'
+require 'sequel/core'
 
 require 'dry/core/constants'
 
@@ -31,23 +32,6 @@ 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
@@ -71,14 +55,6 @@ module ROM
       #
       #   @param [Hash] options connection options
       #
-      #   @option options [Array<Symbol>] :inferrable_relations
-      #     A list of dataset names that should be inferred. If
-      #     this is set explicitly to an empty array relations
-      #     won't be inferred at all
-      #
-      #   @option options [Array<Symbol>] :not_inferrable_relations
-      #     A list of dataset names that should NOT be inferred
-      #
       #   @option options [Array<Symbol>] :extensions
       #     A list of connection extensions supported by Sequel
       #
@@ -118,7 +94,7 @@ module ROM
 
       # Return dataset with the given name
       #
-      # Thsi returns a raw Sequel database
+      # This returns a raw Sequel database
       #
       # @param [String, Symbol] name The dataset name
       #
@@ -202,6 +178,30 @@ module ROM
         @database_type ||= connection.database_type.to_sym
       end
 
+      # Call a SQL function
+      #
+      # @example
+      #   gateway.(:upper, 'John Doe') # => "JOHN DOE"
+      #
+      # @param [Symbol] function Function name
+      # @param [Array<Object>] args Function arguments
+      #
+      # @return [Object]
+      #
+      # @api public
+      def call(function, *args)
+        connection[Sequel.function(function, *args)].first.values.first
+      end
+
+      # Execute a statement
+      #
+      # @param [String] statement
+      #
+      # @api public
+      def run(statement)
+        connection.run(statement)
+      end
+
       private
 
       # Connect to database or reuse established connection instance

data/lib/rom/sql/index.rb

@@ -24,6 +24,10 @@ module ROM
       def partial?
         !predicate.nil?
       end
+
+      def can_access?(attribute)
+        !partial? && attributes[0].name == attribute.name
+      end
     end
   end
 end

data/lib/rom/sql/migration.rb

@@ -138,12 +138,12 @@ module ROM
       end
 
       # @api public
-      def auto_migrate!(conf)
+      def auto_migrate!(conf, options = EMPTY_HASH, &block)
         schemas = conf.relation_classes(self).map do |klass|
-          klass.schema || klass.schema_proc.call.finalize_attributes!(gateway: self)
+          klass.schema_proc.call.finalize_attributes!(gateway: self)
         end
 
-        migrator.auto_migrate!(self, schemas)
+        migrator.auto_migrate!(self, schemas, options)
       end
     end
   end

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

@@ -1,92 +1,18 @@
 module ROM
   module SQL
     module Migration
-      class Migrator
-        # @api private
-        class InlineRunner
-          attr_reader :gateway
+      # @api private
+      class InlineRunner < BasicObject
+        extend Initializer
 
-          def initialize(gateway)
-            @gateway = gateway
-          end
+        param :connection
 
-          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 |index|
-                index index.attributes,
-                      name: index.name,
-                      unique: index.unique?,
-                      type: index.type,
-                      where: index.predicate
-              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
+        def migration
+          yield(connection)
+        end
 
-              diff.index_changes.each do |index|
-                case index
-                when SchemaDiff::IndexAdded
-                  add_index index.attributes,
-                            name: index.name,
-                            unique: index.unique?,
-                            type: index.type,
-                            where: index.predicate
-                when SchemaDiff::IndexRemoved
-                  drop_index index.attributes, name: index.name
-                end
-              end
-            end
-          end
+        def method_missing(m, *args, &block)
+          connection.public_send(m, *args, &block)
         end
       end
     end

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

@@ -3,7 +3,9 @@ require 'pathname'
 require 'rom/types'
 require 'rom/initializer'
 require 'rom/sql/migration'
+require 'rom/sql/migration/runner'
 require 'rom/sql/migration/inline_runner'
+require 'rom/sql/migration/writer'
 
 module ROM
   module SQL
@@ -14,11 +16,14 @@ module ROM
 
         DEFAULT_PATH = 'db/migrate'.freeze
         VERSION_FORMAT = '%Y%m%d%H%M%S'.freeze
+        DEFAULT_INFERRER = Schema::Inferrer.new.suppress_errors.freeze
 
         param :connection
 
         option :path, type: ROM::Types.Definition(Pathname), default: -> { DEFAULT_PATH }
 
+        option :inferrer, default: -> { DEFAULT_INFERRER }
+
         # @api private
         def run(options = {})
           Sequel::Migrator.run(connection, path.to_s, options)
@@ -35,13 +40,16 @@ module ROM
         end
 
         # @api private
-        def create_file(name, version = generate_version)
-          filename = "#{version}_#{name}.rb"
+        def create_file(name, version = generate_version, **options)
+          sequence = options[:sequence] ? '%03d' % options[:sequence] : nil
+          filename = "#{ version }#{ sequence }_#{ name }.rb"
+          content = options[:content] || migration_file_content
+          path = options[:path] || self.path
           dirname = Pathname(path)
           fullpath = dirname.join(filename)
 
           FileUtils.mkdir_p(dirname)
-          File.write(fullpath, migration_file_content)
+          File.write(fullpath, content)
 
           fullpath
         end
@@ -57,19 +65,34 @@ module ROM
         end
 
         # @api private
-        def diff(gateway, inferrer, target)
-          empty = SQL::Schema.define(target.name)
-          current = target.with(inferrer.(empty, gateway))
+        def auto_migrate!(gateway, schemas, options = EMPTY_HASH, &block)
+          diff_finder = SchemaDiff.new(gateway.database_type)
 
-          SchemaDiff.new.(current, target)
-        end
+          changes = schemas.map { |target|
+            empty = SQL::Schema.define(target.name)
+            current = target.with(inferrer.(empty, gateway))
+
+            diff_finder.(current, target)
+          }.reject(&:empty?)
 
-        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 = migration_runner(options)
           runner.(changes)
         end
+
+        # @api private
+        def migration_runner(options)
+          if options[:inline]
+            Runner.new(InlineRunner.new(connection))
+          else
+            counter = 0
+            writer = Writer.new do |name, content|
+              create_file(name, **options, content: content, sequence: counter)
+              counter += 1
+            end
+
+            Runner.new(writer)
+          end
+        end
       end
     end
   end