bmg 0.9.1 → 0.10.0

data/lib/bmg/sql/processor/where.rb

@@ -0,0 +1,25 @@
+module Bmg
+  module Sql
+    class Processor
+      class Where < Processor
+
+        def initialize(predicate, builder)
+          super(builder)
+          @predicate = predicate
+        end
+
+        def on_select_exp(sexpr)
+          pred = @predicate.rename(sexpr.desaliaser).sexpr
+          if sexpr.where_clause
+            anded = [:and, sexpr.where_clause.predicate, pred ]
+            anded = Predicate::Grammar.sexpr(anded)
+            sexpr.with_update(:where_clause, [ :where_clause, anded ])
+          else
+            sexpr.with_insert(4, [ :where_clause, pred ])
+          end
+        end
+
+      end # class Where
+    end # class Processor
+  end # module Sql
+end # module Bmg

data/lib/bmg/sql/relation.rb

@@ -0,0 +1,141 @@
+module Bmg
+  module Sql
+    class Relation
+      include Bmg::Relation
+
+      def initialize(type, builder, expr)
+        @type = type
+        @builder = builder
+        @expr = expr
+      end
+      attr_reader :type
+
+    protected
+
+      attr_reader :expr, :builder
+
+    public
+
+      def each(&bl)
+        raise NotImplementedError
+      end
+
+      def delete
+        raise NotImplementedError
+      end
+
+      def insert(arg)
+        raise NotImplementedError
+      end
+
+      def update(arg)
+        raise NotImplementedError
+      end
+
+    protected ## optimization
+
+      def _allbut(type, butlist)
+        preserved_key = self.type.knows_keys? && self.type.keys.find{|k|
+          (k & butlist).empty?
+        }
+        expr = before_use(self.expr)
+        expr = Processor::Clip.new(butlist, true, :is_table_dee, builder).call(expr)
+        expr = Processor::Distinct.new(builder).call(expr) unless preserved_key
+        _instance(type, builder, expr)
+      end
+
+      def _matching(type, right, on)
+        if right_expr = extract_compatible_sexpr(right)
+          expr = before_use(self.expr)
+          expr = Processor::SemiJoin.new(right_expr, on, builder).call(expr)
+          _instance(type, builder, expr)
+        else
+          super
+        end
+      end
+
+      def _page(type, ordering, page_index, options)
+        limit  = options[:page_size] || Operator::Page::DEFAULT_OPTIONS[:page_size]
+        offset = (page_index - 1) * limit
+        expr = before_use(self.expr)
+        expr = Processor::OrderBy.new(ordering, builder).call(expr)
+        expr = Processor::LimitOffset.new(limit, offset, builder).call(expr)
+        _instance(type, builder, expr)
+      end
+
+      def _project(type, attrlist)
+        preserved_key = self.type.knows_keys? && self.type.keys.find{|k|
+          k.all?{|a| attrlist.include?(a) }
+        }
+        expr = before_use(self.expr)
+        expr = Processor::Clip.new(attrlist, false, :is_table_dee, builder).call(expr)
+        expr = Processor::Distinct.new(builder).call(expr) unless preserved_key
+        _instance(type, builder, expr)
+      end
+
+      def _rename(type, renaming)
+        expr = before_use(self.expr)
+        expr = Processor::Rename.new(renaming, builder).call(self.expr)
+        _instance(type, builder, expr)
+      end
+
+      def _restrict(type, predicate)
+        expr = before_use(self.expr)
+        expr = Processor::Where.new(predicate, builder).call(self.expr)
+        _instance(type, builder, expr)
+      end
+
+      def _union(type, right, options)
+        if right_expr = extract_compatible_sexpr(right)
+          expr = before_use(self.expr)
+          expr = Processor::Merge.new(:union, !!options[:all], right_expr, builder).call(self.expr)
+          puts expr.each.to_a.inspect
+          _instance(type, builder, expr)
+        else
+          super
+        end
+      end
+
+      # Build a new relation instance for some new type & expression
+      #
+      # This method can be overriden by subclasses to provide their
+      # own class instance
+      def _instance(type, builder, expr)
+        Relation.new(type, builder, expr)
+      end
+
+      # Provides subclasses with a chance to manipulate the expression
+      # before it is reused in another one, following an algebra method
+      # call
+      def before_use(expr)
+        expr
+      end
+
+      # Given a Relation operand (typically a right operand in a binary
+      # expression), extract the associated `expr` if it is compatible
+      # with self for optimization (e.g. same underlying engine).
+      #
+      # May return nil if operand should not be considered for further
+      # optimization
+      def extract_compatible_sexpr(operand)
+        nil
+      end
+
+    public
+
+      def to_sql
+        expr.to_sql("", Dialect.default)
+      end
+
+      def to_ast
+        [:sql, to_sql]
+      end
+
+      def to_s
+        "(sql #{to_sql})"
+      end
+      alias :inspect :to_s
+
+    end # class Relation
+  end # module Sql
+end # module Bmg

