alf-sequel 0.14.0 → 0.15.0

data/spec/compiler/test_intersect.rb

@@ -1,18 +0,0 @@
-require 'compiler_helper'
-module Alf
-  module Sequel
-    describe Compiler, "intersect" do
-
-      subject{ compile(expr) }
-
-      context 'when the operand is fully compilable' do
-        let(:expr){ intersect(suppliers, supplies) }
-
-        specify do
-          subject.sql.should eq("SELECT * FROM (SELECT * FROM `suppliers` AS 't1' INTERSECT SELECT * FROM `supplies` AS 't2') AS 't3'")
-        end
-      end
-
-    end
-  end
-end

data/spec/compiler/test_join.rb

@@ -1,26 +0,0 @@
-require 'compiler_helper'
-module Alf
-  module Sequel
-    describe Compiler, "join" do
-
-      subject{ compile(expr) }
-
-      context 'when the operand is fully compilable' do
-        let(:expr){ join(suppliers, supplies) }
-
-        specify do
-          subject.sql.should eq("SELECT * FROM (SELECT * FROM (SELECT * FROM `suppliers` AS 't1') AS 't1' INNER JOIN (SELECT * FROM `supplies` AS 't2') AS 't3' USING (`sid`)) AS 't3'")
-        end
-      end
-
-      context 'when the left operand is a projection' do
-        let(:expr){ join(project(suppliers, [:sid]), supplies) }
-
-        specify do
-          subject.sql.should eq("SELECT * FROM (SELECT * FROM (SELECT `t1`.`sid` FROM `suppliers` AS 't1') AS 't1' INNER JOIN (SELECT * FROM `supplies` AS 't2') AS 't3' USING (`sid`)) AS 't3'")
-        end
-      end
-
-    end
-  end
-end

data/spec/compiler/test_leaf_operand.rb

@@ -1,24 +0,0 @@
-require 'compiler_helper'
-module Alf
-  module Sequel
-    describe Compiler, "leaf_operand" do
-
-      subject{ compile(expr) }
-
-      context 'on the proper context' do
-        let(:expr){ suppliers }
-
-        it{ should be_a(Cog) }
-      end
-
-      context 'on another context' do
-        let(:expr){ Algebra.named_operand(:suppliers, self) }
-
-        pending "support for multiple context is needed" do
-          it{ should_not be_a(Cog) }
-        end
-      end
-
-    end
-  end
-end

data/spec/compiler/test_matching.rb

@@ -1,34 +0,0 @@
-require 'compiler_helper'
-module Alf
-  module Sequel
-    describe Compiler, "matching" do
-
-      subject{ compile(expr) }
-
-      context 'when no common attributes' do
-        let(:expr){ matching(suppliers, project(supplies, [:part_id])) }
-
-        specify do
-          subject.sql.should eq("SELECT * FROM `suppliers` AS 't1' WHERE (EXISTS (SELECT DISTINCT `t2`.`part_id` FROM `supplies` AS 't2'))")
-        end
-      end
-
-      context 'when only one common attributes' do
-        let(:expr){ matching(suppliers, supplies) }
-
-        specify do
-          subject.sql.should eq("SELECT * FROM `suppliers` AS 't1' WHERE (`t1`.`sid` IN (SELECT `t2`.`sid` FROM `supplies` AS 't2'))")
-        end
-      end
-
-      context 'when many common attributes' do
-        let(:expr){ matching(suppliers, parts) }
-
-        specify do
-          subject.sql.should eq("SELECT * FROM `suppliers` AS 't1' WHERE (EXISTS (SELECT * FROM `parts` AS 't2' WHERE ((`t1`.`name` = `t2`.`name`) AND (`t1`.`city` = `t2`.`city`))))")
-        end
-      end
-
-    end
-  end
-end

data/spec/compiler/test_not_matching.rb

