rom-sql 1.3.1 → 1.3.2

data/lib/rom/sql/function.rb

@@ -6,9 +6,9 @@ module ROM
     class Function < ROM::Schema::Attribute
       def sql_literal(ds)
         if name
-          func.as(name).sql_literal(ds)
+          ds.literal(func.as(name))
         else
-          func.sql_literal(ds)
+          ds.literal(func)
         end
       end
 

data/lib/rom/sql/projection_dsl.rb

@@ -7,7 +7,7 @@ module ROM
     class ProjectionDSL < DSL
       # @api public
       def `(value)
-        expr = ::Sequel::VIRTUAL_ROW.instance_eval { `#{value}` }
+        expr = ::Sequel.lit(value)
         ::ROM::SQL::Attribute.new(type(:string)).meta(sql_expr: expr)
       end
 
@@ -18,17 +18,6 @@ module ROM
 
       private
 
-      # @api private
-      def type(identifier)
-        type_name = ::Dry::Core::Inflector.classify(identifier)
-        types.const_get(type_name) if types.const_defined?(type_name)
-      end
-
-      # @api private
-      def types
-        ::ROM::SQL::Types
-      end
-
       # @api private
       def method_missing(meth, *args, &block)
         if schema.key?(meth)

data/lib/rom/sql/relation.rb

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

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

@@ -105,7 +105,7 @@ module ROM
         #
         # @api public
         def qualified_columns
-          schema.qualified.map(&:to_sym)
+          schema.qualified.map(&:to_sql_name)
         end
 
         # Map tuples from the relation
@@ -341,8 +341,10 @@ module ROM
             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
+          elsif !args.empty?
             new(dataset.where(*args))
+          else
+            self
           end
         end
 
@@ -395,9 +397,9 @@ module ROM
         # @api public
         def having(*args, &block)
           if block
-            new(dataset.having(*args).having(self.class.schema.restriction(&block)))
+            new(dataset.having(*args, *self.class.schema.restriction(&block)))
           else
-            new(dataset.__send__(__method__, *args, &block))
+            new(dataset.__send__(__method__, *args))
           end
         end
 
@@ -835,6 +837,8 @@ module ROM
             else
               new(dataset.__send__(type, other.to_sym, join_cond, opts, &block))
             end
+          elsif other.is_a?(Sequel::SQL::AliasedExpression)
+            new(dataset.__send__(type, other, join_cond, opts, &block))
           elsif other.respond_to?(:name) && other.name.is_a?(Relation::Name)
             associations[other.name.dataset].join(__registry__, type, self, other)
           else

data/lib/rom/sql/restriction_dsl.rb

@@ -16,7 +16,13 @@ module ROM
         if schema.key?(meth)
           schema[meth]
         else
-          ::Sequel::VIRTUAL_ROW.__send__(meth, *args, &block)
+          type = type(meth)
+
+          if type
+            ::ROM::SQL::Function.new(type)
+          else
+            ::Sequel::VIRTUAL_ROW.__send__(meth, *args, &block)
+          end
         end
       end
     end

data/lib/rom/sql/types.rb

@@ -16,6 +16,8 @@ module ROM
       Serial = Int.meta(primary_key: true)
 
       Blob = Constructor(Sequel::SQL::Blob, &Sequel::SQL::Blob.method(:new))
+
+      Void = Nil
     end
   end
 end

data/lib/rom/sql/version.rb

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

data/spec/extensions/postgres/attribute_spec.rb

@@ -125,4 +125,82 @@ RSpec.describe 'ROM::SQL::Attribute', :postgres do
                 { result: jsonb_hash['age' => 25] }])
     end
   end