data/lib/bmg/sql/version.rb

@@ -0,0 +1,16 @@
+module Bmg
+  module Sql
+    module Version
+
+      MAJOR = 0
+      MINOR = 17
+      TINY  = 0
+
+      def self.to_s
+        [ MAJOR, MINOR, TINY ].join('.')
+      end
+
+    end
+    VERSION = Version.to_s
+  end
+end

data/lib/bmg/support.rb

@@ -1 +1,2 @@
 require_relative 'support/tuple_algebra'
+require_relative 'support/keys'

data/lib/bmg/support/keys.rb

@@ -0,0 +1,59 @@
+module Bmg
+  class Keys
+
+    def initialize(keys, reduce = false)
+      @keys = reduce ? reduce(keys) : keys
+    end
+
+  public ## tools
+
+  public ## algebra
+
+    def allbut(oldtype, newtype, butlist)
+      keys = @keys.select{|k| (k & butlist).empty? }
+      keys = [newtype.attrlist] if keys.empty?
+      Keys.new(keys, false)
+    end
+
+    def group(oldtype, newtype, attrs, as)
+      keys = [ oldtype.attrlist - attrs ]
+      keys += @keys.map{|k| (k & attrs).empty? ? k : (k - attrs) + [as] }
+      Keys.new(keys, true)
+    end
+
+    def project(oldtype, newtype, attrlist)
+      keys = @keys.select{|k| k.all?{|a| attrlist.include?(a) } }
+      keys = [newtype.attrlist] if keys.empty?
+      Keys.new(keys, false)
+    end
+
+    def rename(oldtype, newtype, renaming)
+      keys = @keys.map{|k| k.map{|a| renaming[a] || a } }
+      Keys.new(keys, false)
+    end
+
+    def union(oldtype, newtype, right_type)
+      return nil unless rkeys = right_type.keys
+      return nil unless (oldtype.predicate & right_type.predicate).contradiction?
+      shared = @keys.select{|k| rkeys.include?(k) }
+      Keys.new(shared, false)
+    end
+
+  public ## usuals
+
+    def to_a
+      @keys
+    end
+
+  private
+
+    def reduce(keys)
+      reduced = []
+      keys.sort{|a,b| a.size <=> b.size}.each do |k|
+        reduced << k unless reduced.any?{|r| (r - k).empty? }
+      end
+      reduced
+    end
+
+  end
+end

data/lib/bmg/type.rb

@@ -5,16 +5,69 @@ module Bmg
       @predicate = predicate
       raise ArgumentError if @predicate.nil?
     end
-    attr_reader :predicate
 
     ANY = Type.new
 
+  public ## predicate
+
+    attr_accessor :predicate
+    protected :predicate=
+
+  public ## attrlist
+
+    attr_accessor :attrlist
+    protected :attrlist=
+
+    def with_attrlist(attrlist)
+      dup.tap{|x|
+        x.attrlist = attrlist
+      }
+    end
+
+    def knows_attrlist?
+      !self.attrlist.nil?
+    end
+
+    def to_attrlist
+      self.attrlist
+    end
+
+  public ## keys
+
+    attr_accessor :keys
+    alias :_keys :keys
+    protected :_keys, :keys=
+
+    def knows_keys?
+      !!@keys
+    end
+
+    def keys
+      return @keys.to_a if @keys
+      return [attrlist] if knows_attrlist?
+      nil
+    end
+
+    def with_keys(keys)
+      dup.tap{|x|
+        x.keys = Keys.new(keys)
+      }
+    end
+
+  public ## typing
+
     def [](attribute)
       ANY
     end
 
+  public ### algebra
+
     def allbut(butlist)
-      ANY
+      dup.tap{|x|
+        x.attrlist  = self.attrlist - butlist if knows_attrlist?
+        x.predicate = Predicate.tautology
+        x.keys      = self._keys.allbut(self, x, butlist) if knows_keys?
+      }
     end
 
     def autowrap(options)
@@ -26,19 +79,35 @@ module Bmg
     end
 
     def constants(cs)
