veritas 0.0.1

data/lib/veritas/optimizer/relation/operation/order.rb

@@ -0,0 +1,94 @@
+module Veritas
+  class Optimizer
+    module Relation
+      module Operation
+
+        # Abstract base class representing Order optimizations
+        class Order < Unary
+
+          # Optimize when the operand is an Order
+          class OrderOperand < self
+
+            # Test if the operand is an Order
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operand.kind_of?(operation.class)
+            end
+
+            # Flatten Order operations using the operation directions
+            #
+            # @return [Order]
+            #
+            # @api private
+            def optimize
+              operation = self.operation
+              operation.class.new(operand.operand, operation.directions)
+            end
+
+          end # class OrderOperand
+
+          # Optimize when the operand is a Limit with a limit of 1
+          class OneLimitOperand < self
+
+            # Test if the operand is an Limit with a limit of 1
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operand = self.operand
+              operand.kind_of?(Veritas::Relation::Operation::Limit) &&
+              operand.to_i == 1
+            end
+
+            # An Order of a Limit with a limit of 1 is a noop
+            #
+            # @return [Limit]
+            #
+            # @api private
+            def optimize
+              operand
+            end
+
+          end # class OneLimitOperand
+
+          # 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 an Order with an optimized operand
+            #
+            # @return [Offset]
+            #
+            # @api private
+            def optimize
+              operation = self.operation
+              operation.class.new(operand, operation.directions)
+            end
+
+          end # class UnoptimizedOperand
+
+          Veritas::Relation::Operation::Order.optimizer = chain(
+            OrderOperand,
+            OneLimitOperand,
+            EmptyOperand,
+            MaterializedOperand,
+            UnoptimizedOperand
+          )
+
+        end # class Order
+      end # module Operation
+    end # module Relation
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/relation/operation/reverse.rb

@@ -0,0 +1,92 @@
+module Veritas
+  class Optimizer
+    module Relation
+      module Operation
+
+        # Abstract base class representing Reverse optimizations
+        class Reverse < Order
+
+          # Optimize when the operand is a Reverse
+          class ReverseOperand < self
+
+            # Test if the operand is a Reverse
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operand.kind_of?(operation.class)
+            end
+
+            # A Reverse of a Reverse is a noop
+            #
+            # @return [Relation]
+            #
+            # @api private
+            def optimize
+              operand.operand
+            end
+
+          end # class ReverseOperand
+
+          # Optimize when the operand is an Order
+          class OrderOperand < self
+
+            # Test if the operand is an Order
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operand.kind_of?(Veritas::Relation::Operation::Order)
+            end
+
+            # Flatten Reverse operation and Order operand into an Order
+            #
+            # @return [Order]
+            #
+            # @api private
+            def optimize
+              operand = self.operand
+              operand.class.new(operand.operand, operation.directions)
+            end
+
+          end # class OrderOperand
+
+          # 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 an Reverse with an optimized operand
+            #
+            # @return [Reverse]
+            #
+            # @api private
+            def optimize
+              operation.class.new(operand)
+            end
+
+          end # class UnoptimizedOperand
+
+          Veritas::Relation::Operation::Reverse.optimizer = chain(
+            ReverseOperand,
+            OrderOperand,
+            OneLimitOperand,
+            EmptyOperand,
+            MaterializedOperand,
+            UnoptimizedOperand
+          )
+
+        end # class Reverse
+      end # module Operation
+    end # module Relation
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/relation/operation/unary.rb

@@ -0,0 +1,86 @@
+module Veritas
+  class Optimizer
+    module Relation
+      module Operation
+
+        # Abstract base class representing Unary relation optimizations
+        class Unary < Optimizer
+
+          # The optimized operand
+          #
+          # @return [Relation]
+          #
+          # @api private
+          attr_reader :operand
+
+          # Initialize a Unary optimizer
+          #
+          # @return [undefined]
+          #
+          # @api private
+          def initialize(*)
+            super
+            @operand = optimize_operand
+          end
+
+        private
+
+          # Optimize the operand
+          #
+          # @return [Relation]
+          #
+          # @api private
+          def optimize_operand
+            operation.operand.optimize
+          end
+
+          # 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
+
+            # A Unary operation on an empty operand is empty
+            #
+            # @return [Relation::Empty]
+            #
+            # @api private
+            def optimize
+              operand
+            end
+
+          end # class EmptyOperand
+
+          # Optimize when the operand is Materialized
+          class MaterializedOperand < self
+
+            # Test if the operand is materialized
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operand.kind_of?(Veritas::Relation::Materialized)
+            end
+
+            # Return the materialized operation
+            #
+            # @return [Relation::Materialized]
+            #
+            # @api private
+            def optimize
+              operation.materialize
+            end
+
+          end # class MaterializedOperand
+        end # class Unary
+      end # module Operation
+    end # module Relation
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/relation/operation.rb