@@ -1,34 +0,0 @@
-require 'compiler_helper'
-module Alf
-  module Sequel
-    describe Compiler, "not_matching" do
-
-      subject{ compile(expr) }
-
-      context 'when no common attributes' do
-        let(:expr){ not_matching(suppliers, project(supplies, [:part_id])) }
-
-        specify do
-          subject.sql.should eq("SELECT * FROM `suppliers` AS 't1' WHERE NOT (EXISTS (SELECT DISTINCT `t2`.`part_id` FROM `supplies` AS 't2'))")
-        end
-      end
-
-      context 'when only one common attributes' do
-        let(:expr){ not_matching(suppliers, supplies) }
-
-        specify do
-          subject.sql.should eq("SELECT * FROM `suppliers` AS 't1' WHERE (`t1`.`sid` NOT IN (SELECT `t2`.`sid` FROM `supplies` AS 't2'))")
-        end
-      end
-
-      context 'when many common attributes' do
-        let(:expr){ not_matching(suppliers, parts) }
-
-        specify do
-          subject.sql.should eq("SELECT * FROM `suppliers` AS 't1' WHERE NOT (EXISTS (SELECT * FROM `parts` AS 't2' WHERE ((`t1`.`name` = `t2`.`name`) AND (`t1`.`city` = `t2`.`city`))))")
-        end
-      end
-
-    end
-  end
-end

data/spec/compiler/test_page.rb

@@ -1,86 +0,0 @@
-require 'compiler_helper'
-module Alf
-  module Sequel
-    describe Compiler, "page" do
-
-      subject{ compile(expr) }
-
-      let(:expr){
-        page(operand, ordering, page_index, page_size: 8)
-      }
-
-      context 'when fully compilable' do
-        let(:operand){ suppliers }
-
-        [
-          [ [[:name, :asc]],  2, "SELECT * FROM `suppliers` AS 't1' ORDER BY `t1`.`name` ASC LIMIT 8 OFFSET 8" ],
-          [ [[:name, :asc]], -2, "SELECT * FROM `suppliers` AS 't1' ORDER BY `t1`.`name` DESC LIMIT 8 OFFSET 8" ],
-          [ [[:city, :asc]],  2, "SELECT * FROM `suppliers` AS 't1' ORDER BY `t1`.`city` ASC, `t1`.`sid` ASC LIMIT 8 OFFSET 8" ],
-          [ [[:city, :asc]], -2, "SELECT * FROM `suppliers` AS 't1' ORDER BY `t1`.`city` DESC, `t1`.`sid` DESC LIMIT 8 OFFSET 8" ],
-        ].each do |(ordering,page_index,expected)|
-
-          context "page(#{ordering}, #{page_index})" do
-            let(:ordering)  { ordering   }
-            let(:page_index){ page_index }
-
-            it 'should compile as expected' do
-              subject.sql.should eq(expected)
-            end
-          end
-
-        end
-      end # fully compilable
-
-      context 'when immediately uncompilable yet known keys' do
-        let(:operand){
-          Algebra::Operand::Fake.new.with_keys([:sid], [:name])
-        }
-
-        [
-          [ [[:name, :asc]], 2, [[:name, :asc]] ],
-          [ [[:city, :asc]], 2, [[:city, :asc], [:sid, :asc]] ]
-        ].each do |ordering, page_index, expected|
-
-          context "page(#{ordering}, #{page_index})" do
-            let(:ordering)  { ordering   }
-            let(:page_index){ page_index }
-
-            it{ should be_a(Engine::Take) }
-
-            it 'should have sort with good ordering' do
-              subject.operand.should be_a(Engine::Sort)
-              subject.operand.ordering.should eq(Ordering.new(expected))
-            end
-          end
-
-        end
-      end
-
-      context 'when immediately uncompilable yet unknown keys' do
-        let(:operand){
-          Algebra::Operand::Fake.new
-        }
-
-        [
-          [ [[:name, :asc]], 2, [[:name, :asc]] ],
-          [ [[:city, :asc]], 2, [[:city, :asc]] ]
-        ].each do |ordering, page_index, expected|
-
-          context "page(#{ordering}, #{page_index})" do
-            let(:ordering)  { ordering   }
-            let(:page_index){ page_index }
-
-            it{ should be_a(Engine::Take) }
-
-            it 'should have sort with good ordering' do
-              subject.operand.should be_a(Engine::Sort)
-              subject.operand.ordering.should eq(Ordering.new(expected))
-            end
-          end
-
-        end
-      end
-
-    end
-  end
-end