-      Type.new(@predicate & Predicate.eq(cs))
+      dup.tap{|x|
+        x.attrlist  = self.attrlist + cs.keys if knows_attrlist?
+        x.predicate = self.predicate & Predicate.eq(cs)
+        ### keys stay the same
+      }
     end
 
     def extend(extension)
-      ANY
+      dup.tap{|x|
+        x.attrlist  = self.attrlist + extension.keys if knows_attrlist?
+        x.predicate = Predicate.tautology
+        ### keys stay the same (?)
+      }
     end
 
     def group(attrs, as)
-      ANY
+      dup.tap{|x|
+        x.attrlist  = self.attrlist - attrs + [as] if knows_attrlist?
+        x.predicate = Predicate.tautology
+        x.keys      = self._keys.group(self, x, attrs, as) if knows_keys?
+      }
     end
 
     def image(right, as, on, options)
-      ANY
+      dup.tap{|x|
+        x.attrlist  = self.attrlist + [as] if knows_attrlist?
+        x.predicate = Predicate.tautology
+        x.keys      = self._keys
+      }
     end
 
     def matching(right, on)
@@ -50,23 +119,35 @@ module Bmg
     end
 
     def project(attrlist)
-      ANY
+      dup.tap{|x|
+        x.attrlist  = attrlist
+        x.predicate = Predicate.tautology
+        x.keys      = self._keys.project(self, x, attrlist) if knows_keys?
+      }
     end
 
     def rename(renaming)
-      Type.new(@predicate.rename(renaming))
+      dup.tap{|x|
+        x.attrlist  = self.attrlist.map{|a| renaming[a] || a } if knows_attrlist?
+        x.predicate = self.predicate.rename(renaming)
+        x.keys      = self._keys.rename(self, x, renaming) if knows_keys?
+      }
     end
 
     def restrict(predicate)
-      Type.new(@predicate & predicate)
-    end
-
-    def rxmatch(attrs, matcher, options)
-      self
+      dup.tap{|x|
+        ### attrlist stays the same
+        x.predicate = self.predicate & predicate
+        x.keys      = self._keys if knows_keys?
+      }
     end
 
     def union(other)
-      Type.new(@predicate | other.predicate)
+      dup.tap{|x|
+        ### attrlist stays the same
+        x.predicate = self.predicate | predicate
+        x.keys      = self._keys.union(self, x, other) if knows_keys?
+      }
     end
 
   end # class Type

data/lib/bmg/version.rb

@@ -1,8 +1,8 @@
 module Bmg
   module Version
     MAJOR = 0
-    MINOR = 9
-    TINY  = 1
+    MINOR = 10
+    TINY  = 0
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"
 end

data/tasks/test.rake

@@ -3,13 +3,20 @@ namespace :test do
 
   tests = []
 
-  desc "Runs unit tests on the library itself"
+  desc "Runs unit tests"
   RSpec::Core::RakeTask.new(:unit) do |t|
     t.pattern = "spec/unit/**/test_*.rb"
-    t.rspec_opts = ["-Ilib", "-Ispec/unit", "--color", "--backtrace", "--format=progress"]
+    t.rspec_opts = ["-Ilib", "-Ispec/unit", "--fail-fast", "--color", "--backtrace", "--format=progress"]
   end
   tests << :unit
 
+  desc "Runs integration tests"
+  RSpec::Core::RakeTask.new(:integration) do |t|
+    t.pattern = "spec/integration/**/test_*.rb"
+    t.rspec_opts = ["-Ilib", "-Ispec/integration", "--fail-fast", "--color", "--backtrace", "--format=progress"]
+  end
+  tests << :integration
+
   task :all => tests
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bmg
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.10.0
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-20 00:00:00.000000000 Z
+date: 2018-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: predicate
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: roo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.7'
 - !ruby/object:Gem::Dependency
   name: sequel
   requirement: !ruby/object:Gem::Requirement
@@ -107,6 +121,7 @@ files:
 - Rakefile
 - lib/bmg.rb
 - lib/bmg/algebra.rb
+- lib/bmg/algebra/shortcuts.rb
 - lib/bmg/error.rb
 - lib/bmg/operator.rb
 - lib/bmg/operator/allbut.rb
@@ -132,7 +147,84 @@ files:
 - lib/bmg/relation/spied.rb
 - lib/bmg/sequel.rb
 - lib/bmg/sequel/relation.rb
