alf-core 0.13.0

data/lib/alf-io/alf/support/csv_utils.rb

@@ -0,0 +1,40 @@
+module Alf
+  module Support
+    #
+    # Provides common tooling to CSV renderer and readers
+    #
+    module CSVUtils
+
+      DEFAULT_OPTIONS = {
+        :headers => true
+      }
+
+      private
+
+      # Returns a CSV instance bound to a given io and options
+      def get_csv(io, options = {})
+        require 'csv'
+        ::CSV.new io, Tuple(options).project(::CSV::DEFAULT_OPTIONS.keys)
+      end
+
+      # Yields a CSV instance bound to a given io and options
+      def with_csv(io, options = {})
+        yield get_csv(io, options)
+      end
+
+      class ProcIO
+
+        def initialize(proc = nil, &bl)
+          @proc = proc || bl
+        end
+
+        def call(*args, &bl)
+          @proc.call(*args, &bl)
+        end
+        alias :<< :call
+
+      end # ProcIO
+
+    end # module CSVUtils
+  end # module Support
+end # module Alf

data/lib/alf-lang/alf/lang.rb

@@ -0,0 +1,4 @@
+require_relative 'lang/functional'
+require_relative 'lang/predicates'
+require_relative 'lang/object_oriented'
+require_relative 'lang/lispy'

data/lib/alf-lang/alf/lang/functional.rb

@@ -0,0 +1,56 @@
+module Alf
+  module Lang
+    module Functional
+
+      class << self
+        def def_aggregator_method(name, clazz)
+          define_method(name) do |*args, &block|
+            clazz.new(*args, &block)
+          end
+        end
+
+        def def_operator_method(name, clazz)
+          define_method(name) do |*args|
+            operands, arguments = args[0...clazz.arity], args[clazz.arity..-1]
+            _op_wrap clazz.new(operands.map{|op| _op_unwrap(op) }, *arguments)
+          end
+        end
+      end
+
+      def Heading(*args, &bl)
+        Alf::Heading(*args, &bl)
+      end
+
+      def Tuple(*args, &bl)
+        Alf::Tuple(*args, &bl)
+      end
+
+      def Relation(*args, &bl)
+        Alf::Relation(*args, &bl)
+      end
+
+      Aggregator.listen do |name, clazz|
+        def_aggregator_method(name, clazz)
+      end
+
+      Algebra::Operator.listen do |name, clazz|
+        def_operator_method(name, clazz)
+      end
+
+      def allbut(operand, attributes)
+        project(operand, attributes, :allbut => true)
+      end
+
+    private
+
+      def _op_wrap(expr)
+        expr
+      end
+
+      def _op_unwrap(expr)
+        expr
+      end
+
+    end
+  end
+end

data/lib/alf-lang/alf/lang/lispy.rb

@@ -0,0 +1,53 @@
+module Alf
+  module Lang
+    class Lispy < Support::Scope
+
+      module OwnMethods
+
+        def parse(expr = nil, path = nil, line = nil, &block)
+          if (expr && block) || (expr.nil? and block.nil?)
+            raise ArgumentError, "Either `expr` or `block` should be specified"
+          end
+          expr = evaluate(expr, path, line, &block) if block or expr.is_a?(String)
+          expr = __send__(expr)                     if expr.is_a?(Symbol)
+          expr = expr.bind(connection)              if expr.is_a?(Support::Bindable) && connection
+          expr
+        end
+
+        attr_reader :connection
+
+        def connection!
+          connection.tap{|c| ::Kernel.raise(UnboundError, "#{self} not bound") unless c }
+        end
+
+        def to_s
+          mods = @extensions
+            .map(&:name)
+            .compact
+            .reject{|x| x =~ /^Alf::|OwnMethods/}
+            .join(',')
+          "Lispy(#{mods})"
+        end
+        alias_method :inspect, :to_s
+
+      end # OwnMethods
+
+      # Creates a language instance
+      def initialize(helpers = [ ], connection = nil)
+        @connection = connection
+        super [ OwnMethods, Functional, Predicates ] + helpers
+      end
+
+      # Resolve DUM and DEE in ruby 1.9.2 context
+      def self.const_missing(name)
+        case name.to_s
+        when 'DEE' then ::Alf::Relation::DEE
+        when 'DUM' then ::Alf::Relation::DUM
+        else
+          super
+        end
+      end
+
+    end # class Lispy
+  end # module Lang
+end # module Alf

