rom-sql 1.3.2 → 1.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dfb29b79f9b58b2fc9b30752951636130b525440
-  data.tar.gz: 2f6b70d93abf536152d991cb689bd77c699a6e83
+  metadata.gz: df694b716a7959598f6ee28219b03220b77ef0ac
+  data.tar.gz: 1538e2d437b5d2f70558034265dd95f72744cb45
 SHA512:
-  metadata.gz: ac6401a56919535a010c3ad049d63df969873c73169f629c5875edd343b404cf02ffc81f3458e9bbb6d3c20edc066fa5e26b2db30840a321f5ea10d5a86c5de4
-  data.tar.gz: d9e27f5a201c515fcd2d2d0a2f5cacae6cfdd2f44d1dfd5c0260c2121714c0491f8c49f87ed6120690d8d7f1603dcbc7308598c7e1000c4da4b775cf8d5494fa
+  metadata.gz: c91a6eb888e659acded2991fc35f98a83db8bb7bd78aacbeda58a501d0f81e3f181a4314f023f0dea430162fd5542ecf7b66f92919340ea3612fd938ef3e5951
+  data.tar.gz: 22762cfe11ae565da6b0583e715f07079b1e2d652b74bce753739228b90052067d2185910ecd102d8a25780addb147955d60f978ff04ffe94475413c5aefcdd8

data/CHANGELOG.md

@@ -1,18 +1,43 @@
-## v1.3.2 to-be-released
+## v1.3.3 to-be-released
 
-## Added
+### Added
+
+* `Relation#lock`, row-level locking using the `SELECT FOR UPDATE` clause (flash-gordon)
+* `get` and `get_text` methods for the `PG::JSON` type (flash-gordon)
+* Support for converting data type with `CAST` using the function DSL (flash-gordon)
+
+  ```ruby
+    users.select { string::cast(id, 'varchar').as(:id_str) }
+  ```
+
+* Support for`EXISTS` (v-kolesnikov)
+
+  ```ruby
+    subquery = tasks.where(tasks[:user_id].qualified => users[:id].qualified)
+    users.where { exists(subquery) }
+  ```
+
+### Fixed
+
+* Fixed a regression introduced in v1.3.2 caused by doing way more work processing the default dataset (flash-gordon)
+
+## v1.3.2 2017-05-13
+
+### Added
 
 * Support for filtering with a SQL function in the `WHERE` clause. Be sure you're using it wisely and don't call it on large datasets ;) (flash-gordon)
 * `Void` type for calling functions without returning value (flash-gordon)
