alf-core 0.13.0

data/spec/unit/alf-lang/object_oriented/test_to_rash.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+module Alf
+  module Lang
+    describe ObjectOriented, 'to_rash' do
+
+      include ObjectOriented.new(supplier_names_relation)
+
+      subject{
+        to_rash(options).each_line.map do |line|
+          ::Kernel.eval(line)
+        end
+      }
+
+      before do
+        subject.should be_a(Array)
+        subject.each{|t| t.should be_a(Hash)}
+      end
+
+      after do
+        Relation(subject).should eq(_self_operand)
+      end
+
+      context 'when an ordering is specified' do
+        let(:ordering){ [[:name, :desc]] }
+        let(:options){ {:sort => ordering} }
+        it 'respects it' do
+          expected = supplier_names.sort.reverse
+          subject.map{|t| t[:name]}.should eq(expected)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-lang/object_oriented/test_tuple_extract.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+module Alf
+  module Lang
+    describe ObjectOriented, 'tuple_extract' do
+
+      def subject(&bl)
+        rel.extend(ObjectOriented.new(rel))
+        rel.tuple_extract(&bl)
+      end
+
+      context 'on a singleton' do
+        let(:rel)     { [{name: "Jones"}] }
+        let(:expected){ Tuple(name: "Jones") }
+
+        it 'returns the tuple' do
+          subject.should eq(expected)
+        end
+
+        it 'is aliased as tuple!' do
+          rel.extend(ObjectOriented.new(rel))
+          rel.tuple!.should eq(expected)
+        end
+      end
+
+      context 'on an empty relation' do
+        let(:rel){ [] }
+
+        it 'raises a NoSuchTupleError without block' do
+          lambda{
+            subject
+          }.should raise_error(NoSuchTupleError)
+        end
+
+        it 'yields if a block' do
+          subject{ {id: 12} }.should eq(Tuple(id: 12))
+        end
+      end
+
+      context 'on a relation with more than one tuple' do
+        let(:rel){ [{name: "Jones"}, {name: "Smith"}] }
+
+        it 'raises a NoSuchTupleError' do
+          lambda{
+            subject
+          }.should raise_error(NoSuchTupleError)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-lang/test_predicates.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+module Alf
+  module Lang
+    describe Predicates do
+      include Predicates
+
+      it "eq should factor a predicate" do
+        eq(:x, 12).should be_a(Alf::Predicate)
+      end
+
+      it "between should factor a predicate" do
+        between(:x, 2, 3).should be_a(Alf::Predicate)
+      end
+
+    end
+  end
+end

data/spec/unit/alf-optimizer/optimizer/test_optimizer.rb

@@ -0,0 +1,37 @@
+require 'optimizer_helper'
+module Alf
+  class Optimizer
+    describe Search do
+
+      let(:operand_1){ an_operand.with_heading(:id => String) }
+
+      # replaces project by clip
+      let(:processor_1){
+        lambda{|expr, search|
+          clip(search.apply(expr.operand), expr.attributes, :allbut => expr.allbut)
+        }
+      }
+      # adds an autonum before rename 
+      let(:processor_2){
+        lambda{|expr, search| autonum(search.copy_and_apply(expr), :auto) }
+      }
+      let(:optimizer){
+        Optimizer.new.register(processor_1, Algebra::Project).
+                      register(processor_2, Algebra::Rename)
+      }
+
+      subject{ optimizer.call(expr) }
+
+      let(:expr){
+        (project (rename (project operand_1, [:bar]), :foo => :bar), [:foo])
+      }
+
+      let(:expected){
+        (clip (autonum (rename (clip operand_1, [:bar]), :foo => :bar), :auto), [:foo])
+      }
+
+      it{ should eq(expected) }
+
+    end
+  end
+end

data/spec/unit/alf-optimizer/optimizer/test_search.rb

@@ -0,0 +1,48 @@
+require 'optimizer_helper'
+module Alf
+  class Optimizer
+    describe Search do
+
+      let(:search){ 
+        Search.new(processor, Algebra::Project)
+      }
+
+      let(:new_operand){ an_operand }
+
+      let(:processor){
+        lambda{|expr, s|
+          raise unless expr.is_a?(Algebra::Project)
+          raise unless s == search
+          new_operand
+        }
+      }
+
+      subject{ search.call(expr) }
+
+      context "when the expression is a Project" do
+        let(:expr){ project(an_operand, [:foo]) }
+
+        it{ should be(new_operand) }
+      end
+
+      context "when the expression has no Project at all" do
+        let(:expr){ clip(an_operand, [:foo]) }
+
+        it{ should eq(expr) }
+      end
+
+      context "when the expression has a Project somewhere" do
+        let(:expr){ clip(project(an_operand, [:foo]), [:foo]) }
+
+        specify "the top one should be a Clip" do
+          subject.should be_a(Algebra::Clip)
+        end
+
+        specify "the internal one has been seen by processor" do
+          subject.operand.should be(new_operand)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-optimizer/restrict/test_on_autonum.rb

