rom-sql 1.3.1 → 1.3.2

data/spec/integration/plugins/auto_wrap_spec.rb

@@ -7,7 +7,7 @@ RSpec.describe 'Plugins / :auto_wrap' do
         it 'returns joined tuples' do
           task_with_user = tasks
             .for_wrap({ id: :user_id }, name)
-            .where(tasks__id: 2)
+            .where { id.qualified.is(2) }
             .one
 
           expect(task_with_user).to eql(

data/spec/integration/sequel_api_spec.rb

@@ -13,7 +13,8 @@ RSpec.describe 'Using legacy sequel api', :sqlite do
 
   describe '#select' do
     it 'selects columns' do
-      expect(users.select(:users__id, :users__name).first).to eql(id: 1, name: 'Jane')
+      expect(users.select(Sequel.qualify(:users, :id), Sequel.qualify(:users, :name)).first).
+        to eql(id: 1, name: 'Jane')
     end
 
     it 'supports legacy blocks' do
@@ -29,7 +30,7 @@ RSpec.describe 'Using legacy sequel api', :sqlite do
 
   describe '#order' do
     it 'orders relation' do
-      expect(users.order(:users__name).first).to eql(id: 1, name: 'Jane')
+      expect(users.order(Sequel.qualify(:users, :name)).first).to eql(id: 1, name: 'Jane')
     end
   end
 end

data/spec/unit/function_spec.rb

@@ -24,7 +24,7 @@ RSpec.describe ROM::SQL::Function, :postgres do
 
   describe '#is' do
     it 'returns an sql boolean expression' do
-      expect((func.count(:id).is(1)).sql_literal(ds)).to eql(%((COUNT("id") = 1)))
+      expect(ds.literal(func.count(:id).is(1))).to eql(%((COUNT("id") = 1)))
     end
   end
 

data/spec/unit/order_dsl_spec.rb

@@ -17,7 +17,7 @@ RSpec.describe ROM::SQL::OrderDSL, :postgres, helpers: true do
 
   describe '#call' do
     it 'returns an array with ordered expressions' do
-      expect(dsl.call { id }.first.sql_literal(conn[:users])).to eql('"id"')
+      expect(ds.literal(dsl.call { id }.first)).to eql('"id"')
     end
   end
 
@@ -28,15 +28,15 @@ RSpec.describe ROM::SQL::OrderDSL, :postgres, helpers: true do
     end
 
     it 'delegates to sequel virtual row' do
-      expect(dsl.call { nullif(id.qualified, `''`).desc }.first.sql_literal(conn[:users])).
+      expect(ds.literal(dsl.call { nullif(id.qualified, Sequel.lit("''")).desc }.first)).
         to eql(%(NULLIF("users"."id", '') DESC))
     end
 
     it 'allows to set nulls first/last' do
-      expect(dsl.call { id.desc(nulls: :first) }.first.sql_literal(conn[:users])).
+      expect(ds.literal(dsl.call { id.desc(nulls: :first) }.first)).
         to eql(%("id" DESC NULLS FIRST))
 
-      expect(dsl.call { id.desc(nulls: :last) }.first.sql_literal(conn[:users])).
+      expect(ds.literal(dsl.call { id.desc(nulls: :last) }.first)).
         to eql(%("id" DESC NULLS LAST))
     end
   end

data/spec/unit/projection_dsl_spec.rb

@@ -71,6 +71,14 @@ RSpec.describe ROM::SQL::ProjectionDSL, :postgres, helpers: true do
 
       expect(literals).to eql([%('event' AS "type")])
     end
+
+    it 'supports functions without return value' do
+      literals = dsl
+                   .call { void::pg_advisory_lock(1).as(:lock) }
+                   .map { |attr| attr.sql_literal(ds) }
+
+      expect(literals).to eql([%(PG_ADVISORY_LOCK(1) AS "lock")])
+    end
   end
 
   describe '#method_missing' do

data/spec/unit/relation/dataset_spec.rb

@@ -17,7 +17,7 @@ RSpec.describe ROM::Relation, '#dataset' do
       end
 
       it 'uses schema to infer default dataset' do
-        expect(relation.dataset.sql).to eql(dataset.select(:id, :name).order(:users__id).sql)
+        expect(relation.dataset.sql).to eql(dataset.select(:id, :name).order(Sequel.qualify(:users, :id)).sql)
       end
     end
 
@@ -31,7 +31,7 @@ RSpec.describe ROM::Relation, '#dataset' do
       end
 
       it 'uses schema to infer default dataset' do
-        expect(relation.dataset.sql).to eql(dataset.select(:id).order(:users__id).sql)
+        expect(relation.dataset.sql).to eql(dataset.select(:id).order(Sequel.qualify(:users, :id)).sql)
       end
     end
 
@@ -41,7 +41,7 @@ RSpec.describe ROM::Relation, '#dataset' do
       end
 
       it 'selects all qualified columns and sorts by pk' do
-        expect(relation.dataset.sql).to eql(dataset.select(*relation.columns).order(:users__id).sql)
+        expect(relation.dataset.sql).to eql(dataset.select(*relation.columns).order(Sequel.qualify(:users, :id)).sql)
       end
     end
   end

data/spec/unit/relation/project_spec.rb

@@ -17,7 +17,7 @@ RSpec.describe ROM::Relation, '#project' do
     it 'projects the dataset using new column names' do
       projected = relation.sorted.project(:name)
 
-      expect(projected.schema.map(&:to_sym)).to match_array([:name])
+      expect(projected.schema.map(&:to_sql_name)).to match_array(Sequel[:name])
       expect(projected.first).to eql(name: 'Jane')
     end
   end

data/spec/unit/relation/qualified_columns_spec.rb

@@ -17,13 +17,14 @@ RSpec.describe ROM::Relation, '#qualified_columns' do
     it 'returns qualified column names' do
       columns = relation.sorted.prefix(:user).qualified_columns
 
-      expect(columns).to eql([:users__id___user_id, :users__name___user_name])
+      expect(columns).to eql([Sequel.qualify(:users, :id).as(:user_id),
+                              Sequel.qualify(:users, :name).as(:user_name)])
     end
 
     it 'returns projected qualified column names' do
       columns = relation.sorted.project(:id).prefix(:user).qualified_columns
 
-      expect(columns).to eql([:users__id___user_id])
+      expect(columns).to eql([Sequel.qualify(:users, :id).as(:user_id)])
     end
   end
 end

data/spec/unit/relation/where_spec.rb

@@ -49,6 +49,26 @@ RSpec.describe ROM::Relation, '#where' do
         expect(relation.where(relation[:id].in(2, 3)).to_a).
           to eql([{ id: 2, title: "Jane's task" }])
       end
+
+      context 'using underscored symbols for qualifying' do
+        before { Sequel.split_symbols = true }
+        after { Sequel.split_symbols = false }
+
+        it 'queries with a qualified name' do
+          expect(relation.where(tasks__id: 1).to_a).
+            to eql([{ id: 1, title: "Joe's task" }])
+        end
+      end
+
+      it 'restricts with a function' do
+        expect(relation.where { string::lower(title).is("joe's task") }.to_a).
+          to eql([{ id: 1, title: "Joe's task" }])
+      end
+
+      it 'restricts with a function using LIKE' do
+        expect(relation.where { string::lower(title).like("joe%") }.to_a).
+          to eql([{ id: 1, title: "Joe's task" }])
+      end
     end
 
     context 'with :read types' do

data/spec/unit/restriction_dsl_spec.rb

@@ -17,7 +17,7 @@ RSpec.describe ROM::SQL::RestrictionDSL, :sqlite, helpers: true do
 
   describe '#call' do
     it 'evaluates the block and returns an SQL expression' do
-      expect(dsl.call { count(id) >= 3 }.sql_literal(conn[:users])).to eql('(count(`id`) >= 3)')
+      expect(conn[:users].literal(dsl.call { count(id) >= 3 })).to eql('(count(`id`) >= 3)')
     end
   end
 
@@ -28,7 +28,7 @@ RSpec.describe ROM::SQL::RestrictionDSL, :sqlite, helpers: true do
     end
 
     it 'delegates to sequel virtual row' do
-      expect(dsl.count(dsl.id).sql_literal(conn[:users])).to eql('count(`id`)')
+      expect(conn[:users].literal(dsl.count(dsl.id))).to eql('count(`id`)')
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rom-sql
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.3.2
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-05 00:00:00.000000000 Z
+date: 2017-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel