alf-core 0.14.0 → 0.15.0

data/spec/unit/alf-compiler/test_principle.rb

@@ -0,0 +1,332 @@
+require 'compiler_helper'
+module Alf
+  describe Compiler, "the overall principle" do
+
+    # This is a compiler dedicated to specific adapters, e.g. SQL
+    class DedicatedCompiler < Compiler
+
+      def supports_reuse?
+        true
+      end
+
+      def reuse(plan, compiled)
+        compiled
+      end
+
+      def on_project(plan, expr, compiled)
+        DedicatedCog.new(expr, self, [compiled])
+      end
+
+      def on_sort(plan, expr, compiled)
+        Engine::Sort.new(compiled, expr.ordering)
+      end
+
+      def on_page(plan, expr, compiled)
+        compiled = plan.recompile(compiled){|p|
+          p.sort(expr.operand, expr.ordering)
+        }
+        DedicatedCog.new(expr, self, [compiled])
+      end
+
+      def on_ungroup(plan, expr, compiled)
+        raise NotSupportedError
+      end
+
+      def on_union(plan, expr, left, right)
+        DedicatedCog.new(expr, self, [left, right])
+      end
+
+    end # class DedicatedCompiler
+
+    # This is the class supposed to be served by an adapter.
+    # It returns self on to_cog and has the dedicated compiler.
+    class DedicatedCog
+      include Engine::Cog
+
+      def initialize(expr, compiler, operands = nil)
+        super(expr, compiler)
+        @operands = operands
+      end
+      attr_reader :operands
+
+      def left
+        unless operands && operands.size == 2
+          raise "Unexpected operands `#{operands.inspect}`"
+        end
+        operands.first
+      end
+
+      def right
+        unless operands && operands.size == 2
+          raise "Unexpected operands `#{operands.inspect}`"
+        end
+        operands.last
+      end
+
+      def operand
+        unless operands && operands.size == 1
+          raise "Unexpected operands `#{operands.inspect}`"
+        end
+        operands.first
+      end
+
+    end # class DedicatedCog
+
+    subject{ default.call(expr) }
+
+    let(:cog){
+      DedicatedCog.new(nil, dedicated)
+    }
+
+    let(:cog2){
+      DedicatedCog.new(nil, dedicated)
+    }
+
+    let(:default){
+      Compiler::Default.new
+    }
+
+    let(:dedicated){
+      DedicatedCompiler.new
+    }
+
+    context 'on a direct cog-proxied operand' do
+      # the first compiler takes care of compiling the stuff, by simple
+      # delegation to to_cog of the operand
+      
+      let(:expr){
+        an_operand(cog)
+      }
+
+      it{ should be(cog) }
+
+      it 'should have expected compiler' do
+        subject.compiler.should be(dedicated)
+      end
+    end
+
+    context 'on a supported operator' do
+      # the first compiler compiles the leaf.
+      # the second compiler compiles the projection.
+
+      let(:expr){
+        project(an_operand(cog), [:a])
+      }
+
+      it{ should be_a(DedicatedCog) }
+
+      it 'should have correct expr' do
+        subject.expr.should be(expr)
+      end
+
+      it 'should have expected compiler' do
+        subject.compiler.should be(dedicated)
+      end
+
+      it 'should have correct operand' do
+        subject.operand.should be(cog)
+        subject.operand.compiler.should be(dedicated)
+      end
+    end
+
+    context 'on a dyadic supported operator' do
+      # the first compiler compiles both leafs.
+      # the second compiler compiles the union.
+
+      let(:expr){
+        union(an_operand(cog), an_operand(cog2))
+      }
+
+      it{ should be_a(DedicatedCog) }
+
+      it 'should have correct expr' do
+        subject.expr.should be(expr)
+      end
+
+      it 'should have correct operands' do
+        subject.operands.should eq([cog, cog2])
+      end
+
+      it 'should have expected compiler' do
+        subject.compiler.should be(dedicated)
+      end
+    end
+
+    context 'on an operator requiring compiling sub-expressions' do
+
+      let(:expr){
+        page(an_operand(cog), [:name, :asc], 2)
+      }
+
+      it{ should be_a(DedicatedCog) }
+
+      it 'has the sort as sub-cog' do
+        subject.operand.should be_a(Engine::Sort)
+      end
+
+      it 'has the cog as sub-sub operand' do
+        subject.operand.operand.should be(cog)
+      end
+
+      it 'should have expected compiler' do
+        subject.compiler.should be(dedicated)
+      end
+    end
+
+    context 'on an unsupported operator' do
+      # the first compiler compiles the leaf.
+      # the second compiler fails at compiling the projection.
+      # the first compiler compiles the projection.
+
+      let(:expr){
+        rename(an_operand(cog), :a => :b)
+      }
+
+      it{ should be_a(Engine::Rename) }
+
+      it 'should have the cog as operand' do
+        subject.operand.should be(cog)
+      end
+
+      it 'should have expected compiler' do
+        subject.compiler.should be(default)
+      end
+    end
+
+    context 'on a partly supported operator' do
+      # the first compiler compiles the leaf.
+      # the second compiler fails at compiling the unwrap and fallsback.
+      # the first compiler compiles the unwrap.
+
+      let(:expr){
+        unwrap(an_operand(cog), :a)
+      }
+
+      it{ should be_a(Engine::Unwrap) }
+
+      it 'should have the cog as operand' do
+        subject.operand.should be(cog)
+      end
+
+      it 'should have expected compilers' do
+        subject.compiler.should be(default)
+      end
+    end
+
+    context 'on a partly supported operator through a NotSupportedError' do
+      # the first compiler compiles the leaf.
+      # the second compiler fails at compiling the ungroup and fallsback.
+      # the first compiler compiles the ungroup.
+
+      let(:expr){
+        ungroup(an_operand(cog), :a)
+      }
+
+      it{ should be_a(Engine::Ungroup) }
+
+      it 'should have the cog as operand' do
+        subject.operand.should be(cog)
+      end
+
+      it 'should have expected compilers' do
+        subject.compiler.should be(default)
+      end
+    end
+
+    context 'on a doubly supported operator' do
+      # the first compiler compiles the leaf.
+      # the second compiler compiles the first projection.
+      # the second compiler compiles the second projection.
+
+      let(:subexpr){
+        project(an_operand(cog), [:a])
+      }
+
+      let(:expr){
+        project(subexpr)
+      }
+
+      it{ should be_a(DedicatedCog) }
+
+      it 'should have correct traceability' do
+        subject.expr.should be(expr)
+      end
+
+      it 'should have expected compiler' do
+        subject.compiler.should be(dedicated)
+      end
+
+      it 'should have correct sub-cog' do
+        subject.operand.should be_a(DedicatedCog)
+        subject.operand.expr.should be(subexpr)
+        subject.operand.compiler.should be(dedicated)
+      end
+
+      it 'should have correct sub-sub-cog' do
+        subject.operand.operand.should be(cog)
+        subject.operand.operand.compiler.should be(dedicated)
+      end
+    end
+
+    context 'on a dyadic operator compiled by two different compilers' do
+      # the first compiler compiles the left leaf and the projection.
+      # the second compiler compiles the right leaf and the projection.
+      # the this compiler compiles the union.
+
+      let(:expr){
+        join(project(an_operand(left), [:a]), project(an_operand(right), [:a]))
+      }
+
+      let(:compilo1){
+        DedicatedCompiler.new
+      }
+
+      let(:compilo2){
+        DedicatedCompiler.new
+      }
+
+      let(:left){
+        DedicatedCog.new(nil, compilo1)
+      }
+
+      let(:right){
+        DedicatedCog.new(nil, compilo2)
+      }
+
+      let(:default){
+        Compiler::Default.new
+      }
+
+      it{ should be_a(Engine::Join) }
+
+      it 'should have correct expr' do
+        subject.expr.should be(expr)
+      end
+
+      it 'should have correct sub-cogs' do
+        subject.left.should be_a(DedicatedCog)
+        subject.right.should be_a(DedicatedCog)
+      end
+
+      it 'should have expected compilers' do
+        subject.compiler.should be(default)
+        subject.left.compiler.should be(compilo1)
+        subject.right.compiler.should be(compilo2)
+      end
+    end
+
+    context 'on expressions where reuse is possible' do
+      let(:expr){
+        reused = project(an_operand(cog), [:a])
+        union(reused, reused)
+      }
+
+      it{ should be_a(DedicatedCog) }
+
+      it 'should reuse the compilation result' do
+        subject.left.should be(subject.right)
+      end
+    end
+
+  end
+end