data/spec/compiler/test_predicate.rb

@@ -1,141 +0,0 @@
-require 'compiler_helper'
-module Alf
-  module Sequel
-    class Compiler
-      describe Predicate do
-
-        let(:p)        { Alf::Predicate              }
-        let(:compiler) { Predicate.new               }
-        let(:dataset)  { sap.cog(:suppliers).dataset }
-        let(:compiled) { compiler.call(expr)         }
-
-        subject{ dataset.literal(compiled) }
-
-        context 'tautology' do
-          let(:expr){ p.tautology }
-
-          it{ should eq("(1 = 1)") }
-        end
-
-        context 'contradiction' do
-          let(:expr){ p.contradiction }
-
-          it{ should eq("(1 = 0)") }
-        end
-
-        context 'var_ref' do
-          let(:expr){ p.var_ref(:x) }
-
-          it{ should eq("`x`") }
-        end
-
-        context 'literal' do
-          let(:expr){ p.literal(12) }
-
-          it{ should eq("12") }
-        end
-
-        context 'eq(var, literal)' do
-          let(:expr){ p.eq(:x, 12) }
-
-          it{ should eq("(`x` = 12)") }
-        end
-
-        context 'neq(var, literal)' do
-          let(:expr){ p.neq(:x, 12) }
-
-          it{ should eq("(`x` != 12)") }
-        end
-
-        context 'eq(var, nil)' do
-          let(:expr){ p.eq(:x, nil) }
-
-          it{ should eq("(`x` IS NULL)") }
-        end
-
-        context 'eq(var, var)' do
-          let(:expr){ p.eq(:x, :y) }
-
-          it{ should eq("(`x` = `y`)") }
-        end
-
-        context 'lt(var, literal)' do
-          let(:expr){ p.lt(:x, 2) }
-
-          it{ should eq("(`x` < 2)") }
-        end
-
-        context 'lte(var, literal)' do
-          let(:expr){ p.lte(:x, 2) }
-
-          it{ should eq("(`x` <= 2)") }
-        end
-
-        context 'gt(var, literal)' do
-          let(:expr){ p.gt(:x, 2) }
-
-          it{ should eq("(`x` > 2)") }
-        end
-
-        context 'gte(var, literal)' do
-          let(:expr){ p.gte(:x, 2) }
-
-          it{ should eq("(`x` >= 2)") }
-        end
-
-        context 'not(var)' do
-          let(:expr){ p.not(:x) }
-
-          it{ should eq("NOT `x`") }
-        end
-
-        context 'not(tautology)' do
-          let(:expr){ p.not(true) }
-
-          it{ should eq("(1 = 0)") }
-        end
-
-        context 'and' do
-          let(:expr){ p.eq(:x, 2) & p.eq(:y, 3) }
-
-          it{ should eq("((`x` = 2) AND (`y` = 3))") }
-        end
-
-        context 'or' do
-          let(:expr){ p.eq(:x, 2) | p.eq(:y, 3) }
-
-          it{ should eq("((`x` = 2) OR (`y` = 3))") }
-        end
-
-        context 'comp' do
-          let(:expr){ p.comp(:lt, :x => 2, :y => 3) }
-
-          it{ should eq("((`x` < 2) AND (`y` < 3))") }
-        end
-
-        context 'in' do
-          let(:expr){ p.in(:x, [2, 3]) }
-
-          it{ should eq("(`x` IN (2, 3))") }
-        end
-
-        context 'in with a dataset at right' do
-          let(:expr){ p.in(:x, dataset) }
-
-          it{ should eq("(`x` IN (SELECT * FROM `suppliers`))") }
-        end
-
-        context 'native' do
-          let(:expr){ p.native(lambda{}) }
-
-          specify{
-            lambda{
-              subject
-            }.should throw_symbol(:pass)
-          }
-        end
-
-      end
-    end
-  end
-end

