veritas-optimizer 0.0.3

data/Gemfile

@@ -0,0 +1,33 @@
+source :rubygems
+
+gem 'veritas', '0.0.3', :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 'rspec',     '~> 1.3.2'
+  gem 'yard',      '~> 0.6.8'
+end
+
+group :jruby do
+  platform :jruby do
+    gem 'jruby-openssl', '~> 0.7.3'
+  end
+end
+
+platforms :mri_18 do
+  group :quality do
+    gem 'flay',      '~> 1.4.2'
+    gem 'flog',      '~> 2.5.1'
+    gem 'heckle',    '~> 1.4.3'
+    gem 'json',      '~> 1.5.1'
+    gem 'metric_fu', '~> 2.1.1'
+    gem 'mspec',     '~> 1.5.17'
+    gem 'rcov',      '~> 0.9.9'
+    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'
+  end
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Dan Kubb
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,27 @@
+= Veritas Optimizer
+
+Relational algebra optimizer
+
+== Note on Patches/Pull Requests
+
+* If you want your code merged into the mainline, please discuss
+  the proposed changes with me before doing any work on it. This
+  library is still in early development, and it may not always be
+  clear the direction it is going. Some features may not be appropriate
+  yet, may need to be deferred until later when the foundation for
+  them is laid, or may be more applicable in a plugin.
+* Fork the project.
+* Make your feature addition or bug fix.
+  * Follow this {style guide}[https://github.com/dkubb/styleguide].
+* Add specs for it. This is important so I don't break it in a
+  future version unintentionally. Tests must cover all branches
+  within the code, and code must be fully covered.
+* Commit, do not mess with Rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Run "rake ci". This must pass and not show any regressions in the
+  metrics for the code to be merged.
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2011 Dan Kubb. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,25 @@
+require 'rake'
+
+require File.expand_path('../lib/veritas/optimizer/version', __FILE__)
+
+begin
+  gem('jeweler', '~> 1.5.2') if respond_to?(:gem, true)
+  require 'jeweler'
+
+  Jeweler::Tasks.new do |gem|
+    gem.name        = 'veritas-optimizer'
+    gem.summary     = 'Relational algebra optimizer'
+    gem.description = 'Optimizes veritas relations'
+    gem.email       = 'dan.kubb@gmail.com'
+    gem.homepage    = 'https://github.com/dkubb/veritas-optimizer'
+    gem.authors     = [ 'Dan Kubb' ]
+
+    gem.version = Veritas::Optimizer::VERSION
+  end
+
+  Jeweler::GemcutterTasks.new
+
+  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'
+end

data/TODO

@@ -0,0 +1,75 @@
+* Add further optimizations:
+  * Projection
+    * When it contains a Rename, if the renamed attributes are projected
+      away, then the rename can be removed.
+  * Operation Order:
+    * Projection containing an Order
+      * Should remove the Order, since it is a noop
+    * Projection should follow Rename
+      * When a Projection contains a Restriction, wrap the Projection
+        in the Restriction, projecting away any attributes not used in
+        the restriction. If there are any remaining attributes, then
+        wrap the operation in a Projection removing those attributes.
+        * If all attributes are being used in the Restriction do nothing
+      * When a Projection contains a Join, wrap the Join with a Projection
+        of all the headers, minus those used in the Join. If there were
+        any used, then wrap the whole operation in a Projection with
+        the remaining attributes.
+        * If all the attributes are used in the Join, do nothing
+        * Try to use the same approach for Product
+        * Test if it's possible to fully distribute projections over
+          joins rather than splitting it up like this.
+    * Restriction should follow Projection
+      * Restriction optimizations:
+        * "attr > ? OR attr > ?" -> "attr > ?", with the least restrictive value
+          * Do the same for >=, <, <=
+        * "attr > ? AND attr > ?" -> "attr > ?", with the most restrictive value
+          * Do the same for >=, <, <=
+        * "attr > 5 OR attr == 5" -> "attr >= 5"
+        * "attr < 5 OR attr == 5" -> "attr <= 5"
+        * "attr" = "string" AND "attr" =~ /string/ -> "attr" = "string"
+          * If the regexp matches the constant, then it should be
+            optimized down to a constant match. If it does not match
+            then it should be optimized to a Contradiction.
+        * Constant folding, eg:
+          "attr1 > attr2 AND attr1 = 5" -> "5 > attr2 AND attr1 = 5"
+          * This will probably only work across Conjunctions.
+        * "attr > 5 AND attr = 6" -> "attr = 6", because attr must be
+          equal to 6. this will probably be related to constant folding;
+          the first expression will become 6 > 5, which evaluates to a
+          Tautology, then the expression is a Tautology AND attr = 6,
+          which simplifies down to attr = 6.
+        * "attr < 5 AND attr = 6" -> "Contradiction", because attr must be equal to
+          6, and 6 < 5 evaluates to a Contradiction.  A Contradiction AND attr = 6
+          simplifies down to a Contradiction.
+      * Figure out how to reorganize the Restriction predicates so that all
+        similar operations are closer together to allow more efficient
+        optimizations. This would allow optimizations of stuff like this:
+
+          "attr1 = ? OR attr2 = ? OR attr1 = ?"
+
+        Into:
+
+          "attr1 IN(..) OR attr2 = ?"
+    * Rename should distribute over Join, Product and Set operations
+      * The goal should be to push Rename as close to the base tables
+        as possible so that the names of attribute will be consistent
+        throughout the whole tree.
+  * A Union of relations with the same base, header, and restrictions should
+    try to combine into a single relation with the restrictions using OR.
+  * An Intersection of relations with the same base, header, and restrictions
+    should try to combine into a single relation with the restrictions using
+    AND.
+  * A Difference of relations with the same base and restrictions should
+    try to combine into a single relation with the restrictions using NOT.
+  * Join Optimizations
+    * When a Join contains a Join, and the size of the base relations is
+      known, join the smallest with the largest, and then join that result
+      with the remaining relation.
+    * Make sure the smallest relation (with a known size) is always the
+      right-most operation.
+  * When a restriction uses a unique index:
+    * Order can be factored out
+    * 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.

data/config/flay.yml

@@ -0,0 +1,3 @@
+---
+threshold: 131
+total_score: 905

data/config/flog.yml

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

data/config/roodi.yml

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

data/config/site.reek

@@ -0,0 +1,91 @@
+---
+UncommunicativeParameterName:
+  accept: []
+  exclude: []
+  enabled: true
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+LargeClass:
+  max_methods: 11  # TODO: decrease max_methods to 10-15 or less
+  exclude: []
+  enabled: true
+  max_instance_variables: 2
+UncommunicativeMethodName:
+  accept: []
+  exclude: []
+  enabled: true
+  reject:
+  - !ruby/regexp /^[a-z]$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+LongParameterList:
+  max_params: 3
+  exclude: []
+  enabled: true
+  overrides: {}
+FeatureEnvy:
+  exclude: []
+  enabled: true
+ClassVariable:
+  exclude: []
+  enabled: true
+BooleanParameter:
+  exclude: []
+  enabled: true
+IrresponsibleModule:
+  exclude: []
+  enabled: true
+UncommunicativeModuleName:
+  accept: []
+  exclude: []
+  enabled: true
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+NestedIterators:
+  ignore_iterators: []
+  exclude: []
+  enabled: true
+  max_allowed_nesting: 1
+LongMethod:
+  max_statements: 7
+  exclude: []
+  enabled: true
+Duplication:
+  allow_calls: []
+  exclude: []
+  enabled: true
+  max_calls: 1
+UtilityFunction:
+  max_helper_calls: 1
+  exclude: []
+  enabled: true
+Attribute:
+  exclude: []
+  enabled: false
+UncommunicativeVariableName:
+  accept: []
+  exclude: []
+  enabled: true
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+SimulatedPolymorphism:
+  exclude: []
+  enabled: true
+  max_ifs: 1
+DataClump:
+  exclude: []
+  enabled: true
+  max_copies: 1
+  min_clump_size: 2
+ControlCouple:
+  exclude: []
+  enabled: true
+LongYieldList:
+  max_params: 1
+  exclude: []
+  enabled: true

data/config/yardstick.yml

@@ -0,0 +1,2 @@
+---
+threshold: 100

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

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+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,42 @@
+# encoding: utf-8
+
+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,66 @@
+# encoding: utf-8
+
+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,44 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Algebra
+
+      # Abstract base class representing Join optimizations
+      class Join < Relation::Operation::Combination
+
+        # 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,70 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Algebra
+
+      # Abstract base class representing Product optimizations
+      class Product < Relation::Operation::Combination
+
+        # 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 with 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 with 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