veritas-optimizer 0.0.3 → 0.0.4

data/.rvmrc

@@ -0,0 +1 @@
+rvm use @$(basename `pwd`) --create

data/.travis.yml

@@ -0,0 +1,8 @@
+bundler_args: --without guard metrics
+script: "bundle exec rake spec"
+rvm:
+  - ree
+  - 1.8.7
+  - 1.9.2
+  - ruby-head
+  - rbx

data/Gemfile

@@ -1,23 +1,33 @@
+# encoding: utf-8
+
 source :rubygems
 
-gem 'veritas', '0.0.3', :git => 'git://github.com/dkubb/veritas.git'
+gem 'veritas', '0.0.4', :git => 'git://github.com/dkubb/veritas.git'
 
 group :development do
-  gem 'backports', '~> 2.1.0'
-  gem 'jeweler',   '~> 1.5.2'
-  gem 'rake',      '~> 0.8.7'
+  gem 'backports', '~> 2.2.1'
+  gem 'jeweler',   '~> 1.6.0'
+  gem 'rake',      '~> 0.9.0'
   gem 'rspec',     '~> 1.3.2'
-  gem 'yard',      '~> 0.6.8'
+  gem 'yard',      '~> 0.7.1'
+end
+
+group :guard do
+  gem 'growl',         '~> 1.0.3'
+  gem 'guard',         '~> 0.3.4'
+  gem 'guard-bundler', '~> 0.1.3'
+  gem 'guard-ego',     '~> 0.0.1'
+  gem 'guard-rspec',   '~> 0.3.1'
 end
 
-group :jruby do
-  platform :jruby do
-    gem 'jruby-openssl', '~> 0.7.3'
+platform :jruby do
+  group :jruby do
+    gem 'jruby-openssl', '~> 0.7.4'
   end
 end
 
 platforms :mri_18 do
-  group :quality do
+  group :metrics do
     gem 'flay',      '~> 1.4.2'
     gem 'flog',      '~> 2.5.1'
     gem 'heckle',    '~> 1.4.3'
@@ -28,6 +38,6 @@ platforms :mri_18 do
     gem 'reek',      '~> 1.2.8', :git => 'git://github.com/dkubb/reek.git'
     gem 'roodi',     '~> 2.1.0'
     gem 'ruby2ruby', '=  1.2.2'
-    gem 'yardstick', '~> 0.3.0'
+    gem 'yardstick', '~> 0.4.0'
   end
 end

data/Guardfile

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+guard 'ego' do
+  watch('Guardfile')
+end
+
+guard 'bundler' do
+  watch('Gemfile')
+end
+
+guard 'rspec' do
+  # run all specs if the spec_helper or supporting files files are modified
+  watch('spec/spec_helper.rb')                      { 'spec' }
+  watch(%r{\Aspec/(?:lib|support|shared)/.+\.rb\z}) { 'spec' }
+
+  # run unit specs if associated lib code is modified
+  watch(%r{\Alib/(.+)\.rb\z})                                         { |m| Dir["spec/unit/#{m[1]}"] }
+  watch("lib/#{File.basename(File.expand_path('../', __FILE__))}.rb") { 'spec'                       }
+
+  # run a spec if it is modified
+  watch(%r{\Aspec/(?:unit|integration)/.+_spec\.rb\z})
+end

data/README.rdoc

@@ -2,6 +2,8 @@
 
 Relational algebra optimizer
 
+http://travis-ci.org/dkubb/veritas-optimizer.png
+
 == Note on Patches/Pull Requests
 
 * If you want your code merged into the mainline, please discuss

data/Rakefile

@@ -1,9 +1,11 @@
+# encoding: utf-8
+
 require 'rake'
 
 require File.expand_path('../lib/veritas/optimizer/version', __FILE__)
 
 begin
-  gem('jeweler', '~> 1.5.2') if respond_to?(:gem, true)
+  gem('jeweler', '~> 1.6.0') if respond_to?(:gem, true)
   require 'jeweler'
 
   Jeweler::Tasks.new do |gem|
@@ -21,5 +23,5 @@ begin
 
   FileList['tasks/**/*.rake'].each { |task| import task }
 rescue LoadError
-  puts 'Jeweler (or a dependency) not available. Install it with: gem install jeweler -v 1.5.2'
+  puts 'Jeweler (or a dependency) not available. Install it with: gem install jeweler -v 1.6.0'
 end

data/TODO

@@ -1,7 +1,32 @@
+* All relations, even optimized ones, need to hold a reference to the
+  original (possibly optimized) operations.
+  * Especially "empty" relations should hold a reference to the original
+    relation so that insert/update can be performed on them if they are
+    empty not because they are valid, but because the source object is empty
+  * Materialized relations will need references to the original objects.
+
+* Optimization can replace one or more AST nodes with a simpler/more efficient
+  structure as long as it is lossless. Just changing it to empty or
+  materialized, the way things are now, we lose what the original relation
+  was so it becomes impossible to insert/update/delete from those relations.
+  * A write to a materialized object should first propagate the write down
+    to the @operand, allowing it to raise exceptions if it's read*only,
+    then it should make the change in the materialized object.
+
 * Add further optimizations:
   * Projection
-    * When it contains a Rename, if the renamed attributes are projected
-      away, then the rename can be removed.
+    * When it contains a Rename, if the renamed attributes are removed,
+      then the rename can be removed.
+    * When it contains a Restriction, if the removed attributes are *not*
+      used in the predicate, then move the Restriction to contain the
+      Projection.
+    * When renames or extensions or summarizations are projected away and
+      not used in any intermediary operation, then they can be dropped
+      altogether. There's no point in going through all that work to
+      not bother using an attribute at all. It would be better to simplify
+      the renames/extensions/summarizations to not add the attribute, and
+      then call optimize again on the op to potentially remove the op altogether
+      (like in the case of an extension adding one attribute that is removed).
   * Operation Order:
     * Projection containing an Order
       * Should remove the Order, since it is a noop
@@ -73,3 +98,19 @@
     * Limit with a limit >= 1 can be factored out
     * Offset with an offset > 0 can be transformed into an empty
       relation, since at most there can be only one match.
+
+* Summarization
+  * Add OrderSummarizePer for factoring out Order objects inside a Summarization
+  * When there are no aggregate functions, drop the Summarization and
+    return the summarize_per (?)
+    * Use the UnchangedHeader optimizer as a base class
+  * When summarize_per is TABLE_DEE, and it is wrapped by Order, at most only
+    one row can be returned, so Order can probably be dropped.
+    * Consider making relations that represents a 0 or 1 tuple relations
+      and use them in this case.
+
+* Projection
+  * It does not distribute over Intersection or Difference, but see if
+    perhaps an exception can be made if there is a functional dependency
+    between the columns projected away and the one remaining. Then I *think*
+    it might still work, but more research will be needed.

data/config/flay.yml

@@ -1,3 +1,3 @@
 ---
-threshold: 131
-total_score: 905
+threshold: 126
+total_score: 870

data/config/flog.yml

@@ -1,2 +1,2 @@
 ---
-threshold: 12.4
+threshold: 11.6

data/config/roodi.yml

@@ -1,8 +1,8 @@
 ---
-AbcMetricMethodCheck:            { score: 7.3 }
+AbcMetricMethodCheck:            { score: 8.6 }
 AssignmentInConditionalCheck:    { }
 CaseMissingElseCheck:            { }
-ClassLineCountCheck:             { line_count: 390 }
+ClassLineCountCheck:             { line_count: 396 }
 ClassNameCheck:                  { pattern: !ruby/regexp /\A(?:[A-Z]+|[A-Z][a-z](?:[A-Z]?[a-z])+)\z/ }
 ClassVariableCheck:              { }
 CyclomaticComplexityBlockCheck:  { complexity: 2 }
@@ -10,7 +10,7 @@ CyclomaticComplexityMethodCheck: { complexity: 6 }
 EmptyRescueBodyCheck:            { }
 ForLoopCheck:                    { }
 MethodLineCountCheck:            { line_count: 9 }
-MethodNameCheck:                 { pattern: !ruby/regexp /\A(?:[a-z](?:_?[a-z])+[?!=]?|\[\]=?|==|<=>|[+*&|-])\z/ }
-ModuleLineCountCheck:            { line_count: 392 }
+MethodNameCheck:                 { pattern: !ruby/regexp /\A(?:[a-z\d](?:_?[a-z\d])+[?!=]?|\[\]=?|==|<=>|[+*&|-])\z/ }
+ModuleLineCountCheck:            { line_count: 398 }
 ModuleNameCheck:                 { pattern: !ruby/regexp /\A(?:[A-Z]+|[A-Z][a-z](?:[A-Z]?[a-z])+)\z/ }
 ParameterNumberCheck:            { parameter_count: 3 }