@@ -0,0 +1,8 @@
+require 'veritas/optimizer/relation/operation/binary'
+require 'veritas/optimizer/relation/operation/unary'
+require 'veritas/optimizer/relation/operation/combine'
+
+require 'veritas/optimizer/relation/operation/limit'
+require 'veritas/optimizer/relation/operation/offset'
+require 'veritas/optimizer/relation/operation/order'
+require 'veritas/optimizer/relation/operation/reverse'

data/lib/veritas/optimizer/relation.rb

@@ -0,0 +1,2 @@
+require 'veritas/optimizer/relation/materialized'
+require 'veritas/optimizer/relation/operation'

data/lib/veritas/optimizer.rb

@@ -0,0 +1,94 @@
+module Veritas
+
+  # A optimization for an operation
+  class Optimizer
+    include AbstractClass, Immutable
+
+    # A noop optimizer that returns the operation as-is
+    Noop = lambda { |operation| operation }.freeze
+
+    # The operation to optimize
+    #
+    # @return [Optimizable]
+    #
+    # @api private
+    attr_reader :operation
+
+    # Initialize an Optimizer
+    #
+    # @param [Optimizable] operation
+    #   the operation to optimize
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(operation)
+      @operation = operation
+    end
+
+    # Abstract method that tests if the optimization should be applied
+    #
+    # @example
+    #   optimizer.optimizable?  # => true or false
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def optimizable?
+      raise NotImplementedError, "#{self.class}#optimizable? must be implemented"
+    end
+
+    # Abstract method that executes the optimization for the operation
+    #
+    # @example
+    #   optimized = optimizer.optimize
+    #
+    # @return [Optimizable]
+    #
+    # @api public
+    def optimize
+      raise NotImplementedError, "#{self.class}#optimize must be implemented"
+    end
+
+    # Chain together a list of optimizer classes into a callable object
+    #
+    # @example
+    #   Optimizer.chain(Optimizer::Foo, Optimizer::Bar)
+    #
+    # @param [Array<Class<Optimizer>>] *optimizers
+    #   a list of optimizer classes to apply
+    #
+    # @return [#call]
+    #
+    # @api public
+    def self.chain(*optimizers)
+      optimizers.reverse_each.reduce(Noop) do |successor, optimizer|
+        link_optimizers(optimizer, successor)
+      end
+    end
+
+    # Link an optimizer to a successor
+    #
+    # @param [Class<Optimizer>] optimizer
+    #   the optimizer to link to the successor
+    # @param [#proc] successor
+    #   the next optimizer to call if the current optimizer is not applied
+    #
+    # @return [#call]
+    #
+    # @api private
+    def self.link_optimizers(optimizer, successor)
+      lambda do |operation|
+        op = optimizer.new(operation)
+        op.optimizable? ? op.optimize : successor.call(operation)
+      end
+    end
+
+    private_class_method :link_optimizers
+
+  end # class Optimizer
+end # module Veritas
+
+require 'veritas/optimizer/relation'
+require 'veritas/optimizer/algebra'
+require 'veritas/optimizer/logic'

data/lib/veritas/relation/empty.rb

@@ -0,0 +1,22 @@
+module Veritas
+  class Relation
+
+    # An empty relation
+    class Empty < Materialized
+      ZERO_TUPLE = [].freeze
+
+      # Initialize an empty Relation
+      #
+      # @param [Header] header
+      #   the header for the empty relation
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def initialize(header)
+        super(header, ZERO_TUPLE)
+      end
+
+    end # class Empty
+  end # class Relation
+end # module Veritas

data/lib/veritas/relation/header.rb