+- lib/bmg/sequel/translator.rb
+- lib/bmg/sequel/type_inference.rb
+- lib/bmg/sql.rb
+- lib/bmg/sql/builder.rb
+- lib/bmg/sql/dialect.rb
+- lib/bmg/sql/ext/predicate.rb
+- lib/bmg/sql/ext/predicate/and.rb
+- lib/bmg/sql/ext/predicate/contradiction.rb
+- lib/bmg/sql/ext/predicate/dyadic_comp.rb
+- lib/bmg/sql/ext/predicate/eq.rb
+- lib/bmg/sql/ext/predicate/exists.rb
+- lib/bmg/sql/ext/predicate/expr.rb
+- lib/bmg/sql/ext/predicate/gt.rb
+- lib/bmg/sql/ext/predicate/gte.rb
+- lib/bmg/sql/ext/predicate/identifier.rb
+- lib/bmg/sql/ext/predicate/in.rb
+- lib/bmg/sql/ext/predicate/literal.rb
+- lib/bmg/sql/ext/predicate/lt.rb
+- lib/bmg/sql/ext/predicate/lte.rb
+- lib/bmg/sql/ext/predicate/nadic_bool.rb
+- lib/bmg/sql/ext/predicate/native.rb
+- lib/bmg/sql/ext/predicate/neq.rb
+- lib/bmg/sql/ext/predicate/not.rb
+- lib/bmg/sql/ext/predicate/or.rb
+- lib/bmg/sql/ext/predicate/qualified_identifier.rb
+- lib/bmg/sql/ext/predicate/tautology.rb
+- lib/bmg/sql/grammar.rb
+- lib/bmg/sql/grammar.sexp.yml
+- lib/bmg/sql/nodes/column_name.rb
+- lib/bmg/sql/nodes/cross_join.rb
+- lib/bmg/sql/nodes/except.rb
+- lib/bmg/sql/nodes/expr.rb
+- lib/bmg/sql/nodes/from_clause.rb
+- lib/bmg/sql/nodes/inner_join.rb
+- lib/bmg/sql/nodes/intersect.rb
+- lib/bmg/sql/nodes/limit_clause.rb
+- lib/bmg/sql/nodes/literal.rb
+- lib/bmg/sql/nodes/name_intro.rb
+- lib/bmg/sql/nodes/native_table_as.rb
+- lib/bmg/sql/nodes/offset_clause.rb
+- lib/bmg/sql/nodes/order_by_clause.rb
+- lib/bmg/sql/nodes/order_by_term.rb
+- lib/bmg/sql/nodes/qualified_name.rb
+- lib/bmg/sql/nodes/range_var_name.rb
+- lib/bmg/sql/nodes/select_exp.rb
+- lib/bmg/sql/nodes/select_item.rb
+- lib/bmg/sql/nodes/select_list.rb
+- lib/bmg/sql/nodes/select_star.rb
+- lib/bmg/sql/nodes/set_operator.rb
+- lib/bmg/sql/nodes/set_quantifier.rb
+- lib/bmg/sql/nodes/subquery_as.rb
+- lib/bmg/sql/nodes/table_as.rb
+- lib/bmg/sql/nodes/table_name.rb
+- lib/bmg/sql/nodes/union.rb
+- lib/bmg/sql/nodes/where_clause.rb
+- lib/bmg/sql/nodes/with_exp.rb
+- lib/bmg/sql/nodes/with_spec.rb
+- lib/bmg/sql/processor.rb
+- lib/bmg/sql/processor/all.rb
+- lib/bmg/sql/processor/clip.rb
+- lib/bmg/sql/processor/distinct.rb
+- lib/bmg/sql/processor/flatten.rb
+- lib/bmg/sql/processor/from_self.rb
+- lib/bmg/sql/processor/join.rb
+- lib/bmg/sql/processor/join_support.rb
+- lib/bmg/sql/processor/limit_offset.rb
+- lib/bmg/sql/processor/merge.rb
+- lib/bmg/sql/processor/order_by.rb
+- lib/bmg/sql/processor/rename.rb
+- lib/bmg/sql/processor/reorder.rb
+- lib/bmg/sql/processor/requalify.rb
+- lib/bmg/sql/processor/semi_join.rb
+- lib/bmg/sql/processor/star.rb
+- lib/bmg/sql/processor/where.rb
+- lib/bmg/sql/relation.rb
+- lib/bmg/sql/version.rb
 - lib/bmg/support.rb
+- lib/bmg/support/keys.rb
 - lib/bmg/support/tuple_algebra.rb
 - lib/bmg/type.rb
 - lib/bmg/version.rb
@@ -158,7 +250,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: Bmg is Alf's successor.