rom-sql 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dd4d5efa9ebc24506ae85cf772c6d57f6d59530b
-  data.tar.gz: 1fe47e3b07ee7979e92d47257b1ecdf4a258246b
+  metadata.gz: e3faf5e4b8e2aa655c4a646421cf148cad3e137e
+  data.tar.gz: 2b1ac9258b8f15111297a71acf92f46f0f19607c
 SHA512:
-  metadata.gz: 7338e9310e9ea94d333489edde055d213e2b466640c1366702cd08f78d636ee0577b5ec2f16e9e4c47b67847ff50f5fe23476d0440ba4e3fec9ad7c1e265c663
-  data.tar.gz: 6c26fb847b68e9f5add7b8255fbf8d4b99ecd387dbcc5897343658c21cf75358b0dc3db369351c70fd592b2f90ce10b428512df0ffeabd747a80685a5b2da97f
+  metadata.gz: d11f6ab0d5a70192f29b1028d5d3acd81ce8b06f3d0edb6a74c24f8c869006837630476fcda3260aa021adbd3f0b5aa321e70df50feeb6d480b701524ff34329
+  data.tar.gz: b3f894dc4a8eddc3cca586186beaa530a0bf6317593622fca1ab86a568083dbeb88564bcba1c4110ee8230fb04c39792df0a760993908feaa999bed601e708a3

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## v1.0.2 2017-02-16
+
+### Added
+
+* Support for selecting literal strings via `select { `'foo'`.as(:bar) }` (solnic)
+
+[Compare v1.0.1...v1.0.2](https://github.com/rom-rb/rom-sql/compare/v1.0.1...v1.0.2)
+
 ## v1.0.1 2017-02-09
 
 ### Added
@@ -11,6 +19,8 @@
 
 * Missing primary key now leads to a more meaningful error (flash-gordon)
 
+[Compare v1.0.0...v1.0.1](https://github.com/rom-rb/rom-sql/compare/v1.0.0...v1.0.1)
+
 ## v1.0.0 2017-01-29
 
 This release is based on rom core 3.0.0 with its improved Schema API, which is extended with SQL-specific features.

data/Gemfile

@@ -25,6 +25,7 @@ group :test do
   gem 'jdbc-mysql', platforms: :jruby
   gem 'sqlite3', platforms: [:mri, :rbx]
   gem 'jdbc-sqlite3', platforms: :jruby
+  gem 'ruby-oci8', platforms: :mri if ENV['ROM_USE_ORACLE']
 end
 
 group :tools do

data/lib/rom/sql/attribute.rb

@@ -21,7 +21,7 @@ module ROM
       #
       # @api public
       def aliased(name)
-        super.meta(sql_expr: sql_expr.as(name))
+        super.meta(name: meta.fetch(:name, name), sql_expr: sql_expr.as(name))
       end
       alias_method :as, :aliased
 

data/lib/rom/sql/projection_dsl.rb

@@ -5,6 +5,12 @@ module ROM
   module SQL
     # @api private
     class ProjectionDSL < DSL
+      # @api public
+      def `(value)
+        expr = ::Sequel::VIRTUAL_ROW.instance_eval { `#{value}` }
+        ::ROM::SQL::Attribute.new(type(:string)).meta(sql_expr: expr)
+      end
+
       # @api private
       def respond_to_missing?(name, include_private = false)
         super || type(name)

data/lib/rom/sql/version.rb

@@ -1,5 +1,5 @@
 module ROM
   module SQL
-    VERSION = '1.0.1'.freeze
+    VERSION = '1.0.2'.freeze
   end
 end

data/rom-sql.gemspec

@@ -1,4 +1,3 @@
-# coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'rom/sql/version'
@@ -26,4 +25,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.5'
 end

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

@@ -1,10 +1,14 @@
 RSpec.describe ROM::SQL::Association::ManyToMany, '#call' do
+  include_context 'users'
+
+  before do
+    inferrable_relations.concat %i(puzzles puzzle_solvers)
+  end
+
   subject(:assoc) do
     relations[:users].associations[:puzzles]
   end
 
-  include_context 'database setup'
-
   with_adapters do
     before do
       conn.create_table(:puzzles) do
@@ -36,9 +40,6 @@ RSpec.describe ROM::SQL::Association::ManyToMany, '#call' do
         end
       end
 
-      joe_id = relations[:users].insert(name: 'Joe')
-      jane_id = relations[:users].insert(name: 'Jane')
-
       p1_id = relations[:puzzles].insert(text: 'P1')
       p2_id = relations[:puzzles].insert(text: 'P2')
       p3_id = relations[:puzzles].insert(text: 'P3')
@@ -50,23 +51,18 @@ RSpec.describe ROM::SQL::Association::ManyToMany, '#call' do
       relations[:puzzle_solvers].insert(solver_id: jane_id, puzzle_id: p3_id)
     end
 
-    after do
-      conn.drop_table?(:puzzle_solvers)
-      conn.drop_table?(:puzzles)
-    end
-
     it 'prepares joined relations using custom FK' do
-      relation = assoc.call(relations).order(:puzzles__text)
+      relation = assoc.call(relations).order(:puzzles__text, :puzzle_solvers__solver_id)
 
       expect(relation.schema.map(&:to_sym)).
         to eql(%i[puzzles__id puzzles__text puzzle_solvers__solver_id])
 
       expect(relation.to_a).
         to eql([
-                 { id: 1, solver_id: 1, text: 'P1' },
+                 { id: 1, solver_id: 2, text: 'P1' },
                  { id: 2, solver_id: 1, text: 'P2' },
                  { id: 2, solver_id: 2, text: 'P2' },
-                 { id: 3, solver_id: 2, text: 'P3' }
+                 { id: 3, solver_id: 1, text: 'P3' }
                ])
     end
   end

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

@@ -1,10 +1,14 @@
 RSpec.describe ROM::SQL::Association::ManyToMany, '#call' do
+  include_context 'users'
+
+  before do
+    inferrable_relations.concat %i(puzzles puzzle_solvers)
+  end
+
   subject(:assoc) do
     relations[:users].associations[:solved_puzzles]
   end
 
-  include_context 'database setup'
-
   with_adapters do
     before do
       conn.create_table(:puzzles) do
@@ -46,9 +50,6 @@ RSpec.describe ROM::SQL::Association::ManyToMany, '#call' do
         end
       end
 
-      joe_id = relations[:users].insert(name: 'Joe')
-      jane_id = relations[:users].insert(name: 'Jane')
-
       p1_id = relations[:puzzles].insert(text: 'P1')
       p2_id = relations[:puzzles].insert(text: 'P2', solved: true)
       p3_id = relations[:puzzles].insert(text: 'P3')
@@ -66,15 +67,15 @@ RSpec.describe ROM::SQL::Association::ManyToMany, '#call' do
     end
 
     it 'prepares joined relations using custom FK' do
-      relation = assoc.call(relations).order(:puzzles__text)
+      relation = assoc.call(relations).order(:puzzles__text, :puzzle_solvers__user_id)
 
       expect(relation.schema.map(&:to_sym)).
         to eql(%i[puzzles__id puzzles__text puzzles__solved puzzle_solvers__user_id])
 
       expect(relation.to_a).
         to eql([
-                 { id: 2, user_id: 1, solved: true, text: 'P2' },
-                 { id: 2, user_id: 2, solved: true, text: 'P2' }
+                 { id: 2, user_id: 1, solved: db_true, text: 'P2' },
+                 { id: 2, user_id: 2, solved: db_true, text: 'P2' }
                ])
     end
   end

data/spec/integration/association/many_to_many_spec.rb

@@ -1,145 +1,146 @@
 RSpec.describe ROM::SQL::Association::ManyToMany do
   include_context 'users and tasks'
 
-  # FIXME: Figure out what is wrong with sqlite
-  with_adapters(:postgres, :mysql) do
-    context 'with two associations pointing to the same target relation' do
-      let(:container) do
-        ROM.container(:sql, uri) do |conf|
-          conf.default.create_table(:users_tasks) do
-            foreign_key :user_id, :users
-            foreign_key :task_id, :tasks
-            primary_key [:user_id, :task_id]
-          end
+  with_adapters do
+    context 'through a relation with a composite PK' do
+      subject(:assoc) {
+        ROM::SQL::Association::ManyToMany.new(:tasks, :tags, through: :task_tags)
+      }
 
-          conf.relation(:users) do
-            schema(infer: true) do
-              associations do
-                has_many :users_tasks
-                has_many :tasks, through: :users_tasks
-                has_many :tasks, as: :priv_tasks
-              end
-            end
-          end
+      let(:tasks) { container.relations[:tasks] }
+      let(:tags) { container.relations[:tags] }
+
+      before do
+        conf.relation(:task_tags) do
+          schema do
+            attribute :task_id, ROM::SQL::Types::ForeignKey(:tasks)
+            attribute :tag_id, ROM::SQL::Types::ForeignKey(:tags)
 
-          conf.relation(:users_tasks) do
-            schema(infer: true) do
-              associations do
-                belongs_to :user
-                belongs_to :task
-              end
+            primary_key :task_id, :tag_id
+
+            associations do
+              many_to_one :tasks
+              many_to_one :tags
             end
           end
+        end
 
-          conf.relation(:tasks) do
-            schema(infer: true) do
-              associations do
-                has_many :users_tasks
-                has_many :users, through: :users_tasks
-              end
+        conf.relation(:tasks) do
+          schema do
+            attribute :id, ROM::SQL::Types::Serial
+            attribute :user_id, ROM::SQL::Types::ForeignKey(:users)
+            attribute :title, ROM::SQL::Types::String
+
+            associations do
+              one_to_many :task_tags
+              one_to_many :tags, through: :task_tags
             end
           end
         end
       end
 
-      it 'does not conflict with two FKs' do
-        users = container.relations[:users]
-        tasks = container.relations[:tasks]
-        assoc = users.associations[:tasks]
+      describe '#result' do
+        specify { expect(ROM::SQL::Association::ManyToMany.result).to be(:many) }
+      end
 
-        relation = tasks.for_combine(assoc).call(users.call)
+      describe '#call' do
+        it 'prepares joined relations' do
+          relation = assoc.call(container.relations)
 
-        expect(relation.to_a).to be_empty
+          expect(relation.schema.map(&:to_sym)).to eql(%i[tags__id tags__name task_tags__task_id])
+          expect(relation.to_a).to eql([id: 1, name: 'important', task_id: 1])
+        end
       end
 
-      it 'preloads using FK' do
-        users = container.relations[:users]
-        tasks = container.relations[:tasks]
-        assoc = users.associations[:priv_tasks]
+      describe ':through another assoc' do
+        subject(:assoc) do
+          ROM::SQL::Association::ManyToMany.new(:users, :tags, through: :tasks)
+        end
 
-        relation = tasks.for_combine(assoc).call(users.where(id: 2).call)
+        it 'prepares joined relations through other association' do
+          relation = assoc.call(container.relations)
 
-        expect(relation.to_a).to eql([id: 1, user_id: 2, title: "Joe's task"])
+          expect(relation.schema.map(&:to_sym)).to eql(%i[tags__id tags__name tasks__user_id])
+          expect(relation.to_a).to eql([id: 1, name: 'important', user_id: 2])
+        end
       end
-    end
-  end
-
-  with_adapters do
-    subject(:assoc) {
-      ROM::SQL::Association::ManyToMany.new(:tasks, :tags, through: :task_tags)
-    }
 
-    let(:tasks) { container.relations[:tasks] }
-    let(:tags) { container.relations[:tags] }
+      describe ROM::Plugins::Relation::SQL::AutoCombine, '#for_combine' do
+        it 'preloads relation based on association' do
+          relation = tags.for_combine(assoc).call(tasks.call)
 
-    before do
-      conf.relation(:task_tags) do
-        schema do
-          attribute :task_id, ROM::SQL::Types::ForeignKey(:tasks)
-          attribute :tag_id, ROM::SQL::Types::ForeignKey(:tags)
+          expect(relation.to_a).to eql([id: 1, name: 'important', task_id: 1])
+        end
 
-          primary_key :task_id, :tag_id
+        it 'maintains original relation' do
+          relation = tags.
+                       select_append(tags[:name].as(:tag)).
+                       for_combine(assoc).call(tasks.call)
 
-          associations do
-            many_to_one :tasks
-            many_to_one :tags
-          end
+          expect(relation.to_a).to eql([id: 1, tag: 'important', name: 'important', task_id: 1])
         end
       end
+    end
+
+    context 'with two associations pointing to the same target relation' do
+      before do
+        inferrable_relations.concat %i(users_tasks)
+      end
 
-      conf.relation(:tasks) do
-        schema do
-          attribute :id, ROM::SQL::Types::Serial
-          attribute :user_id, ROM::SQL::Types::ForeignKey(:users)
-          attribute :title, ROM::SQL::Types::String
+      before do
+        conn.create_table(:users_tasks) do
+          foreign_key :user_id, :users
+          foreign_key :task_id, :tasks
+          primary_key [:user_id, :task_id]
+        end
 
-          associations do
-            one_to_many :task_tags
-            one_to_many :tags, through: :task_tags
+        conf.relation(:users) do
+          schema(infer: true) do
+            associations do
+              has_many :users_tasks
+              has_many :tasks, through: :users_tasks
+              has_many :tasks, as: :priv_tasks
+            end
           end
         end
-      end
-    end
-
-    describe '#result' do
-      specify { expect(ROM::SQL::Association::ManyToMany.result).to be(:many) }
-    end
 
-    describe '#call' do
-      it 'prepares joined relations' do
-        relation = assoc.call(container.relations)
+        conf.relation(:users_tasks) do
+          schema(infer: true) do
+            associations do
+              belongs_to :user
+              belongs_to :task
+            end
+          end
+        end
 
-        expect(relation.schema.map(&:to_sym)).to eql(%i[tags__id tags__name task_tags__task_id])
-        expect(relation.to_a).to eql([id: 1, name: 'important', task_id: 1])
+        conf.relation(:tasks) do
+          schema(infer: true) do
+            associations do
+              has_many :users_tasks
+              has_many :users, through: :users_tasks
+            end
+          end
+        end
       end
-    end
 
-    describe ':through another assoc' do
-      subject(:assoc) do
-        ROM::SQL::Association::ManyToMany.new(:users, :tags, through: :tasks)
-      end
+      it 'does not conflict with two FKs' do
+        users = container.relations[:users]
+        tasks = container.relations[:tasks]
+        assoc = users.associations[:tasks]
 
-      it 'prepares joined relations through other association' do
-        relation = assoc.call(container.relations)
+        relation = tasks.for_combine(assoc).call(users.call)
 
-        expect(relation.schema.map(&:to_sym)).to eql(%i[tags__id tags__name tasks__user_id])
-        expect(relation.to_a).to eql([id: 1, name: 'important', user_id: 2])
+        expect(relation.to_a).to be_empty
       end
-    end
 
-    describe ROM::Plugins::Relation::SQL::AutoCombine, '#for_combine' do
-      it 'preloads relation based on association' do
-        relation = tags.for_combine(assoc).call(tasks.call)
-
-        expect(relation.to_a).to eql([id: 1, name: 'important', task_id: 1])
-      end
+      it 'preloads using FK' do
+        users = container.relations[:users]
+        tasks = container.relations[:tasks]
+        assoc = users.associations[:priv_tasks]
 
-      it 'maintains original relation' do
-        relation = tags.
-                     select_append(tags[:name].as(:tag)).
-                     for_combine(assoc).call(tasks.call)
+        relation = tasks.for_combine(assoc).call(users.where(id: 2).call)
 
-        expect(relation.to_a).to eql([id: 1, tag: 'important', name: 'important', task_id: 1])
+        expect(relation.to_a).to eql([id: 1, user_id: 2, title: "Joe's task"])
       end
     end
   end

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

@@ -1,11 +1,15 @@
 require 'spec_helper'
 
 RSpec.describe ROM::SQL::Association::ManyToOne, '#call' do
+  include_context 'database setup'
+
+  before do
+    inferrable_relations.concat %i(destinations flights)
+  end
+
   let(:assoc_from) { relations[:flights].associations[:from] }
   let(:assoc_to) { relations[:flights].associations[:to] }
 
-  include_context 'database setup'
-
   with_adapters do
     before do
       conn.create_table(:destinations) do
@@ -35,11 +39,6 @@ RSpec.describe ROM::SQL::Association::ManyToOne, '#call' do
       relations[:flights].insert(code: 'F1', from_id: from_id, to_id: to_id)
     end
 
-    after do
-      conn.drop_table(:flights)
-      conn.drop_table(:destinations)
-    end
-
     it 'prepares joined relations using correct FKs based on association aliases' do
       relation = assoc_from.call(relations)