veritas-optimizer 0.0.3

data/spec/integration/veritas/algebra/union/optimize_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+
+describe Algebra::Union, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)         { [ [ :id, Integer ] ]             }
+  let(:left_body)      { [ [ 1 ] ].each                   }
+  let(:right_body)     { [ [ 2 ] ].each                   }
+  let(:original_left)  { Relation.new(header, left_body)  }
+  let(:original_right) { Relation.new(header, right_body) }
+  let(:object)         { described_class.new(left, right) }
+
+  context 'left is an empty relation' do
+    let(:left)  { Relation::Empty.new(header) }
+    let(:right) { original_right              }
+
+    it { should equal(right) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute left_body#each' do
+      left_body.should_not_receive(:each)
+      subject
+    end
+
+    it 'does not execute right_body#each' do
+      right_body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'right is an empty relation' do
+    let(:left)  { original_left               }
+    let(:right) { Relation::Empty.new(header) }
+
+    it { should equal(left) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute left_body#each' do
+      left_body.should_not_receive(:each)
+      subject
+    end
+
+    it 'does not execute right_body#each' do
+      right_body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is an empty relation when optimized' do
+    let(:left)  { Algebra::Restriction.new(original_left, Logic::Proposition::Contradiction.instance) }
+    let(:right) { original_right                                                                      }
+
+    it { should equal(right) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute left_body#each' do
+      left_body.should_not_receive(:each)
+      subject
+    end
+
+    it 'does not execute right_body#each' do
+      right_body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'right is an empty relation when optimized' do
+    let(:left)  { original_left                                                                        }
+    let(:right) { Algebra::Restriction.new(original_right, Logic::Proposition::Contradiction.instance) }
+
+    it { should equal(left) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute left_body#each' do
+      left_body.should_not_receive(:each)
+      subject
+    end
+
+    it 'does not execute right_body#each' do
+      right_body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are equivalent relations' do
+    let(:left_body)  { [ [ 1 ] ].each }
+    let(:right_body) { [ [ 1 ] ].each }
+    let(:left)       { original_left  }
+    let(:right)      { original_right }
+
+    it { should equal(left) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute left_body#each' do
+      pending 'TODO: should only compare left and right with #eql? if they are materialized' do
+        left_body.should_not_receive(:each)
+        subject
+      end
+    end
+
+    it 'does not execute right_body#each' do
+      pending 'TODO: should only compare left and right with #eql? if they are materialized' do
+        right_body.should_not_receive(:each)
+        subject
+      end
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are equivalent materialized relations' do
+    let(:left_body)  { [ [ 1 ] ]      }
+    let(:right_body) { [ [ 1 ] ]      }
+    let(:left)       { original_left  }
+    let(:right)      { original_right }
+
+    it { should equal(left) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'executes left_body#each' do
+      pending 'only receive #each once'
+      left_body.should_receive(:each)
+      subject
+    end
+
+    it 'executes right_body#each' do
+      pending 'only receive #each once'
+      right_body.should_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are not empty relations' do
+    let(:left)  { original_left  }
+    let(:right) { original_right }
+
+    it { should equal(object) }
+
+    it 'executes left_body#each' do
+      left_body.should_receive(:each)
+      subject
+    end
+
+    it 'executes right_body#each' do
+      right_body.should_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are materialized relations' do
+    let(:left)  { Relation.new(header, [ [ 1 ], [ 2 ] ]) }
+    let(:right) { Relation.new(header, [ [ 1 ] ])        }
+
+    it { should eql(Relation::Materialized.new(header, [ [ 1 ], [ 2 ] ])) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+end

data/spec/integration/veritas/logic/connective/conjunction/optimize_spec.rb

@@ -0,0 +1,234 @@
+require 'spec_helper'
+
+describe Logic::Connective::Conjunction, '#optimize' do
+  subject { object.optimize }
+
+  let(:attribute) { Attribute::Integer.new(:id)      }
+  let(:object)    { described_class.new(left, right) }
+
+  it_should_behave_like 'Logic::Connective::Binary#optimize'
+
+  context 'left and right are predicates' do
+    let(:left)  { attribute.gt(1) }
+    let(:right) { attribute.lt(3) }
+
+    it { should equal(object) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are inverse predicates' do
+    let(:left)  { Logic::Connective::Negation.new(attribute.gt(1)) }
+    let(:right) { Logic::Connective::Negation.new(attribute.lt(3)) }
+
+    it { should_not equal(object) }
+
+    it 'reverses the operands' do
+      should eql(described_class.new(attribute.lte(1), attribute.gte(3)))
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are the same' do
+    let(:left)  { attribute.gt(1) }
+    let(:right) { attribute.gt(1) }
+
+    it { should eql(left) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are tautologys' do
+    let(:left)  { Logic::Proposition::Tautology.instance }
+    let(:right) { Logic::Proposition::Tautology.instance }
+
+    it { should equal(Logic::Proposition::Tautology.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are contradictions' do
+    let(:left)  { Logic::Proposition::Contradiction.instance }
+    let(:right) { Logic::Proposition::Contradiction.instance }
+
+    it { should equal(Logic::Proposition::Contradiction.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'right is a tautology' do
+    let(:left)  { attribute.gt(1)                        }
+    let(:right) { Logic::Proposition::Tautology.instance }
+
+    it { should equal(left) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is a tautology' do
+    let(:left)  { Logic::Proposition::Tautology.instance }
+    let(:right) { attribute.lt(3)                        }
+
+    it { should equal(right) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'right is a contradiction' do
+    let(:left)  { attribute.gt(1)                            }
+    let(:right) { Logic::Proposition::Contradiction.instance }
+
+    it { should equal(Logic::Proposition::Contradiction.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is a contradiction' do
+    let(:left)  { Logic::Proposition::Contradiction.instance }
+    let(:right) { attribute.lt(3)                            }
+
+    it { should equal(Logic::Proposition::Contradiction.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are Equality predicates for the same attribute and different values' do
+    let(:left)  { attribute.eq(1) }
+    let(:right) { attribute.eq(3) }
+
+    it { should equal(Logic::Proposition::Contradiction.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are Inequality predicates for the same attribute and different values' do
+    let(:left)  { attribute.ne(1) }
+    let(:right) { attribute.ne(3) }
+
+    it { should eql(attribute.exclude([ 1, 3 ])) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is an Equality and right is an Inequality predicate for the same attribute and value' do
+    let(:left)  { attribute.eq(1) }
+    let(:right) { attribute.ne(1) }
+
+    it { should equal(Logic::Proposition::Contradiction.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is an Inequality and right is an Equality predicate for the same attribute and value' do
+    let(:left)  { attribute.ne(1) }
+    let(:right) { attribute.eq(1) }
+
+    it { should equal(Logic::Proposition::Contradiction.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is an Inclusion and right is an Exclusion predicate for the same attribute and value' do
+    let(:left)  { attribute.include([ 1, 2 ]) }
+    let(:right) { attribute.exclude([ 1, 2 ]) }
+
+    it { should equal(Logic::Proposition::Contradiction.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is an Exclusion and right is an Inclusion predicate for the same attribute and value' do
+    let(:left)  { attribute.exclude([ 1, 2 ]) }
+    let(:right) { attribute.include([ 1, 2 ]) }
+
+    it { should equal(Logic::Proposition::Contradiction.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is a GreaterThan and right is a LessThanOrEqualTo predicate for the same attribute and value' do
+    let(:left)  { attribute.gt(1)  }
+    let(:right) { attribute.lte(1) }
+
+    it { should equal(Logic::Proposition::Contradiction.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is an LessThanOrEqualTo and right is an GreaterThan predicate for the same attribute and value' do
+    let(:left)  { attribute.lte(1) }
+    let(:right) { attribute.gt(1)  }
+
+    it { should equal(Logic::Proposition::Contradiction.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is a GreaterThanOrEqualTo and right is a LessThan predicate for the same attribute and value' do
+    let(:left)  { attribute.gte(1) }
+    let(:right) { attribute.lt(1)  }
+
+    it { should equal(Logic::Proposition::Contradiction.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is an LessThan and right is an GreaterThanOrEqualTo predicate for the same attribute and value' do
+    let(:left)  { attribute.lt(1)  }
+    let(:right) { attribute.gte(1) }
+
+    it { should equal(Logic::Proposition::Contradiction.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is a Match and right is a NoMatch predicate for the same attribute and value' do
+    let(:attribute) { Attribute::String.new(:name)   }
+    let(:left)      { attribute.match(/Dan Kubb/)    }
+    let(:right)     { attribute.no_match(/Dan Kubb/) }
+
+    it { should equal(Logic::Proposition::Contradiction.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is an NoMatch and right is an Match predicate for the same attribute and value' do
+    let(:attribute) { Attribute::String.new(:name)   }
+    let(:left)      { attribute.no_match(/Dan Kubb/) }
+    let(:right)     { attribute.match(/Dan Kubb/)    }
+
+    it { should equal(Logic::Proposition::Contradiction.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are predicates for the same attribute and the same values' do
+    let(:left)  { attribute.eq(1) }
+    let(:right) { attribute.eq(1) }
+
+    it { should eql(attribute.eq(1)) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are predicates for the same attribute, but left.right is an attribute' do
+    let(:other) { Attribute::Integer.new(:other_id) }
+    let(:left)  { attribute.eq(other)               }
+    let(:right) { attribute.eq(1)                   }
+
+    it { should equal(object) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are predicates for the same attribute, but right.right is an attribute' do
+    let(:other) { Attribute::Integer.new(:other_id) }
+    let(:left)  { attribute.eq(1)                   }
+    let(:right) { attribute.eq(other)               }
+
+    it { should equal(object) }
+
+    it_should_behave_like 'an optimize method'
+  end
+end

data/spec/integration/veritas/logic/connective/disjunction/optimize_spec.rb

@@ -0,0 +1,235 @@
+require 'spec_helper'
+
+describe Logic::Connective::Disjunction, '#optimize' do
+  subject { object.optimize }
+
+  let(:attribute) { Attribute::Integer.new(:id)      }
+  let(:object)    { described_class.new(left, right) }
+
+  it_should_behave_like 'Logic::Connective::Binary#optimize'
+
+  context 'left and right are predicates' do
+    let(:left)  { attribute.gt(1) }
+    let(:right) { attribute.lt(3) }
+
+    it { should equal(object) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are inverse predicates' do
+    let(:left)  { Logic::Connective::Negation.new(attribute.gt(1)) }
+    let(:right) { Logic::Connective::Negation.new(attribute.lt(3)) }
+
+    it { should_not equal(object) }
+
+    it 'reverses the operands' do
+      should eql(Logic::Connective::Disjunction.new(attribute.lte(1), attribute.gte(3)))
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are the same' do
+    let(:left)  { attribute.gt(1) }
+    let(:right) { attribute.gt(1) }
+
+    it { should equal(left) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are tautologys' do
+    let(:left)  { Logic::Proposition::Tautology.instance }
+    let(:right) { Logic::Proposition::Tautology.instance }
+
+    it { should equal(left) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are contradictions' do
+    let(:left)  { Logic::Proposition::Contradiction.instance }
+    let(:right) { Logic::Proposition::Contradiction.instance }
+
+
+    it { should equal(left) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'right is a tautology' do
+    let(:left)  { attribute.gt(1)                        }
+    let(:right) { Logic::Proposition::Tautology.instance }
+
+    it { should equal(right) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is a tautology' do
+    let(:left)  { Logic::Proposition::Tautology.instance }
+    let(:right) { attribute.lt(3)                        }
+
+    it { should equal(left) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'right is a contradiction' do
+    let(:left)  { attribute.gt(1)                            }
+    let(:right) { Logic::Proposition::Contradiction.instance }
+
+    it { should equal(left) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is a contradiction' do
+    let(:left)  { Logic::Proposition::Contradiction.instance }
+    let(:right) { attribute.lt(3)                            }
+
+    it { should equal(right) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are Equality predicates for the same attribute and different values' do
+    let(:left)  { attribute.eq(1) }
+    let(:right) { attribute.eq(3) }
+
+    it { should eql(attribute.include([ 1, 3 ])) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are Inequality predicates for the same attribute and different values' do
+    let(:left)  { attribute.ne(1) }
+    let(:right) { attribute.ne(3) }
+
+    it { should equal(Logic::Proposition::Tautology.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is an Equality and right is an Inequality predicate for the same attribute and value' do
+    let(:left)  { attribute.eq(1) }
+    let(:right) { attribute.ne(1) }
+
+    it { should equal(Logic::Proposition::Tautology.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is an Inequality and right is an Equality predicate for the same attribute and value' do
+    let(:left)  { attribute.ne(1) }
+    let(:right) { attribute.eq(1) }
+
+    it { should equal(Logic::Proposition::Tautology.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is an Inclusion and right is an Exclusion predicate for the same attribute and value' do
+    let(:left)  { attribute.include([ 1, 2 ]) }
+    let(:right) { attribute.exclude([ 1, 2 ]) }
+
+    it { should equal(Logic::Proposition::Tautology.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is an Exclusion and right is an Inclusion predicate for the same attribute and value' do
+    let(:left)  { attribute.exclude([ 1, 2 ]) }
+    let(:right) { attribute.include([ 1, 2 ]) }
+
+    it { should equal(Logic::Proposition::Tautology.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is a GreaterThan and right is a LessThanOrEqualTo predicate for the same attribute and value' do
+    let(:left)  { attribute.gt(1)  }
+    let(:right) { attribute.lte(1) }
+
+    it { should equal(Logic::Proposition::Tautology.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is an LessThanOrEqualTo and right is an GreaterThan predicate for the same attribute and value' do
+    let(:left)  { attribute.lte(1) }
+    let(:right) { attribute.gt(1)  }
+
+    it { should equal(Logic::Proposition::Tautology.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is a GreaterThanOrEqualTo and right is a LessThan predicate for the same attribute and value' do
+    let(:left)  { attribute.gte(1) }
+    let(:right) { attribute.lt(1)  }
+
+    it { should equal(Logic::Proposition::Tautology.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is an LessThan and right is an GreaterThanOrEqualTo predicate for the same attribute and value' do
+    let(:left)  { attribute.lt(1)  }
+    let(:right) { attribute.gte(1) }
+
+    it { should equal(Logic::Proposition::Tautology.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is a Match and right is a NoMatch predicate for the same attribute and value' do
+    let(:attribute) { Attribute::String.new(:name)   }
+    let(:left)      { attribute.match(/Dan Kubb/)    }
+    let(:right)     { attribute.no_match(/Dan Kubb/) }
+
+    it { should equal(Logic::Proposition::Tautology.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is an NoMatch and right is an Match predicate for the same attribute and value' do
+    let(:attribute) { Attribute::String.new(:name)   }
+    let(:left)      { attribute.no_match(/Dan Kubb/) }
+    let(:right)     { attribute.match(/Dan Kubb/)    }
+
+    it { should equal(Logic::Proposition::Tautology.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are predicates for the same attribute and the same values' do
+    let(:left)  { attribute.eq(1) }
+    let(:right) { attribute.eq(1) }
+
+    it { should eql(attribute.eq(1)) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are predicates for the same attribute, but left.right is an attribute' do
+    let(:other) { Attribute::Integer.new(:other_id) }
+    let(:left)  { attribute.eq(other)               }
+    let(:right) { attribute.eq(1)                   }
+
+    it { should equal(object) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are predicates for the same attribute, but right.right is an attribute' do
+    let(:other) { Attribute::Integer.new(:other_id) }
+    let(:left)  { attribute.eq(1)                   }
+    let(:right) { attribute.eq(other)               }
+
+    it { should equal(object) }
+
+    it_should_behave_like 'an optimize method'
+  end
+end

data/spec/integration/veritas/logic/connective/negation/optimize_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Logic::Connective::Negation, '#optimize' do
+  subject { object.optimize }
+
+  let(:attribute) { Attribute::Integer.new(:id)  }
+  let(:object)    { described_class.new(operand) }
+
+  context 'operand is a predicate' do
+    let(:operand) { attribute.gt(1) }
+
+    it { should eql(attribute.lte(1)) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'operand is a objected predicate' do
+    let(:predicate) { attribute.gt(1)                }
+    let(:operand)   { described_class.new(predicate) }
+
+    it { should eql(predicate) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'operand is a tautology' do
+    let(:operand) { Logic::Proposition::Tautology.instance }
+
+    it { should equal(Logic::Proposition::Contradiction.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'operand is a contradiction' do
+    let(:operand) { Logic::Proposition::Contradiction.instance }
+
+    it { should equal(Logic::Proposition::Tautology.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+end