@@ -0,0 +1,41 @@
+require 'optimizer_helper'
+module Alf
+  class Optimizer
+    describe Restrict, "on_autonum" do
+
+      let(:inside){ an_operand }
+      let(:expr)  { restrict(autonum(inside, :auto), predicate) }
+
+      subject{ Restrict.new.call(expr) }
+
+      context 'when the restriction does not apply to auto at all' do
+        let(:predicate){ comp(:x => 12) }
+        let(:expected) { autonum(restrict(inside, predicate)) }
+      
+        it{ should eq(expected) }
+      end
+      
+      context 'when the restriction applies to auto only' do
+        let(:predicate){ comp(:auto => 12) }
+      
+        it{ should eq(expr) }
+      end
+      
+      context 'when the restriction applies to auto and other fields in a AND' do
+        let(:predicate){ comp(:auto => 12, :x => 13) }
+        let(:expected){
+          restrict(autonum(restrict(inside, comp(:x => 13)), :auto), comp(:auto => 12))
+        }
+      
+        it{ should eq(expected) }
+      end
+
+      context 'when the restriction applies to auto and other fields in a OR' do
+        let(:predicate){ comp(:auto => 12) | comp(:x => 13) }
+
+        it{ should eq(expr) }
+      end
+
+    end
+  end
+end

data/spec/unit/alf-optimizer/restrict/test_on_coerce.rb

@@ -0,0 +1,42 @@
+require 'optimizer_helper'
+module Alf
+  class Optimizer
+    describe Restrict, "on_coerce" do
+
+      let(:inside)  { an_operand }
+      let(:coercion){ Heading.coerce(:x => Integer) }
+      let(:expr)    { restrict(coerce(inside, coercion), predicate) }
+
+      subject{ Restrict.new.call(expr) }
+
+      context 'when the restriction does not apply to x' do
+        let(:predicate){ comp(:y => 12) }
+        let(:expected) { coerce(restrict(inside, predicate), coercion) }
+
+        it{ should eq(expected) }
+      end
+
+      context 'when the restriction applies to x' do
+        let(:predicate){ comp(:x => 12) }
+
+        it{ should eq(expr) }
+      end
+
+      context 'when the restriction applies to x and other fields in a COMP' do
+        let(:predicate){ comp(:y => 12, :x => 13) }
+        let(:expected){
+          restrict(coerce(restrict(inside, comp(:y => 12)), coercion), comp(:x => 13))
+        }
+
+        it{ should eq(expected) }
+      end
+
+      context 'when the restriction applies to x and other fields in a OR' do
+        let(:predicate){ comp(:y => 12) | comp(:x => 13) }
+
+        it{ should eq(expr) }
+      end
+
+    end
+  end
+end

data/spec/unit/alf-optimizer/restrict/test_on_join.rb

