bmg 0.9.1 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8dd18a64aa1408889e2decc14ddb3a51bd0ec73d
-  data.tar.gz: 561af2cc9d8793ac79b1011c23c4e6c721cd26d3
+  metadata.gz: 4b5e5a6fe330469b706c911dbc8d54e7feebd903
+  data.tar.gz: f14ca254437c5dd3c896c24cf0b31b75a338f280
 SHA512:
-  metadata.gz: 1870b9fcb76b2667ed83967ff80c7776f40d9622f55195aee8428a06fdeca4d298e014a82f1db904bbd3acc985fc0be94e9e1dc3ae1f47a0e06a6d5b753f2fb9
-  data.tar.gz: 49107701d07c644f7f6eed57b6c28c8a5dc61a38beda056d4a9b18bc0bfdd489627239f0ec944ac3933e00ebe8552a0c36c568cee6672bc938c1acdae0a9df6f
+  metadata.gz: b6510a06199ceeca0a06d95ba6d58685483d9dd47c1780f156b2a5854c916c9e4458e2b0ba1862569d657a2dbe1b0e5957c1c5cb29fda6ee5e9de5c1fc4bca67
+  data.tar.gz: 980af325f9e60808fd8c84ad5b9a75f5b63acb416b665e1b66a5c0a95a017e7f35c01a6796ebe89477373ca7c055b34e22a1ab4e4fdaf938547b4afac73075df

data/lib/bmg/algebra.rb

@@ -1,23 +1,6 @@
 module Bmg
   module Algebra
 
-    METHODS = [
-      :allbut,
-      :autowrap,
-      :autosummarize,
-      :constants,
-      :extend,
-      :group,
-      :image,
-      :matching,
-      :page,
-      :project,
-      :rename,
-      :restrict,
-      :rxmatch,
-      :union
-    ]
-
     def allbut(butlist = [])
       _allbut self.type.allbut(butlist), butlist
     end
@@ -140,15 +123,6 @@ module Bmg
     end
     protected :_restrict
 
-    def rxmatch(attrs, matcher, options = {})
-      _rxmatch type.rxmatch(attrs, matcher, options), attrs, matcher, options
-    end
-
-    def _rxmatch(type, attrs, matcher, options)
-      Operator::Rxmatch.new(type, self, attrs, matcher, options)
-    end
-    protected :_rxmatch
-
     def union(other, options = {})
       _union self.type.union(other.type), other, options
     end
@@ -167,5 +141,7 @@ module Bmg
       self
     end
 
+    require_relative 'algebra/shortcuts'
+    include Shortcuts
   end # module Algebra
 end # module Bmg

data/lib/bmg/algebra/shortcuts.rb

@@ -0,0 +1,14 @@
+module Bmg
+  module Algebra
+    module Shortcuts
+
+      def rxmatch(attrs, matcher, options = {})
+        predicate = attrs.inject(Predicate.contradiction){|p,a|
+          p | Predicate.match(a, matcher, options)
+        }
+        self.restrict(predicate)
+      end
+
+    end # module Shortcuts
+  end # module Algebra
+end # module Bmg

data/lib/bmg/operator/autowrap.rb

@@ -41,7 +41,7 @@ module Bmg
 
       def each
         @operand.each do |tuple|
-          yield autowrap(tuple)
+          yield autowrap_tuple(tuple)
         end
       end
 
@@ -49,6 +49,19 @@ module Bmg
         [ :autowrap, operand.to_ast, @original_options.dup ]
       end
 
+    protected ### optimization
+
+      def _restrict(type, predicate)
+        return super unless operand.type.knows_attrlist?
+        roots = Support.wrapped_roots(operand.type.to_attrlist, options[:split])
+        vars = predicate.free_variables
+        if (roots & vars).empty?
+          operand.restrict(predicate).autowrap(options)
+        else
+          super
+        end
+      end
+
     protected ### inspect
 
       def args
@@ -57,7 +70,7 @@ module Bmg
 
     private
 
-      def autowrap(tuple)
+      def autowrap_tuple(tuple)
         separator = @options[:split]
         autowrapped = tuple.each_with_object({}){|(k,v),h|
           parts = k.to_s.split(separator).map(&:to_sym)
@@ -97,6 +110,11 @@ module Bmg
           none:   ->(t,k){ t           }
         }
 