data/lib/veritas/optimizer/aggregate/count.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    class Aggregate
+
+      # Abstract base class representing Count optimizations
+      class Count < self
+
+        Veritas::Aggregate::Count.optimizer = chain(
+          UnoptimizedOperand
+        )
+
+      end # class Count
+    end # class Aggregate
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/aggregate/maximum.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    class Aggregate
+
+      # Abstract base class representing Maximum optimizations
+      class Maximum < self
+
+        Veritas::Aggregate::Maximum.optimizer = chain(
+          UnoptimizedOperand
+        )
+
+      end # class Maximum
+    end # class Aggregate
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/aggregate/mean.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    class Aggregate
+
+      # Abstract base class representing Mean optimizations
+      class Mean < self
+
+        Veritas::Aggregate::Mean.optimizer = chain(
+          UnoptimizedOperand
+        )
+
+      end # class Mean
+    end # class Aggregate
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/aggregate/minimum.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    class Aggregate
+
+      # Abstract base class representing Minimum optimizations
+      class Minimum < self
+
+        Veritas::Aggregate::Minimum.optimizer = chain(
+          UnoptimizedOperand
+        )
+
+      end # class Minimum
+    end # class Aggregate
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/aggregate/standard_deviation.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    class Aggregate
+
+      # Abstract base class representing StandardDeviation optimizations
+      class StandardDeviation < self
+
+        Veritas::Aggregate::StandardDeviation.optimizer = chain(
+          UnoptimizedOperand
+        )
+
+      end # class StandardDeviation
+    end # class Aggregate
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/aggregate/sum.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    class Aggregate
+
+      # Abstract base class representing Sum optimizations
+      class Sum < self
+
+        Veritas::Aggregate::Sum.optimizer = chain(
+          UnoptimizedOperand
+        )
+
+      end # class Sum
+    end # class Aggregate
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/aggregate/variance.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    class Aggregate
+
+      # Abstract base class representing Variance optimizations
+      class Variance < self
+
+        Veritas::Aggregate::Variance.optimizer = chain(
+          UnoptimizedOperand
+        )
+
+      end # class Variance
+    end # class Aggregate
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/aggregate.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+
+    # Abstract base class representing Aggregate optimizations
+    class Aggregate < Optimizer
+      include AbstractClass, Function::Unary
+
+      # Optimize when the operands are unoptimized
+      class UnoptimizedOperand < self
+        include Function::Unary::UnoptimizedOperand
+      end # class UnoptimizedOperand
+    end # class Aggregate
+  end # class Optimizer
+end # module Veritas

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

@@ -56,8 +56,10 @@ module Veritas
           EqualOperands,
           EmptyLeft,
           EmptyRight,
+          LeftOrderOperand,
+          RightOrderOperand,
           MaterializedOperand,
-          UnoptimizedOperand
+          UnoptimizedOperands
         )
 
       end # class Difference

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

@@ -7,8 +7,51 @@ module Veritas
       # Abstract base class representing Extension optimizations
       class Extension < Relation::Operation::Unary
 
+        # The optimized extensions
+        #
+        # @return [Hash{Attribute => Function}]
+        #
+        # @api private
+        attr_reader :extensions
+
+        # Initialize a Summarization optimizer
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(*)
+          super
+          @extensions = optimize_extensions
+        end
+
+      private
+
+        # Optimize the extensions
+        #
+        # @return [Hash{Attribute => Function}]
+        #
+        # @api private
+        def optimize_extensions
+          Function.optimize_functions(operation.extensions)
+        end
+
+        # Wrap the operand's operand in an Extension
+        #
+        # @return [Extension]
+        #
+        # @api private
+        def wrap_operand(operand = operand.operand)
+          operation.class.new(operand, extensions)
+        end
+
+        # Optimize when the operand is an Order
+        class OrderOperand < self
+          include Relation::Operation::Unary::OrderOperand
+        end # class OrderOperand
+
         # Optimize when operands are optimizable
         class UnoptimizedOperand < self
+          include Function::Unary::UnoptimizedOperand
 
           # Test if the operand is unoptimized
           #
@@ -16,7 +59,7 @@ module Veritas
           #
           # @api private
           def optimizable?
-            !operand.equal?(operation.operand)
+            super || extensions_optimizable?
           end
 
           # Return an Extension with an optimized operand
@@ -25,14 +68,26 @@ module Veritas
           #
           # @api private
           def optimize
-            operation = self.operation
-            operation.class.new(operand, operation.extensions)
+            wrap_operand(operand)
+          end
+
+        private
+
+          # Test if the extensions are optimizable
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def extensions_optimizable?
+            !extensions.eql?(operation.extensions)
           end
 
         end # class UnoptimizedOperand
 
         Veritas::Algebra::Extension.optimizer = chain(
+          UnchangedHeader,
           MaterializedOperand,
+          OrderOperand,
           UnoptimizedOperand
         )
 

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

