alf-core 0.15.0 → 0.16.0

data/spec/unit/alf-lang/parser/safer/unsafe.txt

@@ -1,14 +0,0 @@
-`ls -lA`
-::Kernel
-exit
-require "blah"
-load "blah"
-gem 'unsecure'
-suppliers.to_relvar
-suppliers.insert
-suppliers.delete
-suppliers.update
-Alf::Adapter::Connection
-Alf.connect
-Relation.new
-Tuple.new

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

@@ -1,17 +0,0 @@
-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_search.rb

@@ -1,48 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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), :auto) }
-      
-        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

@@ -1,42 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

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

@@ -1,46 +0,0 @@
-shared_examples_for "a split-able expression for restrict" do
-
-  let(:split_pred){
-    Alf::Predicate.eq(split_attributes.to_a.first, 12)
-  }
-  let(:stay_pred){
-    Alf::Predicate.eq(:a_non_split_attribute, 12)
-  }
-
-  context 'with a native predicate' do
-    let(:predicate){ Alf::Predicate.native(lambda{ true }) }
-
-    it_should_behave_like "an unoptimizable expression for restrict"
-  end
-
-  context 'with no split attributes' do
-    let(:predicate){ stay_pred }
-
-    it_should_behave_like "a pass-through expression for restrict"
-  end
-
-  context 'with only split attributes' do
-    let(:predicate){ split_pred }
-
-    it_should_behave_like "an unoptimizable expression for restrict"
-  end
-
-  context 'with split and non-split in a OR' do
-    let(:predicate){ split_pred | stay_pred }
-
-    it_should_behave_like "an unoptimizable expression for restrict"
-  end
-
-  context 'with split and non-split in a COMP' do
-    let(:predicate){ split_pred & stay_pred }
-
-    it_should_behave_like "an optimizable expression for restrict"
-  end
-
-  context 'with split and non-split in the same EXPR' do
-    let(:predicate){ Alf::Predicate.eq(split_attributes.to_a.first, :a_non_split_attribute) }
-
-    it_should_behave_like "an unoptimizable expression for restrict"
-  end
-
-end

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

@@ -1,39 +0,0 @@
-shared_examples_for "an optimizable expression for restrict" do
-
-  let(:restriction){
-    restrict(subject, predicate)
-  }
-
-  let(:optimized){
-    Alf::Optimizer::Restrict.new.call(restriction)
-  }
-
-  let(:middle){
-    optimized.operand
-  }
-
-  let(:inside){
-    middle.operand
-  }
-
-  # before(:all) do
-  #   puts "\n--------"
-  #   puts Support.to_lispy(restriction)
-  #   puts Support.to_lispy(optimized)
-  # end
-
-  specify "optimized leads to a restrict[initial[restrict[...]]]" do
-    optimized.should be_a(Alf::Algebra::Restrict)
-    middle.should be_a(subject.class)
-    inside.should be_a(Alf::Algebra::Restrict)
-  end
-
-  specify "middle's signature is kept unchanged" do
-    middle.signature.collect_on(subject).should eq(subject.signature.collect_on(subject))
-  end
-
-  specify "first restriction only applies on split attributes" do
-    optimized.predicate.free_variables.should eq(split_attributes)
-  end
-
-end

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

@@ -1,24 +0,0 @@
-shared_examples_for "an unoptimizable expression for restrict" do
-
-  let(:the_predicate){
-    defined?(predicate) ? predicate : Alf::Predicate.eq(:x, 12)
-  }
-
-  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 is unchanged" do
-    optimized.should eq(restriction)
-  end
-
-end