+        def self.new(remover)
+          return remover if remover.is_a?(NoLeftJoinNoise)
+          super
+        end
+
         def initialize(remover)
           @remover_to_s = remover
           @remover = case remover
@@ -128,6 +146,18 @@ module Bmg
 
       end # NoLeftJoinNoise
 
+      module Support
+
+        def wrapped_roots(attrlist, split_symbol)
+          attrlist.map{|a|
+            split = a.to_s.split(split_symbol)
+            split.size == 1 ? nil : split[0]
+          }.compact.uniq.map(&:to_sym)
+        end
+        module_function :wrapped_roots
+
+      end # module Support
+
     end # class Autowrap
   end # module Operator
 end # module Bmg

data/lib/bmg/operator/constants.rb

@@ -56,6 +56,18 @@ module Bmg
 
     protected ### optimization
 
+      def _page(type, ordering, page_index, options)
+        attrs = ordering.map{|(k,v)| k}
+        cs_attrs = constants.keys
+        if (attrs & cs_attrs).empty?
+          operand
+            .page(ordering, page_index, options)
+            .constants(constants)
+        else
+          super
+        end
+      end
+
       def _restrict(type, predicate)
         # bottom_p makes no reference to constants, top_p possibly
         # does...

data/lib/bmg/operator/image.rb

@@ -55,6 +55,16 @@ module Bmg
 
     protected ### optimization
 
+      def _page(type, ordering, page_index, opts)
+        if ordering.map{|(k,v)| k}.include?(as)
+          super
+        else
+          left
+            .page(ordering, page_index, opts)
+            .image(right, as, on, options)
+        end
+      end
+
       def _restrict(type, predicate)
         on_as, rest = predicate.and_split([as])
         if rest.tautology?

data/lib/bmg/operator/rename.rb

@@ -62,6 +62,14 @@ module Bmg
 
     protected ### optimization
 
+      def _page(type, ordering, page_index, options)
+        rr = reverse_renaming
+        ordering = ordering.map{|(k,v)|
+          v.nil? ? rr[k] || k : [rr[k] || k, v]
+        }
+        operand.page(ordering, page_index, options).rename(renaming)
+      end
+
       def _restrict(type, predicate)
         operand.restrict(predicate.rename(reverse_renaming)).rename(renaming)
       end

data/lib/bmg/relation/spied.rb

@@ -29,20 +29,15 @@ module Bmg
 
     public ### algebra
 
-      Algebra::METHODS.each do |m|
+      Algebra.public_instance_methods(false).each do |m|
+        next if [:spied, :unspied].include?(m)
+
         define_method(m) do |*args, &bl|
+          args = args.map{|a| a.respond_to?(:unspied) ? a.unspied : a }
           operand.send(m, *args, &bl).spied(spy)
         end
       end
 
-      def image(right, *args)
-        operand.image(right.unspied, *args).spied(spy)
-      end
-
-      def union(right, *args)
-        operand.union(right.unspied, *args).spied(spy)
-      end
-
       def unspied
         operand
       end

data/lib/bmg/sequel.rb

@@ -1,11 +1,62 @@
+require 'bmg/sql'
 require 'sequel'
 require 'predicate/sequel'
 module Bmg
 
