veritas 0.0.1

data/lib/veritas/optimizer/algebra/difference.rb

@@ -0,0 +1,64 @@
+module Veritas
+  class Optimizer
+    module Algebra
+
+      # Abstract base class representing Difference optimizations
+      class Difference < Relation::Operation::Binary
+
+        # Optimize when operands are equal
+        class EqualOperands < self
+          include Relation::Operation::Binary::EqualOperands
+
+          # A Difference with equal operands is empty
+          #
+          # @return [Relation::Empty]
+          #
+          # @api private
+          def optimize
+            Veritas::Relation::Empty.new(operation.header)
+          end
+
+        end # class EqualOperands
+
+        # Optimize when the left operand is empty
+        class EmptyLeft < self
+          include Relation::Operation::Binary::EmptyLeft
+
+          # A Difference with an empty left operand is empty
+          #
+          # @return [Relation::Empty]
+          #
+          # @api private
+          def optimize
+            left
+          end
+
+        end # class EmptyLeft
+
+        # Optimize when the right operand is empty
+        class EmptyRight < self
+          include Relation::Operation::Binary::EmptyRight
+
+          # A Difference with an empty right operand is equivalent to the left
+          #
+          # @return [Relation]
+          #
+          # @api private
+          def optimize
+            left
+          end
+
+        end # class EmptyRight
+
+        Veritas::Algebra::Difference.optimizer = chain(
+          EqualOperands,
+          EmptyLeft,
+          EmptyRight,
+          MaterializedOperand,
+          UnoptimizedOperand
+        )
+
+      end # class Difference
+    end # module Algebra
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/algebra/extension.rb

@@ -0,0 +1,40 @@
+module Veritas
+  class Optimizer
+    module Algebra
+
+      # Abstract base class representing Extension optimizations
+      class Extension < Relation::Operation::Unary
+
+        # Optimize when operands are optimizable
+        class UnoptimizedOperand < self
+
+          # Test if the operand is unoptimized
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            !operand.equal?(operation.operand)
+          end
+
+          # Return an Extension with an optimized operand
+          #
+          # @return [Algebra::Extension]
+          #
+          # @api private
+          def optimize
+            operation = self.operation
+            operation.class.new(operand, operation.extensions)
+          end
+
+        end # class UnoptimizedOperand
+
+        Veritas::Algebra::Extension.optimizer = chain(
+          MaterializedOperand,
+          UnoptimizedOperand
+        )
+
+      end # class Extension
+    end # module Algebra
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/algebra/intersection.rb

@@ -0,0 +1,64 @@
+module Veritas
+  class Optimizer
+    module Algebra
+
+      # Abstract base class representing Intersection optimizations
+      class Intersection < Relation::Operation::Binary
+
+        # Optimize when operands are equal
+        class EqualOperands < self
+          include Relation::Operation::Binary::EqualOperands
+
+          # An Intersection with equal operands is equivalent to either operand
+          #
+          # @return [Relation]
+          #
+          # @api private
+          def optimize
+            left
+          end
+
+        end # class EqualOperands
+
+        # Optimize when the left operand is empty
+        class EmptyLeft < self
+          include Relation::Operation::Binary::EmptyLeft
+
+          # An Intersection with an empty left operand is empty
+          #
+          # @return [Relation::Empty]
+          #
+          # @api private
+          def optimize
+            left
+          end
+
+        end # class EmptyLeft
+
+        # Optimize when the right operand is empty
+        class EmptyRight < self
+          include Relation::Operation::Binary::EmptyRight
+
+          # An Intersection with an empty right operand is empty
+          #
+          # @return [Relation::Empty]
+          #
+          # @api private
+          def optimize
+            right
+          end
+
+        end # class EmptyRight
+
+        Veritas::Algebra::Intersection.optimizer = chain(
+          EqualOperands,
+          EmptyLeft,
+          EmptyRight,
+          MaterializedOperand,
+          UnoptimizedOperand
+        )
+
+      end # class Intersection
+    end # module Algebra
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/algebra/join.rb

@@ -0,0 +1,42 @@
+module Veritas
+  class Optimizer
+    module Algebra
+
+      # Abstract base class representing Join optimizations
+      class Join < Relation::Operation::Combine
+
+        # Optimize when operand headers are equivalent
+        class EqualHeaders < self
+
+          # Test if the operands' headers are equal
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            left.header.eql?(right.header)
+          end
+
+          # A Join with equal headers is an Intersection
+          #
+          # @return [Algebra::Intersection]
+          #
+          # @api private
+          def optimize
+            Veritas::Algebra::Intersection.new(left, right)
+          end
+
+        end # class EqualHeaders
+
+        Veritas::Algebra::Join.optimizer = chain(
+          EmptyLeft,
+          EmptyRight,
+          EqualHeaders,
+          MaterializedOperand,
+          UnoptimizedOperand
+        )
+
+      end # class Join
+    end # module Algebra
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/algebra/product.rb