+
+  describe 'using array types' do
+    before do
+      conn.create_table :pg_people do
+        primary_key :id
+        String :name
+        column :emails, 'text[]'
+        column :bigids, 'bigint[]'
+      end
+
+      conf.commands(:people) do
+        define(:create)
+        define(:update)
+      end
+
+      create_person.(name: 'John Doe', emails: %w(john@doe.com john@example.com), bigids: [84])
+      create_person.(name: 'Jade Doe', emails: %w(jade@hotmail.com), bigids: [42])
+    end
+
+    it 'filters by email inclusion' do
+      expect(people.select(:name).where { emails.contain(['john@doe.com']) }.one).
+        to eql(name: 'John Doe')
+    end
+
+    it 'coerces values so that PG does not complain' do
+      expect(people.select(:name).where { bigids.contain([84]) }.one).
+        to eql(name: 'John Doe')
+    end
+
+    it 'fetches element by index' do
+      expect(people.select { [name, emails.get(2).as(:second_email)] }.to_a).
+        to eql([{ name: 'John Doe', second_email: 'john@example.com' },
+                { name: 'Jade Doe', second_email: nil }])
+    end
+
+    it 'restricts with ANY' do
+      expect(people.select(:name).where { bigids.any(84)}.one).
+        to eql(name: 'John Doe')
+    end
+
+    it 'restricts by <@' do
+      expect(people.select(:name).where { bigids.contained_by((30..50).to_a) }.one).
+        to eql(name: 'Jade Doe')
+    end
+
+    it 'returns array length' do
+      expect(people.select { [name, emails.length.as(:size)] }.to_a).
+        to eql([{ name: 'John Doe', size: 2 }, { name: 'Jade Doe', size: 1 }])
+    end
+
+    it 'restrict by overlapping with other array' do
+      expect(people.select(:name).where { emails.overlaps(%w(jade@hotmail.com)) }.one).
+        to eql(name: 'Jade Doe')
+
+      expect(people.select(:name).where { bigids.overlaps([42]) }.one).
+        to eql(name: 'Jade Doe')
+    end
+
+    it 'removes element by value' do
+      expect(people.select { emails.remove_value('john@example.com').as(:emails) }.to_a).
+        to eq([{ emails: %w(john@doe.com) }, { emails: %w(jade@hotmail.com) }])
+
+      pending "doesn't have auto-casting yet"
+      expect(people.select(:name).where { bigids.remove_value(100).contains([42]) }.one).
+        to eql(name: 'Jade Doe')
+    end
+
+    it 'joins values' do
+      expect(people.select { emails.join(',').as(:emails) }.to_a).
+        to eql([{ emails: 'john@doe.com,john@example.com' },
+                { emails: 'jade@hotmail.com' }])
+    end
+
+    it 'concatenates arrays' do
+      expect(people.select { (emails + %w(foo@bar.com)).as(:emails) }.where { name.is('Jade Doe') }.one).
+        to eq(emails: %w(jade@hotmail.com foo@bar.com))
+    end
+  end
 end

data/spec/integration/association/many_to_many/custom_fks_spec.rb

@@ -9,6 +9,9 @@ RSpec.describe ROM::SQL::Association::ManyToMany, '#call' do
     relations[:users].associations[:puzzles]
   end
 
+  let(:puzzles) { relations[:puzzles] }
+  let(:puzzle_solvers) { relations[:puzzle_solvers] }
+
   with_adapters do
     before do
       conn.create_table(:puzzles) do
@@ -52,10 +55,12 @@ RSpec.describe ROM::SQL::Association::ManyToMany, '#call' do
     end
 
     it 'prepares joined relations using custom FK' do
-      relation = assoc.call(relations).order(:puzzles__text, :puzzle_solvers__solver_id)
+      relation = assoc.call(relations).order(puzzles[:text].qualified, puzzle_solvers[:solver_id].qualified)
 