@@ -0,0 +1,267 @@
+module Veritas
+  class Relation
+
+    # A set of attributes that correspond to values in each tuple
+    class Header
+      extend Aliasable
+      include Enumerable, Immutable
+
+      inheritable_alias(
+        :& => :intersect,
+        :| => :union,
+        :- => :difference
+      )
+
+      # Initialize a Header
+      #
+      # @example
+      #   header = Header.new(attributes)
+      #
+      # @param [#to_ary]
+      #   optional attributes
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def initialize(attributes = [])
+        @attributes = attributes.to_ary.map do |attribute|
+          Attribute.coerce(attribute)
+        end.freeze
+        @names   = {}
+        @indexes = {}
+      end
+
+      # Iterate over each attribute in the header
+      #
+      # @example
+      #   header = Header.new(attributes)
+      #   header.each { |attribute| ... }
+      #
+      # @yield [attribute]
+      #
+      # @yieldparam [Attribute] attribute
+      #   each attribute in the header
+      #
+      # @return [self]
+      #
+      # @api public
+      def each(&block)
+        to_ary.each(&block)
+        self
+      end
+
+      # Lookup the index of an attribute in the header given a name
+      #
+      # @example
+      #   index = header.index(:id)
+      #
+      # @param [Attribute, #to_ary, #to_sym] name
+      #
+      # @return [Integer]
+      #   the offset when the name is known
+      # @return [nil]
+      #   nil when the attribute is unknown
+      #
+      # @api private
+      def index(name)
+        @indexes[name] ||=
+          begin
+            attribute = self[name]
+            to_ary.index(attribute) if attribute
+          end
+      end
+
+      # Lookup an attribute in the header given a name
+      #
+      # @example
+      #   attribute = header[:id]
+      #
+      # @param [Attribute, #to_ary, #to_sym] name
+      #
+      # @return [Attribute]
+      #   the attribute when the name is known
+      # @return [nil]
+      #   nil when the attribute is unknown
+      #
+      # @api public
+      def [](name)
+        @names[name] ||=
+          begin
+            name = Attribute.name_from(name)
+            detect { |attribute| attribute.name == name }
+          end
+      end
+
+      # Return a header with only the attributes specified
+      #
+      # @example
+      #   projected = header.project(attributes)
+      #
+      # @param [#map] attributes
+      #   the attributes to keep in the header
+      #
+      # @return [Header]
+      #
+      # @api private
+      def project(attributes)
+        new(attributes.map { |attribute| self[attribute] })
+      end
+
+      # Return a header with the attributes renamed
+      #
+      # @example
+      #   renamed = header.rename(aliases)
+      #
+      # @param [Aliases] aliases
+      #   the old and new attribute names
+      #
+      # @return [Header]
+      #
+      # @api private
+      def rename(aliases)
+        new(map { |attribute| aliases[attribute] })
+      end
+
+      # Return the intersection of the header with another header
+      #
+      # @param [Header] other
+      #
+      # @return [Header]
+      #
+      # @api private
+      def intersect(other)
+        new(to_ary & other)
+      end
+
+      # Return the union of the header with another header
+      #
+      # @param [Header] other
+      #
+      # @return [Header]
+      #
+      # @api private
+      def union(other)
+        new(to_ary | other)
+      end
+
+      # Return the difference of the header with another header
+      #
+      # @param [Header] other
+      #
+      # @return [Header]
+      #
+      # @api private
+      def difference(other)
+        new(to_ary - other)
+      end
+
+      # Convert the Header into an Array
+      #
+      # @example
+      #   array = header.to_ary
+      #
+      # @return [Array]
+      #
+      # @api private
+      def to_ary
+        @attributes
+      end
+
+      # Compare the header with other header for equivalency
+      #
+      # @example
+      #   header == other  # => true or false
+      #
+      # @param [Header] other
+      #   the other header to compare with
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def ==(other)
+        to_set == self.class.coerce(other).to_set
+      end
+
+      # Compare the header with other header for equality
+      #
+      # @example
+      #   header.eql?(other)  # => true or false
+      #
+      # @param [Header] other
+      #   the other header to compare with
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def eql?(other)
+        instance_of?(other.class) &&
+        to_set == other.to_set
+      end
+
+      # Return the hash of the header
+      #
+      # @example
+      #   numeric_hash = header.hash
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def hash
+        to_ary.hash
+      end
+
+      # Test if there are no attributes
+      #
+      # @example
+      #   header.empty?  # => true or false
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def empty?
+        to_ary.empty?
+      end
+
+      # Return a string representing the header
+      #
+      # @example
+      #   header.inspect  # => "[<Attribute::Integer name: id>]"
+      #
+      # @return [String]
+      #
+      # @api public
+      def inspect
+        to_ary.inspect
+      end
+
+    private
+
+      # Utility method to instantiate a Header
+      #
+      # @param [#to_ary] attributes
+      #   the header attributes
+      #
+      # @return [Header]
+      #
+      # @api private
+      def new(attributes)
+        self.class.new(attributes)
+      end
+
+      # Coerce an Array-like object into a Header
+      #
+      # @param [Header, #to_ary]
+      #   the header or attributes
+      #
+      # @return [Header]
+      #
+      # @api private
+      def self.coerce(object)
+        object.kind_of?(Header) ? object : new(object)
+      end
+
+      memoize :hash
+
+    end # class Header
+  end # class Relation
+end # module Veritas