alf-core 0.13.1 → 0.14.0

data/spec/unit/alf-algebra/operator/project/test_key_preserving.rb

@@ -27,10 +27,13 @@ module Alf
       end
 
       context 'when the operand is a restriction on the key' do
+        ## [:sid]
         let(:operand){
           an_operand.with_heading(sid: Integer, name: String)
                     .with_keys([:sid])
         }
+        # restrict: []
+        # project: []
         let(:op){
           a_lispy.project(a_lispy.restrict(operand, sid: 1), [:sid])
         }

data/spec/unit/alf-algebra/operator/project/test_keys.rb

@@ -3,50 +3,87 @@ module Alf
   module Algebra
     describe Project, 'keys' do
 
-      let(:operand){
-        an_operand.with_heading(id: Integer, name: String, status: String).
-                   with_keys([:id], [:name])
-      }
-
       subject{ op.keys }
 
-      context 'when conserving at least one key' do
-        let(:op){
-          a_lispy.project(operand, [:id, :status])
-        }
-        let(:expected){
-          Keys[ [:id] ]
+      context 'with two single keys' do
+        let(:operand){
+          an_operand.with_heading(id: Integer, name: String, status: String, city: String).
+                     with_keys([:id], [:name])
         }
 
-        it { should eq(expected) }
+        context 'when conserving at least one key' do
+          let(:op){
+            a_lispy.project(operand, [:id, :status])
+          }
+          let(:expected){
+            Keys[ [:id] ]
+          }
+
+          it { should eq(expected) }
+        end
+
+        context 'when projecting all keys away' do
+          let(:op){
+            a_lispy.project(operand, [:status])
+          }
+          let(:expected){
+            Keys[ [:status] ]
+          }
+
+          it { should eq(expected) }
+        end
       end
 
-      context 'when projecting all keys away' do
+      context 'when a key is cut' do
+        # 1, 1, 1
+        # 1, 2, 3
+        let(:operand){
+          an_operand.with_heading(sid: Integer, pid: Integer, qty: Integer)
+                    .with_keys([:sid, :pid])
+        }
+        # 1, _, 1
+        # 1, _, 3
         let(:op){
-          a_lispy.project(operand, [:status])
+          a_lispy.project(operand, [:sid, :qty])
         }
         let(:expected){
-          Keys[ [:status] ]
+          Keys[ [:sid, :qty] ]
         }
 
         it { should eq(expected) }
       end
 
       context 'when a key is projected due to a constant restriction' do
+        # 1, 1, 1
+        # 1, 2, 3
         let(:operand){
           an_operand.with_heading(sid: Integer, pid: Integer)
                     .with_keys([:sid, :pid])
         }
+        # 1, _, 1
         let(:op){
-          a_lispy.project(a_lispy.restrict(operand, sid: 1), [:pid])
+          a_lispy.project(a_lispy.restrict(operand, pid: 1), [:sid, :qty])
         }
         let(:expected){
-          Keys[ [:pid] ]
+          Keys[ [:sid] ]
         }
 
         it { should eq(expected) }
       end
 
+      context 'when a projection leads to an empty key' do
+        ## 1, Jones
+        let(:operand){
+          an_operand.with_heading(sid: Integer, name: String)
+                    .with_keys([:sid])
+        }
+        let(:op){
+          a_lispy.project(a_lispy.restrict(operand, sid: 1), [:sid])
+        }
+
+        it { should eq(Keys[[]]) }
+      end
+
     end
   end
 end

data/spec/unit/alf-algebra/operator/rank/test_keys.rb

@@ -4,7 +4,7 @@ module Alf
     describe Rank, 'keys' do
 
       let(:operand){
-        an_operand.with_heading(:id => Integer, :name => String).with_keys([:id])
+        an_operand.with_heading(id: Integer, name: String, hobby: Tuple[name: String]).with_keys([:id])
       }
 
       subject{ op.keys }
@@ -22,7 +22,7 @@ module Alf
 
       context 'when the order relation does contain a key' do
         let(:op){ 
-          a_lispy.rank(operand, [[:name, :asc], [:id, :desc]], :rank)
+          a_lispy.rank(operand, [[[:hobby, :name], :asc], [:id, :desc]], :rank)
         }
         let(:expected){
           Keys[ [:id], [:rank] ]

data/spec/unit/alf-algebra/operator/restrict/test_keys.rb

@@ -24,7 +24,7 @@ module Alf
           an_operand.with_heading(id: Fixnum, name: String).with_keys([:id, :name])
         }
         let(:op){
-          a_lispy.restrict(operand, Predicate.eq(:id, 12))
+          a_lispy.restrict(operand, id: 12)
         }
         let(:expected){
           Keys[ [:name] ]
@@ -38,7 +38,7 @@ module Alf
           an_operand.with_heading(id: Fixnum, name: String).with_keys([:id, :name])
         }
         let(:op){
-          a_lispy.restrict(operand, Predicate.eq(:id, 12) & Predicate.eq(:name, "Smith"))
+          a_lispy.restrict(operand, id: 12, name: "Smith")
         }
         let(:expected){
           Keys[ [] ]

data/spec/unit/alf-algebra/operator/test_page.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module Alf
+  module Algebra
+    describe Page do
+
+      let(:operator_class){ Page }
+
+      it_should_behave_like("An operator class")
+
+      subject{
+        a_lispy.page(an_operand, [[:name, :asc]], 2)
+      }
+
+      it { should be_a(Page) }
+
+      it 'should have correct ordering' do
+        subject.ordering.should eq(Ordering.coerce([[:name, :asc]]))
+      end
+
+      it 'should have correct page index' do
+        subject.page_index.should eq(2)
+      end
+
+      it 'should have default page size' do
+        subject.page_size.should eq(25)
+      end
+
+    end
+  end
+end

data/spec/unit/alf-algebra/support/test_relational.rb

@@ -8,13 +8,16 @@ module Alf
         Relational.each{|m| x << m}
         x.sort{|m1,m2| m1.name.to_s <=> m2.name.to_s}.should == [
           Extend,
+          Frame,
           Group,
+          Hierarchize,
           InferHeading,
           Intersect,
           Join,
           Matching,
           Minus,
           NotMatching,
+          Page,
           Project,
           Quota,
           Rank,

data/spec/unit/alf-algebra/support/with_ordering/test_total_ordering.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+module Alf
+  module Algebra
+    describe WithOrdering, 'total_ordering' do
+      include WithOrdering
+
+      subject{ total_ordering }
+
+      def keys
+        operand.keys
+      end
+
+      def heading
+        operand.heading
+      end
+
+      context 'when the initial ordering covers a key' do
+        let(:operand){
+          an_operand.with_heading(id: Fixnum, name: String).with_keys([:id])
+        }
+        let(:ordering){
+          Ordering.new([[:id, :desc]])
+        }
+        let(:expected){
+          Ordering.new([[:id, :desc]])
+        }
+
+        it { should eq(expected) }
+      end
+
+      context 'when the initial ordering does not cover a key' do
+        let(:operand){
+          an_operand.with_heading(id: Fixnum, name: String).with_keys([:id, :name])
+        }
+        let(:ordering){
+          Ordering.new([[:name, :desc]])
+        }
+        let(:expected){
+          Ordering.new([[:name, :desc], [:id, :asc]])
+        }
+
+        it { should eq(expected) }
+      end
+
+      context 'when no key' do
+        let(:operand){
+          an_operand.with_heading(id: Fixnum, name: String)
+        }
+        let(:ordering){
+          Ordering.new([[:name, :desc]])
+        }
+        let(:expected){
+          Ordering.new([[:name, :desc], [:id, :asc]])
+        }
+
+        it { should eq(expected) }
+      end
+
+    end
+  end
+end

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

@@ -28,7 +28,7 @@ module Alf
       end
 
       context 'when only logical options are changed' do
-        let(:opts){ {default_viewpoint: Viewpoint::NATIVE} }
+        let(:opts){ {viewpoint: Viewpoint::NATIVE} }
 
         it 'should not close the underlying connection' do
           subject

data/spec/unit/alf-database/options/test_new.rb

@@ -7,12 +7,12 @@ module Alf
 
       subject{ Options.new(h) }
 
-      context 'when valid, coercable options with default_viewpoint' do
-        let(:h){ {schema_cache: "false", default_viewpoint: viewpoint} }
+      context 'when valid, coercable options with viewpoint' do
+        let(:h){ {schema_cache: "false", viewpoint: viewpoint} }
 
         it 'sets the options as expected' do
           subject.schema_cache?.should eq(false)
-          subject.default_viewpoint.should be(viewpoint)
+          subject.viewpoint.should be(viewpoint)
           subject.viewpoint.should be(viewpoint)
         end
       end
@@ -22,7 +22,7 @@ module Alf
 
         it 'sets the options as expected' do
           subject.schema_cache?.should eq(false)
-          subject.default_viewpoint.should be(viewpoint)
+          subject.viewpoint.should be(viewpoint)
           subject.viewpoint.should be(viewpoint)
         end
       end

data/spec/unit/alf-database/shared_examples/a_facade_on_database_options.rb

@@ -1,6 +1,5 @@
 shared_examples_for "a facade on database options" do
 
   it{ should respond_to(:schema_cache?)     }
-  it{ should respond_to(:default_viewpoint) }
 
-end
+end

data/spec/unit/alf-engine/cog/test_to_cog.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Alf
+  module Engine
+    describe Cog, "to_cog" do
+
+      let(:cog){ Object.new.extend(Cog) }
+
+      subject{ cog.to_cog }
+
+      it { should be(cog) }
+
+    end
+  end
+end

data/spec/unit/alf-engine/compiler/test_on_frame.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+module Alf
+  module Engine
+    describe Compiler, 'test_on_frame' do
+
+      subject{ Compiler.new.call(expr) }
+
+      shared_examples_for "a traceable take" do
+        it_should_behave_like "a traceable cog"
+
+        it {
+          should be_a(Engine::Take)
+        }
+      end
+
+      context 'when keys are known and a positive index' do
+        let(:operand){
+          an_operand.with_heading(id: Fixnum, name: String).with_keys([:id])
+        }
+        let(:expr){
+          a_lispy.frame(operand, [], 3, 8)
+        }
+
+        it_should_behave_like "a traceable take"
+
+        it 'should have correct offset' do
+          subject.offset.should eq(3)
+        end
+
+        it 'should have correct limit' do
+          subject.limit.should eq(8)
+        end
+
+        it 'should have a sort as child' do
+          subject.operand.should be_a(Engine::Sort)
+          subject.operand.ordering.should eq(Ordering.new([[:id, :asc]]))
+        end
+
+        it 'should have a leaf as child.child' do
+          subject.operand.operand.should be_a(Leaf)
+        end
+      end
+
+      context 'when keys and heading are not supported' do
+        let(:operand){
+          an_operand
+        }
+        let(:expr){
+          a_lispy.frame(operand, [[:id, :asc]], 3, 8)
+        }
+
+        it_should_behave_like "a traceable take"
+
+        it 'should have correct offset' do
+          subject.offset.should eq(3)
+        end
+
+        it 'should have correct limit' do
+          subject.limit.should eq(8)
+        end
+
+        it 'should have a sort as child and stick to initial ordering' do
+          subject.operand.should be_a(Engine::Sort)
+          subject.operand.ordering.should eq(Ordering.new([[:id, :asc]]))
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-engine/compiler/test_on_hierarchize.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+module Alf
+  module Engine
+    describe Compiler, 'test_on_hierarchize' do
+
+      subject{ Compiler.new.call(expr) }
+
+      context 'the normal case' do
+        let(:operand){
+          an_operand.with_heading(id: Fixnum, parent: Integer).with_keys([:id])
+        }
+        let(:expr){
+          a_lispy.hierarchize(operand, :id, :parent, :as)
+        }
+
+        it{ should be_a(Engine::Hierarchize) }
+
+        it 'should have correct id list' do
+          subject.id.should eq(AttrList[:id])
+        end
+
+        it 'should have correct parent list' do
+          subject.parent.should eq(AttrList[:parent])
+        end
+
+        it 'should have correct children name' do
+          subject.children.should eq(:as)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-engine/compiler/test_on_page.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+module Alf
+  module Engine
+    describe Compiler, 'test_on_page' do
+
+      subject{ Compiler.new.call(expr) }
+
+      shared_examples_for "a traceable take" do
+        it_should_behave_like "a traceable cog"
+
+        it {
+          should be_a(Engine::Take)
+        }
+      end
+
+      context 'when keys are known and a positive index' do
+        let(:operand){
+          an_operand.with_heading(id: Fixnum, name: String).with_keys([:id])
+        }
+        let(:expr){
+          a_lispy.page(operand, [], 3, page_size: 8)
+        }
+
+        it_should_behave_like "a traceable take"
+
+        it 'should have correct offset' do
+          subject.offset.should eq(16)
+        end
+
+        it 'should have correct limit' do
+          subject.limit.should eq(8)
+        end
+
+        it 'should have a sort as child' do
+          subject.operand.should be_a(Engine::Sort)
+          subject.operand.ordering.should eq(Ordering.new([[:id, :asc]]))
+        end
+
+        it 'should have a leaf as child.child' do
+          subject.operand.operand.should be_a(Leaf)
+        end
+      end
+
+      context 'when keys are known and a page 1' do
+        let(:operand){
+          an_operand.with_heading(id: Fixnum, name: String).with_keys([:id])
+        }
+        let(:expr){
+          a_lispy.page(operand, [], 1)
+        }
+
+        it_should_behave_like "a traceable take"
+
+        it 'should have offset 0' do
+          subject.offset.should eq(0)
+        end
+      end
+
+      context 'when keys are known and a negative index' do
+        let(:operand){
+          an_operand.with_heading(id: Fixnum, name: String).with_keys([:id])
+        }
+        let(:expr){
+          a_lispy.page(operand, [], -3, page_size: 8)
+        }
+
+        it_should_behave_like "a traceable take"
+
+        it 'should have correct offset' do
+          subject.offset.should eq(16)
+        end
+
+        it 'should have correct limit' do
+          subject.limit.should eq(8)
+        end
+
+        it 'should have a sort with inverse ordering as child' do
+          subject.operand.should be_a(Engine::Sort)
+          subject.operand.ordering.should eq(Ordering.new([[:id, :desc]]))
+        end
+
+        it 'should have a leaf as child.child' do
+          subject.operand.operand.should be_a(Leaf)
+        end
+      end
+
+      context 'when keys are known and a page -1' do
+        let(:operand){
+          an_operand.with_heading(id: Fixnum, name: String).with_keys([:id])
+        }
+        let(:expr){
+          a_lispy.page(operand, [], -1)
+        }
+
+        it_should_behave_like "a traceable take"
+
+        it 'should have offset 0' do
+          subject.offset.should eq(0)
+        end
+      end
+
+      context 'when keys and heading are not supported' do
+        let(:operand){
+          an_operand
+        }
+        let(:expr){
+          a_lispy.page(operand, [[:id, :asc]], 3, page_size: 8)
+        }
+
+        it_should_behave_like "a traceable take"
+
+        it 'should have correct offset' do
+          subject.offset.should eq(16)
+        end
+
+        it 'should have correct limit' do
+          subject.limit.should eq(8)
+        end
+
+        it 'should have a sort as child and stick to initial ordering' do
+          subject.operand.should be_a(Engine::Sort)
+          subject.operand.ordering.should eq(Ordering.new([[:id, :asc]]))
+        end
+      end
+
+    end
+  end
+end