data/spec/compiler/test_project.rb

@@ -1,64 +0,0 @@
-require 'compiler_helper'
-module Alf
-  module Sequel
-    describe Compiler, "project" do
-
-      subject{ compile(expr) }
-
-      context 'when the operand is fully compilable' do
-        let(:expr){ project(suppliers, [:sid, :name]) }
-
-        specify{
-          subject.sql.should eq("SELECT `t1`.`sid`, `t1`.`name` FROM `suppliers` AS 't1'")
-        }
-      end
-
-      context 'when the operand is fully compilable (distinct needed)' do
-        let(:expr){ project(suppliers, [:city]) }
-
-        specify{
-          subject.sql.should eq("SELECT DISTINCT `t1`.`city` FROM `suppliers` AS 't1'")
-        }
-      end
-
-      context 'when the operand is a restriction on a key part' do
-        let(:expr){ project(restrict(supplies, Predicate.eq(:sid, 1)), [:pid]) }
-
-        specify{
-          subject.sql.should eq("SELECT `t1`.`pid` FROM `supplies` AS 't1' WHERE (`t1`.`sid` = 1)")
-        }
-      end
-
-      context 'when the operand is a restriction on the key' do
-        let(:expr){ project(restrict(suppliers, Predicate.eq(:sid, 1)), [:sid]) }
-
-        specify{
-          subject.sql.should eq("SELECT `t1`.`sid` FROM `suppliers` AS 't1' WHERE (`t1`.`sid` = 1)")
-        }
-      end
-
-      context 'when the operand is fully compilable (allbut, distinct)' do
-        let(:expr){ project(suppliers, [:sid, :name, :status], :allbut => true) }
-
-        specify{
-          subject.sql.should eq("SELECT DISTINCT `t1`.`city` FROM `suppliers` AS 't1'")
-        }
-      end
-
-      context 'when the operand is a renaming' do
-        let(:expr){ project(rename(suppliers, :sid => :supplier_id), [:supplier_id]) }
-
-        specify{
-          subject.sql.should eq("SELECT `t2`.`supplier_id` AS 'supplier_id' FROM (SELECT `t1`.`sid` AS 'supplier_id', `t1`.`name` AS 'name', `t1`.`status` AS 'status', `t1`.`city` AS 'city' FROM `suppliers` AS 't1') AS 't2'")
-        }
-      end
-
-      context 'when the operand is not compilable' do
-        let(:expr){ project(an_operand, [:sid, :name]) }
-
-        it{ should be_a(Engine::Cog) }
-      end
-
-    end
-  end
-end

data/spec/compiler/test_rename.rb

@@ -1,26 +0,0 @@
-require 'compiler_helper'
-module Alf
-  module Sequel
-    describe Compiler, "rename" do
-
-      subject{ compile(expr) }
-
-      context 'when the operand is fully compilable' do
-        let(:expr){ rename(suppliers, :sid => :id) }
-
-        specify{
-          subject.sql.should eq("SELECT * FROM (SELECT `t1`.`sid` AS 'id', `t1`.`name` AS 'name', `t1`.`status` AS 'status', `t1`.`city` AS 'city' FROM `suppliers` AS 't1') AS 't2'")
-        }
-      end
-
-      context 'when the operand is another renaming' do
-        let(:expr){ rename(rename(suppliers, :sid => :id), :id => :foo) }
-
-        specify{
-          subject.sql.should eq("SELECT * FROM (SELECT `t2`.`id` AS 'foo', `t2`.`name` AS 'name', `t2`.`status` AS 'status', `t2`.`city` AS 'city' FROM (SELECT `t1`.`sid` AS 'id', `t1`.`name` AS 'name', `t1`.`status` AS 'status', `t1`.`city` AS 'city' FROM `suppliers` AS 't1') AS 't2') AS 't3'")
-        }
-      end
-
-    end
-  end
-end