@@ -56,8 +56,10 @@ module Veritas
           EqualOperands,
           EmptyLeft,
           EmptyRight,
+          LeftOrderOperand,
+          RightOrderOperand,
           MaterializedOperand,
-          UnoptimizedOperand
+          UnoptimizedOperands
         )
 
       end # class Intersection

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

@@ -7,10 +7,10 @@ module Veritas
       # Abstract base class representing Join optimizations
       class Join < Relation::Operation::Combination
 
-        # Optimize when operand headers are equivalent
+        # Optimize when operands' headers are equal
         class EqualHeaders < self
 
-          # Test if the operands' headers are equal
+          # Test if the operands' headers are equal to the join's headers
           #
           # @return [Boolean]
           #
@@ -19,7 +19,7 @@ module Veritas
             left.header.eql?(right.header)
           end
 
-          # A Join with equal headers is an Intersection
+          # A Join with an equal header is an Intersection
           #
           # @return [Algebra::Intersection]
           #
@@ -34,8 +34,10 @@ module Veritas
           EmptyLeft,
           EmptyRight,
           EqualHeaders,
+          LeftOrderOperand,
+          RightOrderOperand,
           MaterializedOperand,
-          UnoptimizedOperand
+          UnoptimizedOperands
         )
 
       end # class Join

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

@@ -60,8 +60,10 @@ module Veritas
           TableDeeRight,
           EmptyLeft,
           EmptyRight,
+          LeftOrderOperand,
+          RightOrderOperand,
           MaterializedOperand,
-          UnoptimizedOperand
+          UnoptimizedOperands
         )
 
       end # class Product

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

@@ -7,46 +7,17 @@ module Veritas
       # Abstract base class representing Projection optimizations
       class Projection < Relation::Operation::Unary
 
-        # The projected header
-        #
-        # @return [Header]
-        #
-        # @api private
-        attr_reader :header
+      private
 
-        # Initialize an Projection optimizer
+        # Wrap the operand's operand in a Projection
         #
-        # @return [undefined]
+        # @return [Projection]
         #
         # @api private
-        def initialize(*)
-          super
-          @header = operation.header
+        def wrap_operand(operand = operand.operand)
+          operation.class.new(operand, 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
 
@@ -65,24 +36,24 @@ module Veritas
           #
           # @api private
           def optimize
-            operation.class.new(operand.operand, header)
+            wrap_operand
           end
 
         end # class ProjectionOperand
 
-        # Optimize when the operand is a Set
-        class SetOperand < self
+        # Optimize when the operand is a Union
+        class UnionOperand < self
 
-          # Test if the operand is a Set
+          # Test if the operand is a Union
           #
           # @return [Boolean]
           #
           # @api private
           def optimizable?
-            operand.kind_of?(Veritas::Relation::Operation::Set)
+            operand.kind_of?(Veritas::Algebra::Union)
           end
 
-          # Wrap each operand in the Set in a Projection
+          # Wrap each operand in the Union in a Projection
           #
           # @return [Set]
           #
@@ -99,7 +70,7 @@ module Veritas
           #
           # @api private
           def wrap_left
-            operation.class.new(operand.left, header)
+            wrap_operand(operand.left)
           end
 
           # Utility method to wrap the right operand in a Projection
@@ -108,10 +79,15 @@ module Veritas
           #
           # @api private
           def wrap_right
-            operation.class.new(operand.right, header)
+            wrap_operand(operand.right)
           end
 
-        end # class SetOperand
+        end # class UnionOperand
+
+        # Optimize when the operand is an Order
+        class OrderOperand < self
+          include Relation::Operation::Unary::OrderOperand
+        end # class OrderOperand
 
         # Optimize when the operand is Empty
         class EmptyOperand < self
@@ -138,15 +114,7 @@ module Veritas
 
         # 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
+          include Function::Unary::UnoptimizedOperand
 
           # Return a Projection with an optimized operand
           #
@@ -154,7 +122,7 @@ module Veritas
           #
           # @api private
           def optimize
-            operation.class.new(operand, header)
+            wrap_operand(operand)
           end
 
         end # class UnoptimizedOperand
@@ -162,7 +130,8 @@ module Veritas
         Veritas::Algebra::Projection.optimizer = chain(
           UnchangedHeader,
           ProjectionOperand,
-          SetOperand,
+          UnionOperand,
+          OrderOperand,
           EmptyOperand,
           MaterializedOperand,
           UnoptimizedOperand