@@ -0,0 +1,68 @@
+module Veritas
+  class Optimizer
+    module Algebra
+
+      # Abstract base class representing Product optimizations
+      class Product < Relation::Operation::Combine
+
+        # Optimize when left operand is a TABLE DEE
+        class TableDeeLeft < self
+
+          # Test if the left operand is a TABLE DEE
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            left = self.left
+            left.header.empty? && !left.kind_of?(Veritas::Relation::Empty)
+          end
+
+          # A Product wih a left TABLE DEE is equivalent to the right operand
+          #
+          # @return [Relation]
+          #
+          # @api private
+          def optimize
+            right
+          end
+
+        end # class TableDeeLeft
+
+        # Optimize when right operand is a TABLE DEE
+        class TableDeeRight < self
+
+          # Test if the right operand is a TABLE DEE
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            right = self.right
+            right.header.empty? && !right.kind_of?(Veritas::Relation::Empty)
+          end
+
+          # A Product wih a right TABLE DEE is equivalent to the left operand
+          #
+          # @return [Relation]
+          #
+          # @api private
+          def optimize
+            left
+          end
+
+        end # class TableDeeRight
+
+        Veritas::Algebra::Product.optimizer = chain(
+          TableDeeLeft,
+          TableDeeRight,
+          EmptyLeft,
+          EmptyRight,
+          MaterializedOperand,
+          UnoptimizedOperand
+        )
+
+      end # class Product
+    end # module Algebra
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/algebra/projection.rb

@@ -0,0 +1,172 @@
+module Veritas
+  class Optimizer
+    module Algebra
+
+      # Abstract base class representing Projection optimizations
+      class Projection < Relation::Operation::Unary
+
+        # The projected header
+        #
+        # @return [Header]
+        #
+        # @api private
+        attr_reader :header
+
+        # Initialize an Projection optimizer
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(*)
+          super
+          @header = operation.header
+        end
+
+        # Optimize when the headers are not changed
+        class UnchangedHeader < self
+
+          # Test if the projected headers are the same as the operand's
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            header.to_a == operand.header.to_a
+          end
+
+          # A Projection with unchanged headers is a noop
+          #
+          # @return [Relation]
+          #
+          # @api private
+          def optimize
+            operand
+          end
+
+        end # class UnchangedHeader
+
+        # Optimize when the operand is a Projection
+        class ProjectionOperand < self
+
+          # Test if the operand is a Projection
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            operand.kind_of?(operation.class)
+          end
+
+          # Flatten nested Projections into a single Projection
+          #
+          # @return [Projection]
+          #
+          # @api private
+          def optimize
+            operation.class.new(operand.operand, header)
+          end
+
+        end # class ProjectionOperand
+
+        # Optimize when the operand is a Set
+        class SetOperand < self
+
+          # Test if the operand is a Set
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            operand.kind_of?(Veritas::Relation::Operation::Set)
+          end
+
+          # Wrap each operand in the Set in a Projection
+          #
+          # @return [Set]
+          #
+          # @api private
+          def optimize
+            operand.class.new(wrap_left, wrap_right).optimize
+          end
+
+        private
+
+          # Utility method to wrap the left operand in a Projection
+          #
+          # @return [Projection]
+          #
+          # @api private
+          def wrap_left
+            operation.class.new(operand.left, header)
+          end
+
+          # Utility method to wrap the right operand in a Projection
+          #
+          # @return [Projection]
+          #
+          # @api private
+          def wrap_right
+            operation.class.new(operand.right, header)
+          end
+
+        end # class SetOperand
+
+        # Optimize when the operand is Empty
+        class EmptyOperand < self
+
+          # Test if the operand is empty
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            operand.kind_of?(Veritas::Relation::Empty)
+          end
+
+          # Return a new Empty relation with the operation's headers
+          #
+          # @return [Empty]
+          #
+          # @api private
+          def optimize
+            Veritas::Relation::Empty.new(header)
+          end
+
+        end # class EmptyOperand
+
+        # Optimize when operand is optimizable
+        class UnoptimizedOperand < self
+
+          # Test if the operand is unoptimized
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            !operand.equal?(operation.operand)
+          end
+
+          # Return a Projection with an optimized operand
+          #
+          # @return [Projection]
+          #
+          # @api private
+          def optimize
+            operation.class.new(operand, header)
+          end
+
+        end # class UnoptimizedOperand
+
+        Veritas::Algebra::Projection.optimizer = chain(
+          UnchangedHeader,
+          ProjectionOperand,
+          SetOperand,
+          EmptyOperand,
+          MaterializedOperand,
+          UnoptimizedOperand
+        )
+
+      end # class Projection
+    end # module Algebra
+  end # class Optimizer
+end # module Veritas