-* Support for `PG::Array` transformations and queries (flash-gordon)
+* Support for [`PG::Array` transformations and queries](https://github.com/rom-rb/rom-sql/blob/15019a40e2cf2a224476184c4cddab4062a2cc01/lib/rom/sql/extensions/postgres/types.rb#L23-L148) (flash-gordon)
 
-## Fixed
+### Fixed
 
 * A bunch of warnings from Sequel 4.46
 
+[Compare v1.3.1...v1.3.2](https://github.com/rom-rb/rom-sql/compare/v1.3.1...v1.3.2)
+
 ## v1.3.1 2017-05-05
 
-## Changed
+### Changed
 
 * [internal] Compatibility with `dry-core` v0.3.0 (flash-gordon)
 
@@ -23,7 +48,7 @@
 ### Added
 
 * New `Relation#exist?` predicate checks if the relation has at least one tuple (flash-gordon)
-* Support for [JSONB transformations and queries](https://github.com/rom-rb/rom-sql/blob/master/lib/rom/sql/extensions/postgres/types.rb#L43-L190) using native DSL (flash-gordon)
+* Support for [JSONB transformations and queries](https://github.com/rom-rb/rom-sql/blob/15019a40e2cf2a224476184c4cddab4062a2cc01/lib/rom/sql/extensions/postgres/types.rb#L170-L353) using native DSL (flash-gordon)
 * Add `ROM::SQL::Attribute#not` for negated boolean equality expressions (AMHOL)
 * Add `ROM::SQL::Attribute#!` for negated attribute's sql expressions (solnic)
 * Inferrer gets limit constraints for string data types and stores them in type's meta (v-kolesnikov)

data/Gemfile

@@ -2,7 +2,7 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem 'rom', git: 'https://github.com/rom-rb/rom.git', branch: 'master'
+gem 'rom', git: 'https://github.com/rom-rb/rom.git', branch: 'release-3.0'
 
 group :test do
   gem 'byebug', platforms: :mri

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

@@ -208,7 +208,7 @@ module ROM
         #     #
         #     #   @param [Array<Integer>,Array<String>] path Path to extract
         #     #
-        #     #   @return [SQL::Attribute<Types::PG::JSONB>]
+        #     #   @return [SQL::Attribute<Types::PG::JSON>,SQL::Attribute<Types::PG::JSONB>]
         #     #
         #     #   @api public
         #
@@ -228,7 +228,7 @@ module ROM
         #     #   @api public
         #
         #     # @!method has_key(key)
-        #     #   Does the JSON value has the specified top-level key
+        #     #   Does the JSON value have the specified top-level key
         #     #   Translates to ?
         #     #
         #     #   @example
@@ -241,7 +241,7 @@ module ROM
         #     #   @api public
         #
         #     # @!method has_any_key(*keys)
-        #     #   Does the JSON value has any of the specified top-level keys
+        #     #   Does the JSON value have any of the specified top-level keys
         #     #   Translates to ?|
         #     #
         #     #   @example
@@ -254,7 +254,7 @@ module ROM
         #     #   @api public
         #
         #     # @!method has_all_keys(*keys)
-        #     #   Does the JSON value has all the specified top-level keys
+        #     #   Does the JSON value have all the specified top-level keys
         #     #   Translates to ?&
         #     #
         #     #   @example
@@ -302,54 +302,71 @@ module ROM
         #     #
         #     #   @api public
         #   end
-        Attribute::TypeExtensions.register(JSONB) do
-          def contain(type, expr, value)
-            Attribute[Types::Bool].meta(sql_expr: expr.pg_jsonb.contains(value))
-          end
-
-          def contained_by(type, expr, value)
-            Attribute[Types::Bool].meta(sql_expr: expr.pg_jsonb.contained_by(value))
+        module JSONMethods
+          def self.[](type, wrap)
+            parent = self
+            Module.new do
+              include parent
+              define_method(:json_type) { type }
+              define_method(:wrap, wrap)
+            end
           end
 
           def get(type, expr, *path)
-            Attribute[JSONB].meta(sql_expr: expr.pg_jsonb[path_args(path)])
+            Attribute[json_type].meta(sql_expr: wrap(expr)[path_args(path)])
           end
 
           def get_text(type, expr, *path)
-            Attribute[Types::String].meta(sql_expr: expr.pg_jsonb.get_text(path_args(path)))
+            Attribute[Types::String].meta(sql_expr: wrap(expr).get_text(path_args(path)))
+          end
+
+          private
+
+          def path_args(path)
+            case path.size
+            when 0 then raise ArgumentError, "wrong number of arguments (given 0, expected 1+)"
+            when 1 then path[0]
+            else path
+            end
+          end
+        end
+
+        Attribute::TypeExtensions.register(JSON) do
+          include JSONMethods[JSON, :pg_json.to_proc]
+        end
+
+        Attribute::TypeExtensions.register(JSONB) do
+          include JSONMethods[JSONB, :pg_jsonb.to_proc]
+
+          def contain(type, expr, value)
+            Attribute[Types::Bool].meta(sql_expr: wrap(expr).contains(value))
+          end
+
+          def contained_by(type, expr, value)
+            Attribute[Types::Bool].meta(sql_expr: wrap(expr).contained_by(value))
           end
 
           def has_key(type, expr, key)
-            Attribute[Types::Bool].meta(sql_expr: expr.pg_jsonb.has_key?(key))
+            Attribute[Types::Bool].meta(sql_expr: wrap(expr).has_key?(key))
           end
 
           def has_any_key(type, expr, *keys)
-            Attribute[Types::Bool].meta(sql_expr: expr.pg_jsonb.contain_any(keys))
+            Attribute[Types::Bool].meta(sql_expr: wrap(expr).contain_any(keys))
           end
 
           def has_all_keys(type, expr, *keys)
-            Attribute[Types::Bool].meta(sql_expr: expr.pg_jsonb.contain_all(keys))
+            Attribute[Types::Bool].meta(sql_expr: wrap(expr).contain_all(keys))
           end
 
           def merge(type, expr, value)
-            Attribute[JSONB].meta(sql_expr: expr.pg_jsonb.concat(value))
+            Attribute[JSONB].meta(sql_expr: wrap(expr).concat(value))
           end
           alias_method :+, :merge
 
           def delete(type, expr, *path)
-            sql_expr = path.size == 1 ? expr.pg_jsonb - path : expr.pg_jsonb.delete_path(path)
+            sql_expr = path.size == 1 ? wrap(expr) - path : wrap(expr).delete_path(path)
             Attribute[JSONB].meta(sql_expr: sql_expr)
           end
-
-          private
-
-          def path_args(path)
-            case path.size
-            when 0 then raise ArgumentError, "wrong number of arguments (given 0, expected 1+)"
-            when 1 then path[0]
-            else path
-            end
-          end
         end
 
         # HStore

data/lib/rom/sql/function.rb

@@ -26,6 +26,21 @@ module ROM
         ::Sequel::SQL::BooleanExpression.new(:'=', func, other)
       end
 
+      # Convert an expression result to another data type
+      #
+      # @example
+      #   users.select { bool::cast(json_data.get_text('activated'), :boolean).as(:activated) }
+      #
+      # @param [ROM::SQL::Attribute] expr Expression to be cast
+      # @param [String] db_type Target database type
+      #
+      # @return [ROM::SQL::Attribute]
+      #
+      # @api private
+      def cast(expr, db_type)
+        Attribute[type].meta(sql_expr: ::Sequel.cast(expr, db_type))
+      end
+
       private
 
       def func

data/lib/rom/sql/relation.rb

@@ -54,7 +54,7 @@ module ROM
 
             if db.table_exists?(table)
               if schema
-                select(*schema).order(*schema.project(*schema.primary_key_names).qualified)
+                select(*schema.map(&:to_sql_name)).order(*schema.project(*schema.primary_key_names).qualified.map(&:to_sql_name))
               else
                 select(*columns).order(*klass.primary_key_columns(db, table))
               end

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

@@ -7,6 +7,22 @@ module ROM
       #
       # @api public
       module Reading
+        # Row-level lock modes
+        ROW_LOCK_MODES = Hash.new(update: 'FOR UPDATE'.freeze).update(
+          # https://www.postgresql.org/docs/current/static/sql-select.html#SQL-FOR-UPDATE-SHARE
+          postgres: {
+            update: 'FOR UPDATE'.freeze,
+            no_key_update: 'FOR NO KEY UPDATE'.freeze,
+            share: 'FOR SHARE'.freeze,
+            key_share: 'FOR KEY SHARE'.freeze
+          },
+          # https://dev.mysql.com/doc/refman/5.7/en/innodb-locking-reads.html
+          mysql: {
+            update: 'FOR UPDATE'.freeze,
+            share: 'LOCK IN SHARE MODE'.freeze
+          }
+        ).freeze
+
         # Fetch a tuple identified by the pk
         #
         # @example
@@ -810,8 +826,64 @@ module ROM
           new(dataset.db[sql], schema: schema.empty)
         end
 
+        # Lock rows with in the specified mode. Check out ROW_LOCK_MODES for the
+        # list of supported modes, keep in mind available lock modes heavily depend on
+        # the database type+version you're running on.
+        #
+        # @overload lock(options)
+        #   @option options [Symbol] :mode Lock mode
+        #   @option options [Boolean,Integer] :wait Controls the (NO)WAIT part
+        #   @option options [Boolean] :skip_locked Skip locked rows
+        #   @option options [Array,Symbol,String] :of List of objects in the OF part
+        #
+        #   @return [SQL::Relation]
+        #
+        # @overload lock(options, &block)
+        #   Runs the block inside a transaction. The relation will be materialized
+        #   and passed inside the block so that the lock will be acquired right before
+        #   the block gets executed.
+        #
+        #   @param [Hash] options The same options as for the version without a block
+        #   @yieldparam relation [Array]
+        #
+        # @api public
+        def lock(options = EMPTY_HASH, &block)
+          clause = lock_clause(options)
+
+          if block
+            dataset.db.transaction do
+              block.call(dataset.lock_style(clause).to_a)
+            end
+          else
+            new(dataset.lock_style(clause))
+          end
+        end
+
         private
 
+        # Build a locking clause
+        #
+        # @api private
+        def lock_clause(mode: :update, skip_locked: false, of: nil, wait: nil)
+          stmt = ROW_LOCK_MODES[dataset.db.database_type].fetch(mode).dup
+          stmt << ' OF ' << Array(of).join(', ') if of
+
+          if skip_locked
+            raise ArgumentError, "SKIP LOCKED cannot be used with (NO)WAIT clause" if !wait.nil?
+
+            stmt << ' SKIP LOCKED'
+          else
+            case wait
+            when Integer
+              stmt << ' WAIT ' << wait.to_s
+            when false
+              stmt << ' NOWAIT'
+            else
+              stmt
+            end
+          end
+        end
+
         # Apply input types to condition values
         #
         # @api private

data/lib/rom/sql/restriction_dsl.rb

@@ -9,6 +9,14 @@ module ROM
         instance_exec(&block)
       end
 
+      # Returns a result of SQL EXISTS clause.
+      #
+      # @example
+      #   users.where { exists(users.where(name: 'John')) }
+      def exists(relation)
+        relation.dataset.exists
+      end
+
       private
 
       # @api private

data/lib/rom/sql/version.rb

@@ -1,5 +1,5 @@
 module ROM
   module SQL
-    VERSION = '1.3.2'.freeze
+    VERSION = '1.3.3'.freeze
   end
 end

data/spec/extensions/postgres/attribute_spec.rb

@@ -1,9 +1,6 @@
 RSpec.describe 'ROM::SQL::Attribute', :postgres do
   include_context 'database setup'
 
-  jsonb_hash = -> v { Sequel::Postgres::JSONBHash.new(v) }
-  jsonb_array = -> v { Sequel::Postgres::JSONBArray.new(v) }
-
   before do
     conn.drop_table?(:pg_people)
     conn.drop_table?(:people)
@@ -16,113 +13,127 @@ RSpec.describe 'ROM::SQL::Attribute', :postgres do
   let(:people) { relations[:people] }
   let(:create_person) { commands[:people].create }
 
-  describe 'using arrays' do
-    before do
-      conn.create_table :pg_people do
-        primary_key :id
-        String :name
-        column :fields, :jsonb
+  %i(json jsonb).each do |type|
+    if type == :json
+      json_hash = Sequel::Postgres::JSONHash.method(:new)
+      json_array = Sequel::Postgres::JSONArray.method(:new)
+    else
+      json_hash = Sequel::Postgres::JSONBHash.method(:new)
+      json_array = Sequel::Postgres::JSONBArray.method(:new)
+    end
+
+    describe "using arrays in #{ type }" do
+      before do
+        conn.create_table :pg_people do
+          primary_key :id
+          String :name
+          column :fields, type
+        end
+
+        conf.commands(:people) do
+          define(:create)
+          define(:update)
+        end
+
+        create_person.(name: 'John Doe', fields: [{ name: 'age', value: '30' },
+                                                  { name: 'height', value: 180 }])
+        create_person.(name: 'Jade Doe', fields: [{ name: 'age', value: '25' }])
       end
 
-      conf.commands(:people) do
-        define(:create)
-        define(:update)
+      it 'fetches data from jsonb array by index' do
+        expect(people.select { [fields.get(1).as(:field)] }.where(name: 'John Doe').one).
+          to eql(field: json_hash['name' => 'height', 'value' => 180])
       end
 
-      create_person.(name: 'John Doe', fields: [{ name: 'age', value: '30' },
-                                                { name: 'height', value: 180 }])
-      create_person.(name: 'Jade Doe', fields: [{ name: 'age', value: '25' }])
-    end
-
-    it 'allows to query jsonb by inclusion' do
-      expect(people.select(:name).where { fields.contain([value: '30']) }.one).
-        to eql(name: 'John Doe')
-    end
-
-    it 'cat project result of contains' do
-      expect(people.select { fields.contain([value: '30']).as(:contains) }.to_a).
-        to eql([{ contains: true }, { contains: false }])
-    end
-
-    it 'fetches data from jsonb array by index' do
-      expect(people.select { [fields.get(1).as(:field)] }.where(name: 'John Doe').one).
-        to eql(field: jsonb_hash['name' => 'height', 'value' => 180])
-    end
-
-    it 'fetches data from jsonb array' do
-      expect(people.select { fields.get(1).get_text('value').as(:height) }.where(name: 'John Doe').one).
-        to eql(height: '180')
-    end
-
-    it 'fetches data with path' do
-      expect(people.select(people[:fields].get_text('1', 'value').as(:height)).to_a).
-        to eql([{ height: '180' }, { height: nil }])
-    end
-
-    it 'deletes key from result' do
-      expect(people.select { fields.delete(0).as(:result) }.limit(1).one).
-        to eq(result: jsonb_array[['name' => 'height', 'value' => 180]])
-    end
-
-    it 'deletes by path' do
-      expect(people.select { fields.delete('0', 'name').delete('1', 'name').as(:result) }.limit(1).one).
-        to eq(result: jsonb_array[[{ 'value' => '30' }, { 'value' => 180 }]])
-    end
-
-    it 'concatenates JSON values' do
-      expect(people.select { (fields + [name: 'height', value: 165]).as(:result) }.by_pk(2).one).
-        to eq(result: jsonb_array[[{ 'name' => 'age', 'value' => '25' },
-                                   { 'name' => 'height', 'value' => 165 }]])
-    end
-  end
-
-  describe 'using map' do
-    before do
-      conn.create_table :pg_people do
-        primary_key :id
-        String :name
-        column :data, :jsonb
+      it 'fetches data from jsonb array' do
+        expect(people.select { fields.get(1).get_text('value').as(:height) }.where(name: 'John Doe').one).
+          to eql(height: '180')
       end
 
-      conf.commands(:people) do
-        define(:create)
-        define(:update)
+      it 'fetches data with path' do
+        expect(people.select(people[:fields].get_text('1', 'value').as(:height)).to_a).
+          to eql([{ height: '180' }, { height: nil }])
       end
 
-      create_person.(name: 'John Doe', data: { age: 30, height: 180 })
-      create_person.(name: 'Jade Doe', data: { age: 25 })
-    end
-
-    it 'queries data by inclusion' do
-      expect(people.select(:name).where { data.contain(age: 30) }.one).
-        to eql(name: 'John Doe')
-    end
-
-    it 'queries data by left inclusion' do
-      expect(people.select(:name).where { data.contained_by(age: 25, foo: 'bar') }.one).
-        to eql(name: 'Jade Doe')
-    end
-
-    it 'checks for key presence' do
-      expect(people.select { data.has_key('height').as(:there) }.to_a).
-        to eql([{ there: true }, { there: false }])
-
-      expect(people.select(:name).where { data.has_any_key('height', 'width') }.one).
-        to eql(name: 'John Doe')
-
-      expect(people.select(:name).where { data.has_all_keys('height', 'age') }.one).
-        to eql(name: 'John Doe')
-    end
-
-    it 'concatenates JSON values' do
-      expect(people.select { data.merge(height: 165).as(:result) }.by_pk(2).one).
-        to eql(result: jsonb_hash['age' => 25, 'height' => 165])
+      if type == :jsonb
+        it 'allows to query jsonb by inclusion' do
+          expect(people.select(:name).where { fields.contain([value: '30']) }.one).
+            to eql(name: 'John Doe')
+        end
+
+        it 'cat project result of contains' do
+          expect(people.select { fields.contain([value: '30']).as(:contains) }.to_a).
+            to eql([{ contains: true }, { contains: false }])
+        end
+
+        it 'deletes key from result' do
+          expect(people.select { fields.delete(0).as(:result) }.limit(1).one).
+            to eq(result: json_array[['name' => 'height', 'value' => 180]])
+        end
+
+        it 'deletes by path' do
+          expect(people.select { fields.delete('0', 'name').delete('1', 'name').as(:result) }.limit(1).one).
+            to eq(result: json_array[[{ 'value' => '30' }, { 'value' => 180 }]])
+        end
+
+        it 'concatenates JSON values' do
+          expect(people.select { (fields + [name: 'height', value: 165]).as(:result) }.by_pk(2).one).
+            to eq(result: json_array[[{ 'name' => 'age', 'value' => '25' },
+                                      { 'name' => 'height', 'value' => 165 }]])
+        end
+      end
     end
 
-    it 'deletes key from result' do
-      expect(people.select { data.delete('height').as(:result) }.to_a).
-        to eql([{ result: jsonb_hash['age' => 30] },
-                { result: jsonb_hash['age' => 25] }])
+    if type == :jsonb
+      describe "using maps in #{ type }" do
+        before do
+          conn.create_table :pg_people do
+            primary_key :id
+            String :name
+            column :data, type
+          end
+
+          conf.commands(:people) do
+            define(:create)
+            define(:update)
+          end
+
+          create_person.(name: 'John Doe', data: { age: 30, height: 180 })
+          create_person.(name: 'Jade Doe', data: { age: 25 })
+        end
+
+        it 'queries data by inclusion' do
+          expect(people.select(:name).where { data.contain(age: 30) }.one).
+            to eql(name: 'John Doe')
+        end
+
+        it 'queries data by left inclusion' do
+          expect(people.select(:name).where { data.contained_by(age: 25, foo: 'bar') }.one).
+            to eql(name: 'Jade Doe')
+        end
+
+        it 'checks for key presence' do
+          expect(people.select { data.has_key('height').as(:there) }.to_a).
+            to eql([{ there: true }, { there: false }])
+
+          expect(people.select(:name).where { data.has_any_key('height', 'width') }.one).
+            to eql(name: 'John Doe')
+
+          expect(people.select(:name).where { data.has_all_keys('height', 'age') }.one).
+            to eql(name: 'John Doe')
+        end
+
+        it 'concatenates JSON values' do
+          expect(people.select { data.merge(height: 165).as(:result) }.by_pk(2).one).
+            to eql(result: json_hash['age' => 25, 'height' => 165])
+        end
+
+        it 'deletes key from result' do
+          expect(people.select { data.delete('height').as(:result) }.to_a).
+            to eql([{ result: json_hash['age' => 30] },
+                    { result: json_hash['age' => 25] }])
+        end
+      end
     end
   end
 

data/spec/spec_helper.rb

@@ -77,7 +77,7 @@ end
 
 def with_adapters(*args, &block)
   reset_adapter = Hash[*ADAPTERS.flat_map { |a| [a, false] }]
-  adapters = args.empty? || args[0] == :all ? ADAPTERS : args
+  adapters = args.empty? || args[0] == :all ? ADAPTERS : (args & ADAPTERS)
 
   adapters.each do |adapter|
     context("with #{adapter}", **reset_adapter, adapter => true, &block)

data/spec/unit/function_spec.rb

@@ -38,4 +38,11 @@ RSpec.describe ROM::SQL::Function, :postgres do
         to raise_error(NoMethodError, /upper/)
     end
   end
+
+  describe '#cast' do
+    it 'transforms data' do
+      expect(func.cast(:id, 'varchar').sql_literal(ds)).
+        to eql(%(CAST("id" AS varchar(255))))
+    end
+  end
 end

data/spec/unit/relation/exists_spec.rb

@@ -0,0 +1,18 @@
+RSpec.describe ROM::Relation, '#exists' do
+  include_context 'users and tasks'
+
+  let(:tasks) { container.relations.tasks }
+  let(:users) { container.relations.users }
+
+  with_adapters do
+    it 'returns true if subquery has at least one tuple' do
+      subquery = tasks.where(tasks[:user_id].qualified => users[:id].qualified)
+      expect(users.where { exists(subquery) }.count).to eql(2)
+    end
+
+    it 'returns false if subquery is empty' do
+      subquery = tasks.where(false)
+      expect(users.where { exists(subquery) }.count).to eql(0)
+    end
+  end
+end

data/spec/unit/relation/lock_spec.rb

@@ -0,0 +1,93 @@
+require 'concurrent/atomic/count_down_latch'
+
+RSpec.describe ROM::Relation, '#lock' do
+  include_context 'users and tasks'
+
+  subject(:relation) { users }
+
+  def lock_style(relation)
+    relation.dataset.opts.fetch(:lock)
+  end
+
+  context 'with hitting the database' do
+    let(:latch) { Concurrent::CountDownLatch.new }
+
+    let(:timeout) { (defined? JRUBY_VERSION) ? 2 : 0.2 }
+
+    let!(:start) { Time.now }
+
+    def elapsed_time
+      Time.now.to_f - start.to_f
+    end
+
+    with_adapters :postgres, :mysql, :oracle do
+      it 'locks rows for update' do
+        Thread.new do
+          relation.lock do |rel|
+            latch.count_down
+
+            sleep timeout
+          end
+        end
+
+        latch.wait
+
+        expect(elapsed_time).to be < timeout
+
+        relation.lock.to_a
+
+        expect(elapsed_time).to be > timeout
+      end
+    end
+  end
+
+  with_adapters :postgres, :mysql, :oracle do
+    it 'selects rows for update' do
+      expect(lock_style(relation.lock)).to eql('FOR UPDATE')
+    end
+
+    it 'locks without wait' do
+      expect(lock_style(relation.lock(wait: false))).to eql('FOR UPDATE NOWAIT')
+    end
+
+    it 'skips locked rows' do
+      expect(lock_style(relation.lock(skip_locked: true))).to eql('FOR UPDATE SKIP LOCKED')
+    end
+
+    it 'raises an exception on attempt to use NOWAIT/WAIT with SKIP LOCKED' do
+      expect { relation.lock(wait: false, skip_locked: true) }
+        .to raise_error(ArgumentError, /cannot be used/)
+    end
+  end
+
+  with_adapters :postgres do
+    it 'locks with UPDATE OF' do
+      expect(lock_style(relation.lock(of: :users))).to eql('FOR UPDATE OF users')
+      expect(lock_style(relation.lock(of: :users, skip_locked: true))).to eql('FOR UPDATE OF users SKIP LOCKED')
+    end
+
+    it 'locks rows in different modes' do
+      expect(lock_style(relation.lock(mode: :update))).to eql('FOR UPDATE')
+      expect(lock_style(relation.lock(mode: :no_key_update))).to eql('FOR NO KEY UPDATE')
+      expect(lock_style(relation.lock(mode: :share))).to eql('FOR SHARE')
+      expect(lock_style(relation.lock(mode: :key_share))).to eql('FOR KEY SHARE')
+    end
+  end
+
+  with_adapters :mysql do
+    it 'locks rows in the SHARE mode' do
+      expect(lock_style(relation.lock(mode: :share))).to eql('LOCK IN SHARE MODE')
+    end
+  end
+
+  with_adapters :oracle do
+    it 'locks with timeout' do
+      expect(lock_style(relation.lock(wait: 10))).to eql('FOR UPDATE WAIT 10')
+    end
+
+    it 'locks with UPDATE OF' do
+      expect(lock_style(relation.lock(of: :name))).to eql('FOR UPDATE OF name')
+      expect(lock_style(relation.lock(of: %i(id name)))).to eql('FOR UPDATE OF id, name')
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rom-sql
 version: !ruby/object:Gem::Version
-  version: 1.3.2
+  version: 1.3.3
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-13 00:00:00.000000000 Z
+date: 2017-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -299,6 +299,7 @@ files:
 - spec/unit/relation/distinct_spec.rb
 - spec/unit/relation/exclude_spec.rb
 - spec/unit/relation/exist_predicate_spec.rb
+- spec/unit/relation/exists_spec.rb
 - spec/unit/relation/fetch_spec.rb
 - spec/unit/relation/group_spec.rb
 - spec/unit/relation/having_spec.rb
@@ -307,6 +308,7 @@ files:
 - spec/unit/relation/instrument_spec.rb
 - spec/unit/relation/invert_spec.rb
 - spec/unit/relation/left_join_spec.rb
+- spec/unit/relation/lock_spec.rb
 - spec/unit/relation/map_spec.rb
 - spec/unit/relation/max_spec.rb
 - spec/unit/relation/min_spec.rb
@@ -435,6 +437,7 @@ test_files:
 - spec/unit/relation/distinct_spec.rb
 - spec/unit/relation/exclude_spec.rb
 - spec/unit/relation/exist_predicate_spec.rb
+- spec/unit/relation/exists_spec.rb
 - spec/unit/relation/fetch_spec.rb
 - spec/unit/relation/group_spec.rb
 - spec/unit/relation/having_spec.rb
@@ -443,6 +446,7 @@ test_files:
 - spec/unit/relation/instrument_spec.rb
 - spec/unit/relation/invert_spec.rb
 - spec/unit/relation/left_join_spec.rb
+- spec/unit/relation/lock_spec.rb
 - spec/unit/relation/map_spec.rb
 - spec/unit/relation/max_spec.rb
 - spec/unit/relation/min_spec.rb