-  def sequel(dataset, type = Type::ANY)
-    Sequel::Relation.new(type, dataset).spied(main_spy)
+  module Sequel
+
+    def sequel(*args, &bl)
+      source, sequel_db, type = sequel_params(*args, &bl)
+      builder = Sql::Builder.new
+      sexpr = builder.select_all(type.to_attrlist, source)
+      Sequel::Relation.new(type, builder, sexpr, sequel_db).spied(Bmg.main_spy)
+    end
+    module_function :sequel
+
+    def sequel_params(source, sequel_db = nil, type = nil)
+      sequel_db, type = nil, sequel_db if sequel_db.nil? or sequel_db.is_a?(Type)
+      sequel_db = source.db if sequel_db.nil? and source.is_a?(::Sequel::Dataset)
+      raise ArgumentError, "A Sequel::Database object is required" if sequel_db.nil?
+      raise ArgumentError, "Type's attrlist must be known (#{type})" if type && !type.knows_attrlist?
+      type = infer_type!(sequel_db, source) if type.nil?
+      [source, sequel_db, type]
+    end
+    module_function :sequel_params
+
+    def infer_type!(sequel_db, source)
+      raise "Sequel::Relation requires a type for `#{source}`" unless source.is_a?(Symbol)
+      TypeInference.new(sequel_db).call(source)
+    end
+    module_function :infer_type!
+
+  end
+
+  # Builds a Relation that uses Sequel for managing real data
+  # accesses.
+  #
+  # Supported signatures:
+  #
+  #   # Table name, providing the Sequel's Database object
+  #   Bmg.sequel(:suppliers, DB)
+  #
+  #   # Sequel dataset object, embedding the Database object
+  #   # `from_self` will be used at compilation time, you don't
+  #   # need to call it yourself.
+  #   Bmg.sequel(DB[:suppliers])
+  #
+  #   # Similar, but with with a pure SQL query
+  #   Bmg.sequel(DB[%Q{SELECT ... FROM ...}])
+  #
+  #   # All signatures above with an explicit type object, e.g.:
+  #   Bmg.sequel(:suppliers, DB, Type::ANY)
+  #   Bmg.sequel(DB[:suppliers], Type::ANY)
+  #
+  def sequel(source, sequel_db = nil, type = nil)
+    Sequel.sequel(source, sequel_db, type)
   end
   module_function :sequel
 
 end
+require_relative 'sequel/translator'
+require_relative 'sequel/type_inference'
 require_relative 'sequel/relation'

data/lib/bmg/sequel/relation.rb

@@ -1,22 +1,15 @@
 module Bmg
   module Sequel
-    class Relation
-      include Bmg::Relation
+    class Relation < Sql::Relation
 
-      def initialize(type, dataset)
-        @type = type
-        @dataset = dataset
+      def initialize(type, builder, source, sequel_db)
+        super(type, builder, source)
+        @sequel_db = sequel_db
       end
-      attr_reader :type
-
-    protected
-
-      attr_reader :dataset
-
-    public
+      attr_reader :sequel_db
 
       def each(&bl)
-        @dataset.each(&bl)
+        dataset.each(&bl)
       end
 
       def delete
@@ -44,19 +37,31 @@ module Bmg
         [:sequel, dataset.sql]
       end
 
+      def to_sql
+        dataset.sql
+      end
+
       def to_s
         "(sequel #{dataset.sql})"
       end
       alias :inspect :to_s
 
-    protected ### optimization
+    protected
+
+      def dataset
+        @dataset ||= Translator.new(sequel_db).call(self.expr)
+      end
+
+      def _instance(type, builder, expr)
+        Relation.new(type, builder, expr, sequel_db)
+      end
 
-      def _restrict(type, predicate)
-        Relation.new type, dataset.where(predicate.to_sequel)
-      rescue NotImplementedError, Predicate::NotSupportedError
-        super
+      def extract_compatible_sexpr(operand)
+        return nil unless operand.is_a?(Bmg::Sequel::Relation)
+        return nil unless self.sequel_db == operand.sequel_db
+        operand.expr
       end
 
     end # class Relation
-  end # module Operator
+  end # module Sequel
 end # module Bmg

data/lib/bmg/sequel/translator.rb