data/spec/unit/alf-core/test_aggregator.rb

@@ -29,30 +29,6 @@ module Alf
         let(:arg){ Aggregator.sum{a} }
         it{ should eq(arg) }
       end
-
-      describe "from a String" do
-        let(:arg){ "sum{a}" }
-
-        it {
-          should be_a(Aggregator::Sum)
-        }
-
-        it 'should have source code' do
-          subject.has_source_code!.should eq("sum{a}")
-        end
-
-        specify{
-          subject.aggregate(input).should eql(7)
-        }
-
-      end
-
-    end
-
-    it 'should implement optimistic equality based on source code' do
-      ag1 = Aggregator.coerce("sum{ qty }")
-      ag2 = Aggregator.coerce("sum{ qty }")
-      ag1.should eq(ag2)
     end
 
   end

data/spec/unit/alf-database/connection/test_parse.rb

@@ -5,26 +5,8 @@ module Alf
 
       let(:conn){ sap_conn }
 
-      shared_examples_for 'a bound expression' do
-
-        it{ should be_bound }
-        
-        it 'has the expected connection' do
-          subject.connection!.should be(conn)
-        end
-
-        it 'has bound operands too' do
-          subject.operands.all?{|op|
-            op.should be_bound
-            op.connection!.should be(conn)
-          } if subject.is_a?(Algebra::Operator)
-        end
-      end
-
       shared_examples_for 'a named operand on suppliers' do
 