@@ -0,0 +1,107 @@
+require 'optimizer_helper'
+module Alf
+  class Optimizer
+    describe Restrict, "on_join" do
+
+      let(:left) { an_operand.with_heading(id: Integer, name: String) }
+      let(:right){ an_operand.with_heading(id: Integer, city: String) }
+
+      let(:id_pred)  { comp(id: 1)       }
+      let(:name_pred){ comp(name: 'foo') }
+      let(:city_pred){ comp(city: 'bar') }
+
+      let(:expr)     { restrict(join(left, right), predicate) }
+      let(:optimized){ Restrict.new.call(expr)                }
+      let(:expected) { Support.to_lispy(expected_rewrite)     }
+
+      subject{ Support.to_lispy(optimized) }
+
+      # not analyzable
+      context 'when the restriction is a native one' do
+        let(:predicate){ Predicate.native(->{ id > 12 }) }
+        let(:expected_rewrite){ restrict(join(left, right), predicate) }
+      
+        it 'should be as expected' do
+          optimized.should be_a(Algebra::Restrict)
+          optimized.operand.should be(expr.operand)
+        end
+      end
+
+      # covered by one restriction pushed
+
+      context 'when the restriction applies to left only' do
+        let(:predicate){ name_pred }
+        let(:expected_rewrite){ join(restrict(left, predicate), right) }
+      
+        it{ should eq(expected) }
+      end
+      
+      context 'when the restriction applies to right only' do
+        let(:predicate){ city_pred }
+        let(:expected_rewrite){ join(left, restrict(right, predicate)) }
+      
+        it{ should eq(expected) }
+      end
+      
+      context 'when the restriction is a OR on left' do
+        let(:predicate){ id_pred | name_pred }
+        let(:expected_rewrite){ join(restrict(left, predicate), right) }
+      
+        it{ should eq(expected) }
+      end
+
+      context 'when the restriction is a OR on right' do
+        let(:predicate){ id_pred | city_pred }
+        let(:expected_rewrite){ join(left, restrict(right, predicate)) }
+      
+        it{ should eq(expected) }
+      end
+
+      # covered by the conjunction of pushed restrictions
+
+      context 'when the restriction applies to both operands' do
+        let(:predicate){ id_pred }
+        let(:expected_rewrite){ join(restrict(left, predicate), restrict(right, predicate)) }
+      
+        it{ should eq(expected) }
+      end
+
+      context 'when the restriction is a AND on left' do
+        let(:predicate){ id_pred & name_pred }
+        let(:expected_rewrite){ join(restrict(left, predicate), restrict(right, id_pred)) }
+      
+        it{ should eq(expected) }
+      end
+      
+      context 'when the restriction is a AND to be splitted' do
+        let(:predicate){ city_pred & name_pred }
+        let(:expected_rewrite){ join(restrict(left, name_pred), restrict(right, city_pred)) }
+      
+        it{ should eq(expected) }
+      end
+
+      # not fully covered by a conjunction
+      context 'when the restriction is an un-splittable OR' do
+        let(:predicate){ city_pred | name_pred }
+        let(:expected_rewrite){ restrict(join(left, right), predicate) }
+      
+        it{ should eq(expected) }
+      end
+
+      context 'when the restriction is an un-splittable AND/OR' do
+        let(:predicate){ (city_pred & name_pred) | id_pred }
+        let(:expected_rewrite){ restrict(join(left, right), predicate) }
+      
+        it{ should eq(expected) }
+      end
+
+      context 'when the restriction is a partly un-splittable OR' do
+        let(:predicate){ id_pred & (city_pred | name_pred) }
+        let(:expected_rewrite){ restrict(join(restrict(left, id_pred), restrict(right, id_pred)), city_pred | name_pred) }
+      
+        it{ should eq(expected) }
+      end
+
+    end
+  end
+end

data/spec/unit/alf-optimizer/restrict/test_on_matching.rb

@@ -0,0 +1,41 @@
+require 'optimizer_helper'
+module Alf
+  class Optimizer
+    describe Restrict, "on_matching" do
+
+      let(:left) { an_operand.with_heading(id: Integer, name: String) }
+      let(:right){ an_operand.with_heading(id: Integer, city: String) }
+
+      let(:id_pred)  { comp(id: 1)       }
+      let(:name_pred){ comp(name: 'foo') }
+
+      let(:expr)     { restrict(matching(left, right), predicate) }
+      let(:optimized){ Restrict.new.call(expr)                    }
+      let(:expected) { Support.to_lispy(expected_rewrite)         }
+
+      subject{ Support.to_lispy(optimized) }
+
+      context 'when the restriction does not touch right attributes' do
+        let(:predicate){ name_pred }
+        let(:expected_rewrite){ matching(restrict(left, predicate), right) }
+      
+        it{ should eq(expected) }
+      end
+
+      context 'when the restriction does touch right attributes' do
+        let(:predicate){ id_pred }
+        let(:expected_rewrite){ matching(restrict(left, predicate), restrict(right, predicate)) }
+      
+        it{ should eq(expected) }
+      end
+
+      context 'when the restriction partly touches right attributes' do
+        let(:predicate){ id_pred & name_pred }
+        let(:expected_rewrite){ matching(restrict(left, predicate), restrict(right, id_pred)) }
+      
+        it{ should eq(expected) }
+      end
+
+    end
+  end
+end

data/spec/unit/alf-optimizer/shared/a_pass_through_expression_for_restrict.rb

@@ -0,0 +1,36 @@
+shared_examples_for "a pass-through expression for restrict" do
+
+  let(:the_predicate){
+    defined?(predicate) ? predicate : Alf::Predicate.native(lambda{})
+  }
+
+  let(:restriction){
+    restrict(subject, the_predicate)
+  }
+
+  let(:optimized){
+    Alf::Optimizer::Restrict.new.call(restriction)
+  }
+
+  # before(:all) do
+  #   puts Support.to_lispy(restriction)
+  #   puts Support.to_lispy(optimized)
+  # end
+
+  specify "optimized leads to the initial operator" do
+    optimized.should be_a(subject.class)
+  end
+
+  specify "optimized signature is unchanged" do
+    optimized.signature.collect_on(subject).should eq(subject.signature.collect_on(subject))
+  end
+
+  specify "the restriction has been pushed with same predicate" do
+    optimized.operands.each do |operand|
+      operand.should be_a(Alf::Algebra::Restrict)
+      repl = defined?(replaced_predicate) ? replaced_predicate : restriction.predicate
+      operand.predicate.should eq(repl)
+    end
+  end
+
+end