data/lib/alf-lang/alf/lang/object_oriented.rb

@@ -0,0 +1,26 @@
+require_relative 'oo/aggregation_methods'
+require_relative 'oo/algebra_methods'
+require_relative 'oo/rendering_methods'
+module Alf
+  module Lang
+    module ObjectOriented
+      include AggregationMethods
+      include AlgebraMethods
+      include RenderingMethods
+
+      def self.new(self_operand)
+        Module.new{
+          include ObjectOriented
+          define_method(:_self_operand) do
+            self_operand
+          end
+          define_method(:to_cog) do
+            self_operand.to_cog
+          end
+          private :_self_operand
+        }
+      end
+
+    end # module ObjectOriented
+  end # module Lang
+end # module Alf

data/lib/alf-lang/alf/lang/oo/aggregation_methods.rb

@@ -0,0 +1,19 @@
+module Alf
+  module Lang
+    module ObjectOriented
+      module AggregationMethods
+
+        def self.def_aggregator_method(name, clazz)
+          define_method(name) do |*args, &block|
+            clazz.new(*args, &block).aggregate(_self_operand)
+          end
+        end
+
+        Aggregator.listen do |name, clazz|
+          def_aggregator_method(name, clazz)
+        end
+
+      end # module AggregationMethods
+    end # module ObjectOriented
+  end # module Lang
+end # module Alf

data/lib/alf-lang/alf/lang/oo/algebra_methods.rb

@@ -0,0 +1,72 @@
+module Alf
+  module Lang
+    module ObjectOriented
+      module AlgebraMethods
+
+        def self.def_operator_method(name, clazz)
+          define_method(name) do |*args|
+            args.unshift(_self_operand)
+            operands, arguments = args[0...clazz.arity], args[clazz.arity..-1]
+            _operator_output clazz.new(operands, *arguments)
+          end
+        end
+
+        Algebra::Operator.listen do |name, clazz|
+          def_operator_method(name, clazz)
+        end
+
+        def allbut(attributes)
+          project(attributes, :allbut => true)
+        end
+
+        def +(other)
+          union(other)
+        end
+        alias :| :+
+
+        def -(other)
+          minus(other)
+        end
+
+        def *(other)
+          join(other)
+        end
+
+        def &(other)
+          intersect(other)
+        end
+
+        def =~(other)
+          matching(other)
+        end
+
+        def !~(other)
+          not_matching(other)
+        end
+
+        def tuple_extract
+          tuple = nil
+          each do |t|
+            raise NoSuchTupleError if tuple
+            tuple = t
+          end
+          tuple ||= yield if block_given?
+          raise NoSuchTupleError unless tuple or block_given?
+          Tuple(tuple)
+        end
+        alias_method :'tuple!', :tuple_extract
+
+      private
+
+        def _self_operand
+          self
+        end
+
+        def _operator_output(op)
+          op
+        end
+
+      end # module AlgebraMethods
+    end # module ObjectOriented
+  end # module Lang
+end # module Alf

data/lib/alf-lang/alf/lang/oo/rendering_methods.rb

