rom-sql 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fb7aa3ae6fc950b9149086e31c3162e99a524b37
-  data.tar.gz: c324b47d45d23e01fc606d65f853b163e2699a59
+  metadata.gz: d4ee8c56fc0c1b34efb44c1d32c844765bc6c891
+  data.tar.gz: a2aeb62deb514cc3912f5fd512c9c02e2c9a24df
 SHA512:
-  metadata.gz: 172e07e4a8073164d7b9f8eec06eaefa16b052f7439a2b4d3f211cd2f932da9976df4d3a9863d525083b5e37a5dd230151b9a126f923cf8b5acdfb12b2b36469
-  data.tar.gz: 69352c745545be3e04a9eba2a196e0e2a3b59cd1d5f4782fa0ec9e78d78b4a5893b8bfa98f80a6bf208914ecc93a11dcc3f7e0f9549a10d764862eb110a2cf69
+  metadata.gz: '0942e1aeec2211371d871e1510f2668187581abcd5f4cbe447f2666a125678c4392c4e39fd0e8ceaecae227562d691b3ef8ab715a9ef111ed1ebb260ba5d64d4'
+  data.tar.gz: 3f08eac6477071a28cabb927690eaef0a0db41ee1bba0804f01a45e5317f5ba882765a06001313bed14309c8c169198071b45f07e8e22579a7956db669a0bf32

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+## v1.1.0 2017-03-01
+
+### Added
+
+* Added inferring for database indices (flash-gordon)
+* Restriction conditions are now coerced using schema attributes (solnic)
+* `:instrumentation` relation plugin that can be configured with any instrumentation backend (solnic)
+* `:auto_restrictions` relation plugin, which defines `by_*` views restricting relations by their indexed attributes (solnic)
+
+### Fixed
+
+* Missing `group` method was added to legacy `SequelAPI` module (solnic)
+* Associations properly maintain `order` if it was set (solnic)
+
+[Compare v1.0.3...v1.1.0](https://github.com/rom-rb/rom-sql/compare/v1.0.3...v1.1.0)
+
 ## v1.0.3 2017-02-23
 
 ### Changed

data/lib/rom/plugins/relation/sql/auto_restrictions.rb

@@ -0,0 +1,74 @@
+module ROM
+  module Plugins
+    module Relation
+      module SQL
+        # Generates methods for restricting relations by their indexed attributes
+        #
+        # This plugin must be enabled for the whole adapter, `use` won't work as
+        # schema is not yet available, unless it was defined explicitly.
+        #
+        # @example
+        #   rom = ROM.container(:sql, 'sqlite::memory') do |config|
+        #     config.create_table(:users) do
+        #       primary_key :id
+        #       column :email, String, null: false, unique: true
+        #     end
+        #
+        #     config.plugin(:sql, relations: :auto_restrictions)
+        #
+        #     config.relation(:users) do
+        #       schema(infer: true)
+        #     end
+        #   end
+        #
+        #   # now `by_email` is available automatically
+        #   rom.relations[:users].by_email('jane@doe.org')
+        #
+        # @api public
+        module AutoRestrictions
+          EmptySchemaError = Class.new(ArgumentError) do
+            def initialize(klass)
+              super("#{klass} relation has no schema. " \
+                    "Make sure :auto_restrictions is enabled after defining a schema")
+            end
+          end
+
+          def self.included(klass)
+            super
+            schema = klass.schema
+            raise EmptySchemaError, klass if schema.nil?
+            methods, mod = restriction_methods(schema)
+            klass.include(mod)
+            methods.each { |meth| klass.auto_curry(meth) }
+          end
+
+          def self.restriction_methods(schema)
+            mod = Module.new
+
+            indexed_attrs = schema.select { |attr| attr.meta[:index] }
+
+            methods = indexed_attrs.map do |attr|
+              meth_name = :"by_#{attr.name}"
+
+              mod.module_eval do
+                define_method(meth_name) do |value|
+                  where(attr.is(value))
+                end
+              end
+
+              meth_name
+            end
+
+            [methods, mod]
+          end
+        end
+      end
+    end
+  end
+end
+
+ROM.plugins do
+  adapter :sql do
+    register :auto_restrictions, ROM::Plugins::Relation::SQL::AutoRestrictions, type: :relation
+  end
+end

data/lib/rom/plugins/relation/sql/instrumentation.rb

@@ -0,0 +1,31 @@
+require 'rom/plugins/relation/instrumentation'
+
+module ROM
+  module Plugins
+    module Relation
+      module SQL
+        # @api private
+        module Instrumentation
+          def self.included(klass)
+            super
+
+            klass.class_eval do
+              include ROM::Plugins::Relation::Instrumentation
+
+              # @api private
+              def notification_payload(relation)
+                super.merge(query: relation.dataset.sql)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+ROM.plugins do
+  adapter :sql do
+    register :instrumentation, ROM::Plugins::Relation::SQL::Instrumentation, type: :relation
+  end
+end

data/lib/rom/sql/association/many_to_many.rb

@@ -37,9 +37,7 @@ module ROM
               right.schema.merge(join_rel.schema.project(left_fk))
             end.qualified
 
-          relation = left
-            .inner_join(source, join_keys(relations))
-            .order(*right.schema.project_pk.qualified)
+          relation = left.inner_join(source, join_keys(relations))
 
           if view
             apply_view(schema, relation)

data/lib/rom/sql/association/many_to_one.rb

@@ -21,9 +21,7 @@ module ROM
               left_schema.merge(right_schema.project_fk(left_pk => right_fk))
             end.qualified
 
-          relation = left
-            .inner_join(source_table, join_keys(relations))
-            .order(*right_schema.qualified)
+          relation = left.inner_join(source_table, join_keys(relations))
 
           if view
             apply_view(schema, relation)

data/lib/rom/sql/association/one_to_many.rb

@@ -8,9 +8,7 @@ module ROM
         def call(relations, right = relations[target.relation])
           schema = right.schema.qualified
 
-          relation = right
-                       .inner_join(source_table, join_keys(relations))
-                       .order(*right.schema.project_pk.qualified)
+          relation = right.inner_join(source_table, join_keys(relations))
 
           if view
             apply_view(schema, relation)

data/lib/rom/sql/attribute.rb

@@ -9,6 +9,8 @@ module ROM
     #
     # @api public
     class Attribute < ROM::Schema::Attribute
+      OPERATORS = %i[>= <= > <].freeze
+
       # Error raised when an attribute cannot be qualified
       QualifyError = Class.new(StandardError)
 
@@ -237,7 +239,9 @@ module ROM
       #
       # @api private
       def method_missing(meth, *args, &block)
-        if sql_expr.respond_to?(meth)
+        if OPERATORS.include?(meth)
+          __cmp__(meth, args[0])
+        elsif sql_expr.respond_to?(meth)
           meta(sql_expr: sql_expr.__send__(meth, *args, &block))
         else
           super
@@ -248,8 +252,16 @@ module ROM
       # the left part is the attribute value
       #
       # @api private
-      def __cmp__(op, r)
-        Sequel::SQL::BooleanExpression.new(op, self, r)
+      def __cmp__(op, other)
+        value =
+          case other
+          when Sequel::SQL::Expression
+            value
+          else
+            type[other]
+          end
+
+        Sequel::SQL::BooleanExpression.new(op, self, value)
       end
     end
   end

data/lib/rom/sql/plugins.rb

@@ -1,3 +1,6 @@
+require 'rom/plugins/relation/sql/instrumentation'
+require 'rom/plugins/relation/sql/auto_restrictions'
+
 require 'rom/sql/plugin/associates'
 require 'rom/sql/plugin/pagination'
 require 'rom/sql/plugin/timestamps'

data/lib/rom/sql/relation/reading.rb

@@ -45,7 +45,7 @@ module ROM
         #
         # @api public
         def first
-          dataset.first
+          limit(1).to_a.first
         end
 
         # Get last tuple from the relation
@@ -58,7 +58,7 @@ module ROM
         #
         # @api public
         def last
-          dataset.last
+          reverse.limit(1).first
         end
 
         # Prefix all columns in a relation
@@ -338,9 +338,11 @@ module ROM
         # @api public
         def where(*args, &block)
           if block
-            new(dataset.where(*args).where(self.class.schema.restriction(&block)))
+            where(*args).where(self.class.schema.restriction(&block))
+          elsif args.size == 1 && args[0].is_a?(Hash)
+            new(dataset.where(coerce_conditions(args[0])))
           else
-            new(dataset.__send__(__method__, *args))
+            new(dataset.where(*args))
           end
         end
 
@@ -784,11 +786,24 @@ module ROM
         #
         # @api public
         def read(sql)
-          new(dataset.db[sql])
+          new(dataset.db[sql], schema: schema.empty)
         end
 
         private
 
+        # Apply input types to condition values
+        #
+        # @api private
+        def coerce_conditions(conditions)
+          conditions.each_with_object({}) { |(k, v), h|
+            if k.is_a?(Symbol) && self.class.schema.key?(k)
+              h[k] = self.class.schema[k][v]
+            else
+              h[k] = v
+            end
+          }
+        end
+
         # Common join method used by other join methods
         #
         # @api private

data/lib/rom/sql/relation/sequel_api.rb

@@ -114,6 +114,20 @@ module ROM
       def left_join(*args, &block)
         new(dataset.__send__(__method__, *args, &block))
       end
+
+      # Group by specific columns
+      #
+      # @example
+      #   tasks.group(:user_id)
+      #
+      # @param [Array<Symbol>] *args A list of column names
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def group(*args, &block)
+        new(dataset.__send__(__method__, *args, &block))
+      end
     end
   end
 end

data/lib/rom/sql/schema.rb

@@ -95,6 +95,15 @@ module ROM
         relation.new(relation.dataset.select(*self), schema: self)
       end
 
+      # Return an empty schema
+      #
+      # @return [Schema]
+      #
+      # @api public
+      def empty
+        new(EMPTY_ARRAY)
+      end
+
       # @api private
       def finalize!(*)
         super do

data/lib/rom/sql/schema/inferrer.rb

@@ -1,3 +1,4 @@
+require 'set'
 require 'dry/core/class_attributes'
 
 module ROM
@@ -55,10 +56,12 @@ module ROM
           dataset = source.dataset
 
           columns = filter_columns(gateway.connection.schema(dataset))
+          all_indexes = indexes_for(gateway, dataset)
           fks = fks_for(gateway, dataset)
 
           inferred = columns.map do |(name, definition)|
-            type = build_type(definition.merge(foreign_key: fks[name]))
+            indexes = column_indexes(all_indexes, name)
+            type = build_type(**definition, foreign_key: fks[name], indexes: indexes)
 
             if type
               type.meta(name: name, source: source)
@@ -74,7 +77,7 @@ module ROM
           schema.reject { |(_, definition)| definition[:db_type] == CONSTRAINT_DB_TYPE }
         end
 
-        def build_type(primary_key:, db_type:, type:, allow_null:, foreign_key:, **rest)
+        def build_type(primary_key:, db_type:, type:, allow_null:, foreign_key:, indexes:, **rest)
           if primary_key
             map_pk_type(type, db_type)
           else
@@ -84,6 +87,8 @@ module ROM
               read_type = mapped_type.meta[:read]
               mapped_type = mapped_type.optional if allow_null
               mapped_type = mapped_type.meta(foreign_key: true, target: foreign_key) if foreign_key
+              mapped_type = mapped_type.meta(index: indexes) unless indexes.empty?
+
               if read_type && allow_null
                 mapped_type.meta(read: read_type.optional)
               elsif read_type
@@ -118,6 +123,24 @@ module ROM
           end
         end
 
+        # @api private
+        def indexes_for(gateway, dataset)
+          if gateway.connection.respond_to?(:indexes)
+            gateway.connection.indexes(dataset)
+          else
+            # index listing is not implemented
+            EMPTY_HASH
+          end
+        end
+
+        # @api private
+        def column_indexes(indexes, column)
+          indexes.each_with_object(Set.new) do |(name, idx), indexes|
+            indexes << name if idx[:columns][0] == column
+          end
+        end
+
+        # @api private
         def build_fk(columns: , table: , **rest)
           if columns.size == 1
             [columns[0], table]

data/lib/rom/sql/version.rb

@@ -1,5 +1,5 @@
 module ROM
   module SQL
-    VERSION = '1.0.3'.freeze
+    VERSION = '1.1.0'.freeze
   end
 end

data/rom-sql.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
   spec.add_runtime_dependency 'dry-types', '~> 0.9', '>= 0.9.4'
   spec.add_runtime_dependency 'dry-core', '~> 0.2', '>= 0.2.3'
-  spec.add_runtime_dependency 'rom', '~> 3.0'
+  spec.add_runtime_dependency 'rom', '~> 3.1'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake', '~> 10.0'

data/spec/integration/association/many_to_many_spec.rb

@@ -79,6 +79,21 @@ RSpec.describe ROM::SQL::Association::ManyToMany do
 
           expect(relation.to_a).to eql([id: 1, tag: 'important', name: 'important', task_id: 1])
         end
+
+        it 'respects custom order' do
+          conn[:tags].insert id: 2, name: 'boring'
+          conn[:task_tags].insert(tag_id: 2, task_id: 1)
+
+          relation = tags.
+                       order(tags[:name].qualified).
+                       for_combine(assoc).call(tasks.call)
+
+          expect(relation.to_a).
+            to eql([
+                     { id: 2, name: 'boring', task_id: 1 },
+                     { id: 1, name: 'important', task_id: 1 }
+                   ])
+        end
       end
     end
 

data/spec/integration/association/many_to_one_spec.rb

@@ -52,8 +52,10 @@ RSpec.describe ROM::SQL::Association::ManyToOne, helpers: true do
           expect(relation.where(user_id: 2).one).to eql(id: 2, task_id: 1, name: 'Joe')
 
           expect(relation.to_a).
-            to eql([{ id: 2, task_id: 1, name: 'Joe' },
-                    { id: 1, task_id: 2, name: 'Jane' }])
+            to eql([
+                     { id: 1, task_id: 2, name: 'Jane' },
+                     { id: 2, task_id: 1, name: 'Joe' }
+                   ])
         end
       end
 
@@ -62,12 +64,14 @@ RSpec.describe ROM::SQL::Association::ManyToOne, helpers: true do
           relation = users.for_combine(assoc).call(tasks.call)
 
           expect(relation.to_a).
-            to eql([{ id: 2, task_id: 1, name: 'Joe' },
-                    { id: 1, task_id: 2, name: 'Jane' }])
+            to eql([
+                     { id: 1, task_id: 2, name: 'Jane' },
+                     { id: 2, task_id: 1, name: 'Joe' }
+                   ])
         end
 
         it 'maintains original relation' do
-          users.accounts.insert(user_id: 2, number: 'a1', balance: 0)
+          users.accounts.insert(user_id: 2, number: '31', balance: 0)
 
           relation = users.
                        join(:accounts, user_id: :id).
@@ -76,7 +80,7 @@ RSpec.describe ROM::SQL::Association::ManyToOne, helpers: true do
                        for_combine(assoc).call(tasks.call)
 
           expect(relation.to_a).
-            to eql([{ id: 2, task_id: 1, name: 'Joe', account_num: 'a1' },
+            to eql([{ id: 2, task_id: 1, name: 'Joe', account_num: '31' },
                     { id: 1, task_id: 2, name: 'Jane', account_num: '42' }])
         end
       end

data/spec/integration/association/one_to_many_spec.rb

@@ -59,6 +59,15 @@ RSpec.describe ROM::SQL::Association::OneToMany do
 
         expect(relation.to_a).to eql([{ id: 1, user_id: 2, title: "Joe's task", tag_id: 1 }])
       end
+
+      it 'respects custom order' do
+        relation = tasks.
+                     order(tasks[:title].qualified).
+                     for_combine(assoc).call(users.call)
+
+        expect(relation.to_a).
+          to eql([{ id: 2, user_id: 1, title: "Jane's task" }, { id: 1, user_id: 2, title: "Joe's task" }])
+      end
     end
   end
 end

data/spec/integration/commands/create_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
   let(:users) { commands[:users] }
   let(:tasks) { commands[:tasks] }
 
-  before do
+  before do |ex|
     module Test
       class Params < Dry::Struct
         attribute :name, Types::Strict::String.optional
@@ -19,6 +19,12 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
 
     conn.add_index :users, :name, unique: true
 
+    if sqlite?(ex)
+      conn.add_index :tasks, :title, unique: true
+    else
+      conn.execute "ALTER TABLE tasks add CONSTRAINT tasks_title_key UNIQUE (title)"
+    end
+
     conf.commands(:users) do
       define(:create) do
         input Test::Params

data/spec/integration/commands/upsert_spec.rb

@@ -6,6 +6,8 @@ RSpec.describe 'Commands / Postgres / Upsert', :postgres, seeds: false do
   let(:tasks) { commands[:tasks] }
 
   before do
+    conn.execute "ALTER TABLE tasks add CONSTRAINT tasks_title_key UNIQUE (title)"
+
     conn[:users].insert id: 1, name: 'Jane'
     conn[:users].insert id: 2, name: 'Joe'
     conn[:users].insert id: 3, name: 'Jean'

data/spec/integration/plugins/auto_restrictions_spec.rb

@@ -0,0 +1,54 @@
+RSpec.describe 'Plugins / :auto_restrictions', seeds: true do
+  include_context 'users and tasks'
+
+  with_adapters do
+    before do
+      conn.add_index :tasks, :title, unique: true
+    end
+
+    shared_context 'auto-generated restriction view' do
+      it 'defines restriction views for all indexed attributes' do
+        expect(tasks.select(:id).by_title("Jane's task").one).to eql(id: 2)
+      end
+
+      it 'defines curried methods' do
+        expect(tasks.by_title.("Jane's task").first).to eql(id: 2, user_id: 1, title: "Jane's task")
+      end
+    end
+
+    context 'with an inferred schema' do
+      before do
+        conf.plugin(:sql, relations: :auto_restrictions)
+      end
+
+      include_context 'auto-generated restriction view'
+    end
+
+    context 'with explicit schema' do
+      before do
+        conf.relation(:tasks) do
+          schema do
+            attribute :id, ROM::SQL::Types::Serial
+            attribute :user_id, ROM::SQL::Types::Int
+            attribute :title, ROM::SQL::Types::String.meta(index: true)
+          end
+
+          use :auto_restrictions
+        end
+      end
+
+      include_context 'auto-generated restriction view'
+    end
+
+    it 'raises error when enabled w/o a schema' do
+      expect {
+        conf.relation(:tasks) do
+          use :auto_restrictions
+        end
+      }.to raise_error(
+             ROM::Plugins::Relation::SQL::AutoRestrictions::EmptySchemaError,
+             "ROM::Relation[Tasks] relation has no schema. Make sure :auto_restrictions is enabled after defining a schema"
+           )
+    end
+  end
+end

data/spec/integration/schema/inferrer_spec.rb

@@ -38,7 +38,13 @@ RSpec.describe 'Schema inference for common datatypes', seeds: false do
         let(:dataset) { :tasks }
         let(:source) { ROM::Relation::Name[:tasks] }
 
-        it 'can infer attributes for dataset' do
+        it 'can infer attributes for dataset' do |ex|
+          if mysql?(ex)
+            indexes = { index: %i(user_id).to_set }
+          else
+            indexes = {}
+          end
+
           expect(schema.to_h).
             to eql(
                  id: ROM::SQL::Types::Serial.meta(name: :id, source: source),
@@ -47,7 +53,8 @@ RSpec.describe 'Schema inference for common datatypes', seeds: false do
                    name: :user_id,
                    foreign_key: true,
                    source: source,
-                   target: :users
+                   target: :users,
+                   **indexes
                  )
                )
         end
@@ -87,14 +94,15 @@ RSpec.describe 'Schema inference for common datatypes', seeds: false do
         it 'can infer attributes for dataset' do |ex|
           date_type = oracle?(ex) ? ROM::SQL::Types::Time : ROM::SQL::Types::Date
 
-          expect(schema.to_h).to eql(
-            id: ROM::SQL::Types::Serial.meta(name: :id, source: source),
-            text: ROM::SQL::Types::String.meta(name: :text, source: source),
-            time: ROM::SQL::Types::Time.optional.meta(name: :time, source: source),
-            date: date_type.optional.meta(name: :date, source: source),
-            datetime: ROM::SQL::Types::Time.meta(name: :datetime, source: source),
-            data: ROM::SQL::Types::Blob.optional.meta(name: :data, source: source),
-          )
+          expect(schema.to_h).
+            to eql(
+                 id: ROM::SQL::Types::Serial.meta(name: :id, source: source),
+                 text: ROM::SQL::Types::String.meta(name: :text, source: source),
+                 time: ROM::SQL::Types::Time.optional.meta(name: :time, source: source),
+                 date: date_type.optional.meta(name: :date, source: source),
+                 datetime: ROM::SQL::Types::Time.meta(name: :datetime, source: source),
+                 data: ROM::SQL::Types::Blob.optional.meta(name: :data, source: source),
+               )
         end
       end
 
@@ -130,16 +138,17 @@ RSpec.describe 'Schema inference for common datatypes', seeds: false do
 
           pending 'Add precision inferrence for Oracle' if oracle?(example)
 
-          expect(schema.to_h).to eql(
-            id: ROM::SQL::Types::Serial.meta(name: :id, source: source),
-            dec: default_precision,
-            dec_prec: decimal.meta(name: :dec_prec, precision: 12, scale: 0),
-            num: decimal.meta(name: :num, precision: 5, scale: 2),
-            small: ROM::SQL::Types::Int.optional.meta(name: :small, source: source),
-            int: ROM::SQL::Types::Int.optional.meta(name: :int, source: source),
-            floating: ROM::SQL::Types::Float.optional.meta(name: :floating, source: source),
-            double_p: ROM::SQL::Types::Float.optional.meta(name: :double_p, source: source),
-          )
+          expect(schema.to_h).
+            to eql(
+                 id: ROM::SQL::Types::Serial.meta(name: :id, source: source),
+                 dec: default_precision,
+                 dec_prec: decimal.meta(name: :dec_prec, precision: 12, scale: 0),
+                 num: decimal.meta(name: :num, precision: 5, scale: 2),
+                 small: ROM::SQL::Types::Int.optional.meta(name: :small, source: source),
+                 int: ROM::SQL::Types::Int.optional.meta(name: :int, source: source),
+                 floating: ROM::SQL::Types::Float.optional.meta(name: :floating, source: source),
+                 double_p: ROM::SQL::Types::Float.optional.meta(name: :double_p, source: source),
+               )
         end
       end
     end
@@ -300,5 +309,39 @@ RSpec.describe 'Schema inference for common datatypes', seeds: false do
         end
       end
     end
+
+    describe 'inferring indices', oracle: false do
+      before do |ex|
+        ctx = self
+
+        conn.create_table :test_inferrence do
+          primary_key :id
+          Integer :foo
+          Integer :bar, null: false
+          Integer :baz, null: false
+
+          index :foo, name: :foo_idx
+          index :bar, name: :bar_idx
+          index :baz, name: :baz1_idx
+          index :baz, name: :baz2_idx
+
+          index %i(bar baz), name: :composite_idx
+        end
+      end
+
+      let(:dataset) { :test_inferrence }
+      let(:source) { ROM::Relation::Name[dataset] }
+
+      it 'infers types with indices' do
+        int = ROM::SQL::Types::Int
+        expect(schema.to_h).
+          to eql(
+               id: int.meta(name: :id, source: source, primary_key: true),
+               foo: int.optional.meta(name: :foo, source: source, index: %i(foo_idx).to_set),
+               bar: int.meta(name: :bar, source: source, index: %i(bar_idx composite_idx).to_set),
+               baz: int.meta(name: :baz, source: source, index: %i(baz1_idx baz2_idx).to_set)
+             )
+      end
+    end
   end
 end

data/spec/integration/sequel_api_spec.rb

@@ -28,4 +28,10 @@ RSpec.describe 'Using legacy sequel api', :sqlite do
       expect(users.where(name: 'Jane').first).to eql(id: 1, name: 'Jane')
     end
   end
+
+  describe '#order' do
+    it 'orders relation' do
+      expect(users.order(:users__name).first).to eql(id: 1, name: 'Jane')
+    end
+  end
 end

data/spec/shared/users_and_tasks.rb

@@ -13,7 +13,7 @@ RSpec.shared_context 'users and tasks' do
     conn.create_table :tasks do
       primary_key :id
       foreign_key :user_id, :users
-      String :title, unique: true
+      String :title
       constraint(:title_length) { char_length(title) > 1 } if ctx.postgres?(example)
       constraint(:title_length) { length(title) > 1 }      if ctx.sqlite?(example)
     end

data/spec/unit/relation/instrument_spec.rb

@@ -0,0 +1,45 @@
+RSpec.describe ROM::SQL::Relation, '#instrument', :sqlite do
+  include_context 'users and tasks'
+
+  subject(:relation) do
+    relations[:users]
+  end
+
+  let(:notifications) do
+    spy(:notifications)
+  end
+
+  before do
+    conf.plugin(:sql, relations: :instrumentation) do |p|
+      p.notifications = notifications
+    end
+  end
+
+  it 'instruments relation materialization' do
+    users.to_a
+
+    expect(notifications).
+      to have_received(:instrument).with(:sql, name: :users, query: users.dataset.sql)
+  end
+
+  it 'instruments methods that return a single tuple' do
+    users.first
+
+    expect(notifications).
+      to have_received(:instrument).with(:sql, name: :users, query: users.limit(1).dataset.sql)
+
+    users.last
+
+    expect(notifications).
+      to have_received(:instrument).with(:sql, name: :users, query: users.reverse.limit(1).dataset.sql)
+  end
+
+  it 'instruments aggregation methods' do
+    pending "no idea how to make this work with sequel"
+
+    users.count
+
+    expect(notifications).
+      to have_received(:instrument).with(:sql, name: :users, query: 'SELECT COUNT(*) FROM users')
+  end
+end

data/spec/unit/relation/read_spec.rb

@@ -17,5 +17,9 @@ RSpec.describe ROM::Relation, '#read' do
       expect(materialized).to match_array([{ name: 'Jane' }, { name: 'Joe' }])
       expect(materialized.source).to be(users)
     end
+
+    it 'has empty schema' do
+      expect(users.schema).to be_empty
+    end
   end
 end

data/spec/unit/relation/where_spec.rb

@@ -3,54 +3,100 @@ RSpec.describe ROM::Relation, '#where' do
 
   include_context 'users and tasks'
 
-  before do
-    conf.relation(:tasks) { schema(infer: true) }
-  end
-
   with_adapters do
-    it 'restricts relation using provided conditions' do
-      expect(relation.where(id: 1).to_a).
-        to eql([{ id: 1, title: "Joe's task" }])
-    end
+    context 'without :read types' do
+      it 'restricts relation using provided conditions' do
+        expect(relation.where(id: 1).to_a).
+          to eql([{ id: 1, title: "Joe's task" }])
+      end
 
-    it 'restricts relation using provided conditions and block' do
-      expect(relation.where(id: 1) { title.like("%Jane%") }.to_a).to be_empty
-    end
+      it 'restricts relation using provided conditions and block' do
+        expect(relation.where(id: 1) { title.like("%Jane%") }.to_a).to be_empty
+      end
 
-    it 'restricts relation using provided conditions in a block' do
-      expect(relation.where { (id > 2) & title.like("%Jane%") }.to_a).to be_empty
-    end
+      it 'restricts relation using provided conditions in a block' do
+        expect(relation.where { (id > 2) & title.like("%Jane%") }.to_a).to be_empty
+      end
 
-    it 'restricts relation using canonical attributes' do
-      expect(relation.rename(id: :user_id).where { id > 3 }.to_a).to be_empty
-    end
+      it 'restricts relation using canonical attributes' do
+        expect(relation.rename(id: :user_id).where { id > 3 }.to_a).to be_empty
+      end
 
-    it 'restricts with or condition' do
-      expect(relation.where { id.is(1) | id.is(2) }.to_a).
-        to eql([{ id: 1, title: "Joe's task" }, { id: 2, title: "Jane's task" }])
-    end
+      it 'restricts with or condition' do
+        expect(relation.where { id.is(1) | id.is(2) }.to_a).
+          to eql([{ id: 1, title: "Joe's task" }, { id: 2, title: "Jane's task" }])
+      end
 
-    it 'restricts with a range condition' do
-      expect(relation.where { id.in(-1...2) }.to_a).
-        to eql([{ id: 1, title: "Joe's task" }])
+      it 'restricts with a range condition' do
+        expect(relation.where { id.in(-1...2) }.to_a).
+          to eql([{ id: 1, title: "Joe's task" }])
 
-      expect(relation.where { id.in(0...3) }.to_a).
-        to eql([{ id: 1, title: "Joe's task" }, { id: 2, title: "Jane's task" }])
-    end
+        expect(relation.where { id.in(0...3) }.to_a).
+          to eql([{ id: 1, title: "Joe's task" }, { id: 2, title: "Jane's task" }])
+      end
 
-    it 'restricts with an inclusive range' do
-      expect(relation.where { id.in(0..2) }.to_a).
-        to eql([{ id: 1, title: "Joe's task" }, { id: 2, title: "Jane's task" }])
-    end
+      it 'restricts with an inclusive range' do
+        expect(relation.where { id.in(0..2) }.to_a).
+          to eql([{ id: 1, title: "Joe's task" }, { id: 2, title: "Jane's task" }])
+      end
 
-    it 'restricts with an ordinary enum' do
-      expect(relation.where { id.in(2, 3) }.to_a).
-        to eql([{ id: 2, title: "Jane's task" }])
+      it 'restricts with an ordinary enum' do
+        expect(relation.where { id.in(2, 3) }.to_a).
+          to eql([{ id: 2, title: "Jane's task" }])
+      end
+
+      it 'restricts with enum using self syntax' do
+        expect(relation.where(relation[:id].in(2, 3)).to_a).
+          to eql([{ id: 2, title: "Jane's task" }])
+      end
     end
 
-    it 'restricts with enum using self syntax' do
-      expect(relation.where(relation[:id].in(2, 3)).to_a).
-        to eql([{ id: 2, title: "Jane's task" }])
+    context 'with :read types' do
+      before do
+        conf.relation(:tasks) do
+          schema(infer: true) do
+            attribute :id, ROM::SQL::Types::Serial.constructor(&:to_i)
+            attribute :title, ROM::SQL::Types::Coercible::String
+          end
+        end
+
+        module Test
+          Id = Struct.new(:v) do
+            def to_i
+              v.to_i
+            end
+          end
+
+          Title = Struct.new(:v) do
+            def to_s
+              v.to_s
+            end
+          end
+        end
+      end
+
+      it 'applies write_schema to hash conditions' do
+        rel = tasks.where(id: Test::Id.new('2'), title: Test::Title.new(:"Jane's task"))
+
+        expect(rel.first).
+          to eql(id: 2, user_id: 1, title: "Jane's task")
+      end
+
+      it 'applies write_schema to conditions with operators other than equality' do
+        rel = tasks.where { id >= Test::Id.new('2') }
+
+        expect(rel.first).
+          to eql(id: 2, user_id: 1, title: "Jane's task")
+      end
+
+      it 'applies write_schema to conditions in a block' do
+        rel = tasks.where {
+          id.is(Test::Id.new('2')) & title.is(Test::Title.new(:"Jane's task"))
+        }
+
+        expect(rel.first).
+          to eql(id: 2, user_id: 1, title: "Jane's task")
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rom-sql
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-23 00:00:00.000000000 Z
+date: 2017-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -84,14 +84,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -154,7 +154,9 @@ files:
 - circle.yml
 - lib/rom-sql.rb
 - lib/rom/plugins/relation/sql/auto_combine.rb
+- lib/rom/plugins/relation/sql/auto_restrictions.rb
 - lib/rom/plugins/relation/sql/auto_wrap.rb
+- lib/rom/plugins/relation/sql/instrumentation.rb
 - lib/rom/sql.rb
 - lib/rom/sql/association.rb
 - lib/rom/sql/association/many_to_many.rb
@@ -241,6 +243,7 @@ files:
 - spec/integration/migration_spec.rb
 - spec/integration/plugins/associates/many_to_many_spec.rb
 - spec/integration/plugins/associates_spec.rb
+- spec/integration/plugins/auto_restrictions_spec.rb
 - spec/integration/plugins/auto_wrap_spec.rb
 - spec/integration/relation_schema_spec.rb
 - spec/integration/schema/call_spec.rb
@@ -297,6 +300,7 @@ files:
 - spec/unit/relation/having_spec.rb
 - spec/unit/relation/inner_join_spec.rb
 - spec/unit/relation/inspect_spec.rb
+- spec/unit/relation/instrument_spec.rb
 - spec/unit/relation/invert_spec.rb
 - spec/unit/relation/left_join_spec.rb
 - spec/unit/relation/map_spec.rb
@@ -372,6 +376,7 @@ test_files:
 - spec/integration/migration_spec.rb
 - spec/integration/plugins/associates/many_to_many_spec.rb
 - spec/integration/plugins/associates_spec.rb
+- spec/integration/plugins/auto_restrictions_spec.rb
 - spec/integration/plugins/auto_wrap_spec.rb
 - spec/integration/relation_schema_spec.rb
 - spec/integration/schema/call_spec.rb
@@ -428,6 +433,7 @@ test_files:
 - spec/unit/relation/having_spec.rb
 - spec/unit/relation/inner_join_spec.rb
 - spec/unit/relation/inspect_spec.rb
+- spec/unit/relation/instrument_spec.rb
 - spec/unit/relation/invert_spec.rb
 - spec/unit/relation/left_join_spec.rb
 - spec/unit/relation/map_spec.rb