@@ -0,0 +1,153 @@
+module Bmg
+  module Sequel
+    class Translator < Sexpr::Processor
+      include ::Predicate::ToSequel::Methods
+
+      def initialize(sequel_db)
+        @sequel_db = sequel_db
+      end
+      attr_reader :sequel_db
+
+      def on_with_exp(sexpr)
+        if sequel_db.select(1).supports_cte?
+          dataset = apply(sexpr.select_exp)
+          apply(sexpr.with_spec).each_pair do |name,subquery|
+            dataset = dataset.with(name, subquery)
+          end
+          dataset
+        else
+          apply(Sql::Processor::Flatten.new(Sql::Builder.new).call(sexpr))
+        end
+      end
+
+      def on_with_spec(sexpr)
+        sexpr.each_with_object({}){|child,hash|
+          next if child == :with_spec
+          hash[apply(child.table_name)] = apply(child.subquery)
+        }
+      end
+
+      def on_set_operator(sexpr)
+        left, right = apply(sexpr.left), apply(sexpr.right)
+        left = left.from_self if sexpr.left.set_operator?
+        left.send(sexpr.first, right, all: sexpr.all?, from_self: false)
+      end
+      alias :on_union     :on_set_operator
+      alias :on_intersect :on_set_operator
+      alias :on_except    :on_set_operator
+
+      def on_select_exp(sexpr)
+        dataset   = sequel_db.select(1)
+        dataset   = dataset(apply(sexpr.from_clause)) if sexpr.from_clause
+        #
+        selection = apply(sexpr.select_list)
+        predicate = apply(sexpr.predicate)       if sexpr.predicate
+        order     = apply(sexpr.order_by_clause) if sexpr.order_by_clause
+        limit     = apply(sexpr.limit_clause)    if sexpr.limit_clause
+        offset    = apply(sexpr.offset_clause)   if sexpr.offset_clause
+        #
+        dataset   = dataset.select(*selection)
+        dataset   = dataset.distinct             if sexpr.distinct?
+        dataset   = dataset.where(predicate)     if predicate
+        dataset   = dataset.order_by(*order)     if order
+        dataset   = dataset.limit(limit, offset == 0 ? nil : offset) if limit or offset
+        dataset
+      end
+
+      def on_select_list(sexpr)
+        sexpr.sexpr_body.map{|c| apply(c) }
+      end
+
+      def on_select_star(sexpr)
+        ::Sequel.lit('*')
+      end
+
+      def on_select_item(sexpr)
+        left  = apply(sexpr.left)
+        right = apply(sexpr.right)
+        if left.column == right.value
+          left
+        else
+          ::Sequel.as(left, right)
+        end
+      end
+
+      def on_qualified_name(sexpr)
+        apply(sexpr.last).qualify(sexpr.qualifier)
+      end
+
+      def on_column_name(sexpr)
+        ::Sequel.expr(sexpr.last.to_sym)
+      end
+
+      def on_from_clause(sexpr)
+        apply(sexpr.table_spec)
+      end
+
+      def on_table_name(sexpr)
+        ::Sequel.identifier(sexpr.last)
+      end
+
+      def on_cross_join(sexpr)
+        left, right = apply(sexpr.left), apply(sexpr.right)
+        dataset(left).cross_join(right)
+      end
+
+      def on_inner_join(sexpr)
+        left, right = apply(sexpr.left), apply(sexpr.right)
+        options = {qualify: false, table_alias: false}
+        dataset(left).join_table(:inner, right, nil, options){|*args|
+          apply(sexpr.predicate)
+        }
+      end
+
+      def on_table_as(sexpr)
+        ::Sequel.as(::Sequel.identifier(sexpr.table_name), ::Sequel.identifier(sexpr.as_name))
+      end
+
+      def on_subquery_as(sexpr)
+        ::Sequel.as(apply(sexpr.subquery), ::Sequel.identifier(sexpr.as_name))
+      end
+
+      def on_native_table_as(sexpr)
+        sexpr[1].from_self(:alias => sexpr.as_name)
+      end
+
+      def on_order_by_clause(sexpr)
+        sexpr.sexpr_body.map{|c| apply(c)}
+      end
+
+      def on_order_by_term(sexpr)
+        ::Sequel.send(sexpr.direction, apply(sexpr.qualified_name))
+      end
+
+      def on_limit_clause(sexpr)
+        sexpr.last
+      end
+
+      def on_offset_clause(sexpr)
+        sexpr.last
+      end
+
+    public ### Predicate hack
+
+      def on_in(sexpr)
+        left, right = apply(sexpr.identifier), sexpr.last
+        right = apply(right) if sexpr.subquery?
+        ::Sequel.expr(left => right)
+      end
+
+      def on_exists(sexpr)
+        apply(sexpr.last).exists
+      end
+
+    private
+
+      def dataset(expr)
+        return expr if ::Sequel::Dataset===expr
+        sequel_db[expr]
+      end
+
+    end # class Translator
+  end # module Sequel
+end # module Bmg