@@ -0,0 +1,54 @@
+module Alf
+  module Lang
+    module ObjectOriented
+      module RenderingMethods
+
+        def self.def_renderer_method(name, clazz)
+          define_method(:"to_#{name}") do |*args|
+            options, io = nil
+            args.each do |arg|
+              options ||= arg if arg.is_a?(Hash)
+              io      ||= arg if arg.respond_to?(:<<)
+            end
+            to_array(options || {}) do |arr|
+              io ||= ""
+              clazz.new(arr, options).execute(io)
+              io
+            end
+          end
+        end
+
+        def to_array(options = {})
+          _with_ordering(options) do |o|
+            op = Alf::Engine::ToArray.new(to_cog, o)
+            block_given? ? yield(op) : op.to_a
+          end
+        end
+
+        def to_a(options = nil)
+          (options.nil? && defined?(super)) ? super() : to_array(options || {})
+        end
+
+        Renderer.listen do |name,clazz|
+          def_renderer_method(name, clazz)
+        end
+
+      private
+
+        def _with_ordering(options, &bl)
+          case options
+          when Array, Ordering
+            _with_ordering(:sort => options, &bl)
+          when Hash
+            ordering = options.delete(:order) || options.delete(:sort)
+            ordering = Ordering.coerce(ordering || [])
+            yield(ordering)
+          else
+            ::Kernel.raise "Invalid ordering `#{options}`"
+          end
+        end
+
+      end # module RenderingMethods
+    end # module ObjectOriented
+  end # module Lang
+end # module Alf

data/lib/alf-lang/alf/lang/predicates.rb

@@ -0,0 +1,17 @@
+module Alf
+  module Lang
+    module Predicates
+
+      [ :tautology, :contradiction,
+        :in, :eq, :neq,
+        :lt, :lte, :gt, :gte, :between ].each do |m|
+
+        define_method(m) do |*args|
+          Predicate.send(m, *args)
+        end
+
+      end
+
+    end # module Predicates
+  end # module Lang
+end # module Alf

data/lib/alf-optimizer/alf/optimizer.rb

@@ -0,0 +1,38 @@
+require_relative 'optimizer/restrict'
+module Alf
+  class Optimizer
+
+    def initialize
+      @processors = []
+    end
+
+    def call(expr)
+      @processors.inject(expr) do |c, (p,k)|
+        Search.new(p, k).call(c)
+      end
+    end
+
+    def register(processor, interest)
+      @processors << [processor, interest]
+      self
+    end
+
+    class Search < Algebra::Rewriter
+
+      def initialize(processor, interest)
+        @processor = processor
+        @interest = interest
+      end
+
+      def apply(expr)
+        if @interest === expr
+          @processor.call(expr, self)
+        else
+          super
+        end
+      end
+
+    end # class Search
+
+  end # class Optimizer
+end # module Alf

data/lib/alf-optimizer/alf/optimizer/restrict.rb