-        it_should_behave_like 'a bound expression'
-        
         it{ should be_a(Algebra::Operand::Named) }
 
         it 'has the expected name' do
@@ -34,8 +16,6 @@ module Alf
 
       shared_examples_for 'a join operand on suppliers and supplies' do
 
-        it_should_behave_like 'a bound expression'
-        
         it{ should be_a(Algebra::Join) }
       end
 
@@ -58,19 +38,6 @@ module Alf
 
           it_should_behave_like 'a named operand on suppliers'
         end
-
-        context 'parsed from an existing operand' do
-          let(:expr){ Algebra.named_operand(:suppliers, 12) }
-
-          subject{ conn.parse(expr) }
-
-          it_should_behave_like 'a named operand on suppliers'
-
-          it 'does not touch the original expr' do
-            subject.should_not be(expr)
-            expr.connection.should eq(12)
-          end
-        end
       end
 
       context 'when a complex expression' do
@@ -86,22 +53,6 @@ module Alf
 
           it_should_behave_like 'a join operand on suppliers and supplies'
         end
-
-        context 'with an expression' do
-          let(:expr){
-            conn.parse{ join(project(suppliers, [:sid]), supplies) }.bind(12)
-          }
-
-          subject{ conn.parse(expr) }
-
-          it_should_behave_like 'a join operand on suppliers and supplies'
-
-          it 'does not touch the original expr' do
-            subject.should_not be(expr)
-            expr.connection.should eq(12)
-            expr.operands.all?{|op| op.connection.should eq(12) }
-          end
-        end
       end
 
     end

data/spec/unit/alf-database/connection/test_relvar.rb

@@ -11,7 +11,7 @@ module Alf
         it{ should be_a(Relvar::Base) }
 
         it 'has the expected name' do
-          subject.name.should eq(:suppliers)
+          subject.expr.name.should eq(:suppliers)
         end
 
         it 'is bound to the serving connection' do
@@ -27,14 +27,6 @@ module Alf
         it 'has the expected expression' do
           subject.expr.should be_a(Algebra::Project)
         end
-
-        it 'is bound to the serving connection' do
-          subject.connection!.should be(conn)
-        end
-
-        it 'has a bound expression as well' do
-          subject.expr.connection!.should be(conn)
-        end
       end
 
     end