-      expect(relation.schema.map(&:to_sym)).
-        to eql(%i[puzzles__id puzzles__text puzzle_solvers__solver_id])
+      expect(relation.schema.map(&:to_sql_name)).
+        to eql([Sequel.qualify(:puzzles, :id),
+                Sequel.qualify(:puzzles, :text),
+                Sequel.qualify(:puzzle_solvers, :solver_id)])
 
       expect(relation.to_a).
         to eql([

data/spec/integration/association/many_to_many/from_view_spec.rb

@@ -9,6 +9,9 @@ RSpec.describe ROM::SQL::Association::ManyToMany, '#call' do
     relations[:users].associations[:solved_puzzles]
   end
 
+  let(:puzzles) { relations[:puzzles] }
+  let(:puzzle_solvers) { relations[:puzzle_solvers] }
+
   with_adapters do
     before do
       conn.create_table(:puzzles) do
@@ -67,10 +70,13 @@ RSpec.describe ROM::SQL::Association::ManyToMany, '#call' do
     end
 
     it 'prepares joined relations using custom FK' do
-      relation = assoc.call(relations).order(:puzzles__text, :puzzle_solvers__user_id)
+      relation = assoc.call(relations).order(puzzles[:text].qualified, puzzle_solvers[:user_id].qualified)
 
-      expect(relation.schema.map(&:to_sym)).
-        to eql(%i[puzzles__id puzzles__text puzzles__solved puzzle_solvers__user_id])
+      expect(relation.schema.map(&:to_sql_name)).
+        to eql([Sequel.qualify(:puzzles, :id),
+                Sequel.qualify(:puzzles, :text),
+                Sequel.qualify(:puzzles, :solved),
+                Sequel.qualify(:puzzle_solvers, :user_id)])
 
       expect(relation.to_a).
         to eql([

data/spec/integration/association/many_to_many_spec.rb

@@ -46,7 +46,10 @@ RSpec.describe ROM::SQL::Association::ManyToMany do
         it 'prepares joined relations' do
           relation = assoc.call(container.relations)
 
-          expect(relation.schema.map(&:to_sym)).to eql(%i[tags__id tags__name task_tags__task_id])
+          expect(relation.schema.map(&:to_sql_name)).
+            to eql([Sequel.qualify(:tags, :id),
+                    Sequel.qualify(:tags, :name),
+                    Sequel.qualify(:task_tags, :task_id)])
           expect(relation.to_a).to eql([id: 1, name: 'important', task_id: 1])
         end
       end
@@ -59,7 +62,10 @@ RSpec.describe ROM::SQL::Association::ManyToMany do
         it 'prepares joined relations through other association' do
           relation = assoc.call(container.relations)
 
-          expect(relation.schema.map(&:to_sym)).to eql(%i[tags__id tags__name tasks__user_id])
+          expect(relation.schema.map(&:to_sql_name)).
+            to eql([Sequel.qualify(:tags, :id),
+                    Sequel.qualify(:tags, :name),
+                    Sequel.qualify(:tasks, :user_id)])
           expect(relation.to_a).to eql([id: 1, name: 'important', user_id: 2])
         end
       end

data/spec/integration/association/many_to_one/custom_fks_spec.rb

@@ -42,15 +42,19 @@ RSpec.describe ROM::SQL::Association::ManyToOne, '#call' do
     it 'prepares joined relations using correct FKs based on association aliases' do
       relation = assoc_from.call(relations)
 
-      expect(relation.schema.map(&:to_sym)).
-        to eql(%i(destinations__id destinations__name flights__id___flight_id))
+      expect(relation.schema.map(&:to_sql_name)).
+        to eql([Sequel.qualify(:destinations, :id),
+                Sequel.qualify(:destinations, :name),
+                Sequel.qualify(:flights, :id).as(:flight_id)])
 
       expect(relation.first).to eql(id: 1, name: 'FROM', flight_id: 1)
 
       relation = assoc_to.call(relations)
 
-      expect(relation.schema.map(&:to_sym)).
-        to eql(%i(destinations__id destinations__name flights__id___flight_id))
+      expect(relation.schema.map(&:to_sql_name)).
+        to eql([Sequel.qualify(:destinations, :id),
+                Sequel.qualify(:destinations, :name),
+                Sequel.qualify(:flights, :id).as(:flight_id)])
 
       expect(relation.first).to eql(id: 2, name: 'TO', flight_id: 1)
     end

data/spec/integration/association/many_to_one/from_view_spec.rb

@@ -60,16 +60,22 @@ RSpec.describe ROM::SQL::Association::ManyToOne, '#call' do
     it 'prepares joined relations using custom view in target relation' do
       relation = assoc_inter.call(relations)
 
-      expect(relation.schema.map(&:to_sym)).
-        to eql(%i(destinations__id destinations__name destinations__intermediate flights__id___flight_id))
+      expect(relation.schema.map(&:to_sql_name)).
+        to eql([Sequel.qualify(:destinations, :id),
+                Sequel.qualify(:destinations, :name),
+                Sequel.qualify(:destinations, :intermediate),
+                Sequel.qualify(:flights, :id).as(:flight_id)])
 
       expect(relation.first).to eql(id: 2, intermediate: db_true, name: 'Intermediate', flight_id: 1)
       expect(relation.count).to be(1)
 
       relation = assoc_final.call(relations)
 
-      expect(relation.schema.map(&:to_sym)).
-        to eql(%i(destinations__id destinations__name destinations__intermediate flights__id___flight_id))
+      expect(relation.schema.map(&:to_sql_name)).
+        to eql([Sequel.qualify(:destinations, :id),
+                Sequel.qualify(:destinations, :name),
+                Sequel.qualify(:destinations, :intermediate),
+                Sequel.qualify(:flights, :id).as(:flight_id)])
 
       expect(relation.first).to eql(id: 1, intermediate: db_false, name: 'Final', flight_id: 2)
       expect(relation.count).to be(1)

data/spec/integration/association/many_to_one/self_ref_spec.rb

@@ -37,8 +37,10 @@ RSpec.describe ROM::SQL::Association::OneToMany, '#call' do
     it 'prepares joined relations using custom FK for a self-ref association' do
       relation = assoc.call(relations)
 
-      expect(relation.schema.map(&:to_sym)).
-        to eql(%i[categories__id categories__parent_id categories__name])
+      expect(relation.schema.map(&:to_sql_name)).
+        to eql([Sequel.qualify(:categories, :id),
+                Sequel.qualify(:categories, :parent_id),
+                Sequel.qualify(:categories, :name)])
 
       expect(relation.to_a).
         to eql([

data/spec/integration/association/many_to_one_spec.rb

@@ -41,8 +41,10 @@ RSpec.describe ROM::SQL::Association::ManyToOne, helpers: true do
         it 'prepares joined relations' do
           relation = assoc.call(container.relations)
 
-          expect(relation.schema.map(&:to_sym))
-            .to eql(%i[users__id users__name tasks__id___task_id])
+          expect(relation.schema.map(&:to_sql_name)).
+            to eql([Sequel.qualify(:users, :id),
+                    Sequel.qualify(:users, :name),
+                    Sequel.qualify(:tasks, :id).as(:task_id)])
 
           expect(relation.where(user_id: 1).one).to eql(id: 1, task_id: 2, name: 'Jane')
 
@@ -109,8 +111,10 @@ RSpec.describe ROM::SQL::Association::ManyToOne, helpers: true do
         it 'prepares joined relations' do
           relation = assoc.call(container.relations)
 
-          expect(relation.schema.map(&:to_sym))
-            .to eql(%i[users__id users__name posts__post_id])
+          expect(relation.schema.map(&:to_sql_name)).
+            to eql([Sequel.qualify(:users, :id),
+                    Sequel.qualify(:users, :name),
+                    Sequel.qualify(:posts, :post_id)])
 
           expect(relation.order(:id).to_a).to eql([
             { id: 1, name: 'Jane', post_id: 2 },

data/spec/integration/association/one_to_many/custom_fks_spec.rb

@@ -40,8 +40,11 @@ RSpec.describe ROM::SQL::Association::OneToMany, '#call' do
     it 'prepares joined relations using custom FK' do
       relation = assoc.call(relations)
 
-      expect(relation.schema.map(&:to_sym)).
-        to eql(%i[puzzles__id puzzles__author_id puzzles__solver_id puzzles__text])
+      expect(relation.schema.map(&:to_sql_name)).
+        to eql([Sequel.qualify(:puzzles, :id),
+                Sequel.qualify(:puzzles, :author_id),
+                Sequel.qualify(:puzzles, :solver_id),
+                Sequel.qualify(:puzzles, :text)])
 
       expect(relation.first).to eql(id: 2, author_id: 2, solver_id: 1, text: 'P2')
     end

data/spec/integration/association/one_to_many/from_view_spec.rb

@@ -44,8 +44,11 @@ RSpec.describe ROM::SQL::Association::OneToMany, '#call' do
     it 'prepares joined relations using custom view' do
       relation = assoc.call(relations)
 
-      expect(relation.schema.map(&:to_sym)).
-        to eql(%i[puzzles__id puzzles__user_id puzzles__text puzzles__solved])
+      expect(relation.schema.map(&:to_sql_name)).
+        to eql([Sequel.qualify(:puzzles, :id),
+                Sequel.qualify(:puzzles, :user_id),
+                Sequel.qualify(:puzzles, :text),
+                Sequel.qualify(:puzzles, :solved)])
 
       expect(relation.count).to be(1)
       expect(relation.first).to eql(id: 2, user_id: 2, solved: db_true, text: 'P2')

data/spec/integration/association/one_to_many/self_ref_spec.rb

@@ -38,8 +38,10 @@ RSpec.describe ROM::SQL::Association::OneToMany, '#call' do
     it 'prepares joined relations using custom FK for a self-ref association' do
       relation = assoc.call(relations)
 
-      expect(relation.schema.map(&:to_sym)).
-        to eql(%i[categories__id categories__parent_id categories__name])
+      expect(relation.schema.map(&:to_sql_name)).
+        to eql([Sequel.qualify(:categories, :id),
+                Sequel.qualify(:categories, :parent_id),
+                Sequel.qualify(:categories, :name)])
 
       expect(relation.to_a).
         to eql([

data/spec/integration/association/one_to_many_spec.rb

@@ -26,7 +26,7 @@ RSpec.describe ROM::SQL::Association::OneToMany do
 
         expect(relation.schema.map(&:name)).to eql(%i[id user_id title])
 
-        expect(relation.order(:tasks__id).to_a).to eql([
+        expect(relation.order(tasks[:id].qualified).to_a).to eql([
           { id: 1, user_id: 2, title: "Joe's task" },
           { id: 2, user_id: 1, title: "Jane's task" }
         ])

data/spec/integration/commands/upsert_spec.rb

@@ -56,7 +56,7 @@ RSpec.describe 'Commands / Postgres / Upsert', :postgres, seeds: false do
         let(:command_config) do
           -> do
             constraint :tasks_title_key
-            update_statement user_id: :excluded__user_id
+            update_statement user_id: Sequel.qualify(:excluded, :user_id)
           end
         end
 
@@ -70,7 +70,7 @@ RSpec.describe 'Commands / Postgres / Upsert', :postgres, seeds: false do
           -> do
             conflict_target :title
             update_statement user_id: nil
-            update_where tasks__id: 2
+            update_where Sequel.qualify(:tasks, :id) => 2
           end
         end