@@ -0,0 +1,169 @@
+module Alf
+  class Optimizer
+    class Restrict < Algebra::Rewriter
+      include Lang::Functional
+
+    ### overridings
+
+      def call(restrict, search = nil)
+        apply(restrict.operand, restrict.predicate)
+      rescue NotSupportedError
+        restrict
+      end
+
+      def restrict(operand, predicate)
+        check_constant(operand, predicate){ super }
+      end
+
+      def apply(operand, predicate)
+        check_constant(operand, predicate){ super }
+      end
+
+    # leaf Operand, recursion end :-)
+
+      def on_leaf_operand(expr, predicate)
+        restrict(expr, predicate)
+      end
+      alias :on_missing :on_leaf_operand
+
+    ### pass through, unoptimizable, binary optimizable
+
+      def on_pass_through(expr, predicate)
+        expr.with_operands(*expr.operands.map{|op| apply(op, predicate)})
+      end
+      alias :on_clip        :on_pass_through
+      alias :on_compact     :on_pass_through
+      alias :on_sort        :on_pass_through
+      alias :on_type_safe  :on_pass_through
+      alias :on_project     :on_pass_through
+      alias :on_intersect   :on_pass_through
+      alias :on_minus       :on_pass_through
+      alias :on_union       :on_pass_through
+
+      def on_unoptimizable(expr, predicate)
+        restrict(expr, predicate)
+      end
+      alias :on_generator     :on_unoptimizable
+      alias :on_infer_heading :on_unoptimizable
+
+      def on_binary_optimizable(expr, predicate)
+        binary_split(expr, predicate)
+      end
+      alias :on_join         :on_binary_optimizable
+      alias :on_matching     :on_binary_optimizable
+      alias :on_not_matching :on_binary_optimizable
+
+    ### non relational
+
+      def on_autonum(expr, predicate)
+        unary_split(expr, predicate, AttrList[expr.as])
+      end
+
+      def on_coerce(expr, predicate)
+        unary_split(expr, predicate, expr.coercions.to_attr_list)
+      end
+
+      def on_defaults(expr, predicate)
+        unary_split(expr, predicate, expr.defaults.to_attr_list)
+      end
+
+    ### relational
+
+      def on_extend(expr, predicate)
+        unary_split(expr, predicate, expr.ext.to_attr_list)
+      end
+
+      def on_group(expr, predicate)
+        unary_split(expr, predicate, AttrList[expr.as])
+      end
+
+      def on_quota(expr, predicate)
+        unary_split(expr, predicate, expr.summarization.to_attr_list)
+      end
+
+      def on_rank(expr, predicate)
+        unary_split(expr, predicate, AttrList[expr.as])
+      end
+
+      def on_rename(expr, predicate)
+        begin
+          predicate = predicate.rename(expr.renaming.invert)
+        rescue NotSupportedError
+          return restrict(expr, predicate)
+        end
+        on_pass_through(expr, predicate)
+      end
+
+      def on_restrict(expr, predicate)
+        apply(expr.operand, predicate & expr.predicate)
+      end
+
+      def on_summarize(expr, predicate)
+        unary_split(expr, predicate, expr.summarization.to_attr_list)
+      end
+
+      def on_ungroup(expr, predicate)
+        # TODO:
+        restrict(expr, predicate)
+      end
+
+      def on_unwrap(expr, predicate)
+        # TODO:
+        restrict(expr, predicate)
+      end
+
+      def on_wrap(expr, predicate)
+        unary_split(expr, predicate, AttrList[expr.as])
+      end
+
+    ### Splitting rules
+    private
+
+      def check_constant(operand, predicate)
+        if predicate.tautology?
+          operand
+        elsif predicate.contradiction?
+          Relation::DUM
+        else
+          yield
+        end
+      end
+
+      def unary_split(expr, predicate, attr_list)
+        top, down = predicate.and_split(attr_list)
+        restrict(expr.with_operand(apply(expr.operand, down)), top)
+      end
+
+      def binary_split(expr, predicate)
+        left_attrs, right_attrs = expr.operands.map{|op| op.heading.to_attr_list }
+        left_only,  right_only  = left_attrs - right_attrs, right_attrs - left_attrs
+
+        # left_top is the push-stopper due to right_only attributes
+        # right_top is the push-stopper due to left_only attributes
+        left_top,   left_pred   = predicate.and_split(right_only)
+        right_top,  right_pred  = predicate.and_split(left_only)
+
+        # left_rest is tautology if left_top is already fully covered by right_pred
+        left_rest,  _ = left_top.and_split(left_only)
+        # right_rest is a tautology if right_top is already fully covered by left_pred
+        right_rest, _ = right_top.and_split(right_only)
+
+        # basic join with restricted operands
+        join = expr.with_operands(
+          apply(expr.left, left_pred),
+          apply(expr.right, right_pred))
+
+        if left_top.tautology? || right_top.tautology?
+          # everything is already covered by one restriction pushed
+          join
+        elsif left_rest.tautology? && right_rest.tautology?
+          # everything is already covered by the conjunctions of pushed restrictions
+          join
+        else
+          restrict(join, left_rest & right_rest)
+        end
+      end
+
+    end # class Restrict
+  end # class Optimizer
+end # module Alf