alf-core 0.13.0

data/lib/alf-algebra/alf/algebra/support/classification.rb

@@ -0,0 +1,37 @@
+module Alf
+  module Algebra
+    module Classification
+
+      # @return true if this is a relational operator, false otherwise
+      def relational?
+        ancestors.include?(Relational)
+      end
+
+      # @return true if this is an experimental operator, false otherwise
+      def experimental?
+        ancestors.include?(Experimental)
+      end
+
+      # @return true if this is a non relational operator, false otherwise
+      def non_relational?
+        ancestors.include?(NonRelational)
+      end
+
+      # @return true if this operator is a zero-ary operator, false otherwise
+      def nullary?
+        arity == 0
+      end
+
+      # @return true if this operator is an unary operator, false otherwise
+      def unary?
+        arity == 1
+      end
+
+      # @return true if this operator is a binary operator, false otherwise
+      def binary?
+        arity == 2
+      end
+
+    end # module Classification
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/support/compiler.rb

@@ -0,0 +1,28 @@
+module Alf
+  module Algebra
+    class Compiler
+      include Visitor
+
+    # public interface
+
+      def call(expr, *args, &bl)
+        apply(expr, *args, &bl)
+      end
+
+    # copy all default implementation
+
+      def apply(expr, *args, &bl)
+        send to_method_name(expr, "on_"), expr, *args, &bl
+      end
+
+      def on_missing(expr, *args, &bl)
+        raise NotSupportedError, "Unable to compile `#{expr}`"
+      end
+
+      def not_supported(expr, *args, &bl)
+        raise NotSupportedError, "Unexpected operand `#{expr}`"
+      end
+
+    end # class Compiler
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/support/experimental.rb

@@ -0,0 +1,19 @@
+module Alf
+  module Algebra
+    #
+    # Marker for experimental operators
+    #
+    module Experimental
+
+      class << self
+        include Support::Registry
+
+        def included(mod)
+          super
+          register(mod, Experimental)
+        end
+      end
+
+    end # module Experimental
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/support/non_relational.rb

@@ -0,0 +1,16 @@
+module Alf
+  module Algebra
+    module NonRelational
+
+      class << self
+        include Support::Registry
+
+        def included(mod)
+          super
+          register(mod, NonRelational)
+        end
+      end
+
+    end # NonRelational
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/support/nullary.rb

@@ -0,0 +1,25 @@
+module Alf
+  module Algebra
+    #
+    # Specialization of Operator for operators without operands
+    #
+    module Nullary
+
+      # Class-level methods
+      module ClassMethods
+
+        # (see Operator::ClassMethods#arity)
+        def arity
+          0
+        end
+
+      end # module ClassMethods
+
+      def self.included(mod)
+        super
+        mod.extend(ClassMethods)
+      end
+
+    end # module Nullary
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/support/relational.rb

@@ -0,0 +1,16 @@
+module Alf
+  module Algebra
+    module Relational
+
+      class << self
+        include Support::Registry
+
+        def included(mod)
+          super
+          register(mod, Relational)
+        end
+      end
+
+    end # module Relational
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/support/rewriter.rb

@@ -0,0 +1,32 @@
+module Alf
+  module Algebra
+    class Rewriter
+      include Visitor
+
+    # public interface
+
+      def call(expr, search = nil)
+        apply(expr)
+      end
+
+    # copy all default implementation
+
+      def apply(expr, *args, &bl)
+        send to_method_name(expr, "on_"), expr, *args, &bl
+      end
+
+      def on_leaf_operand(expr, *args, &bl)
+        expr
+      end
+
+      def on_missing(expr, *args, &bl)
+        copy_and_apply(expr, *args, &bl)
+      end
+
+      def not_supported(expr, *args, &bl)
+        raise NotSupportedError, "Unexpected operand `#{expr}`"
+      end
+
+    end # class Rewriter
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/support/signature.rb

@@ -0,0 +1,195 @@
+module Alf
+  module Algebra
+    # Provides an operator signature
+    class Signature
+
+      # @return [Class] the operator class to which this signature belongs
+      attr_reader :operator
+
+      # @return [Array] signature arguments
+      attr_reader :arguments
+
+      # @return [Array] signature options
+      attr_reader :options
+
+      # Creates an empty signature instance
+      #
+      # @param [Class] the operator class to which this signature belongs
+      def initialize(operator)
+        @operator = operator
+        @arguments = []
+        @options = []
+        yield(self) if block_given?
+      end
+
+      # Adds an argument to the signature
+      #
+      # @param [Symbol] name argument name
+      # @param [Class] domain argument domain
+      # @param [Object] default (optional) default value
+      def argument(name, domain, default = nil, descr = nil)
+        arguments << [name, domain, default, descr]
+      end
+
+      # Adds an option to the signature
+      #
+      # @param [Symbol] name argument name
+      # @param [Class] domain argument domain
+      # @param [Object] default (optional) default value
+      def option(name, domain, default = nil, descr = nil)
+        options << [name, domain, default, descr]
+      end
+
+      # Builds an option parser instance `opt` prepared for installing options on
+      # `receiver`.
+      #
+      # @param [Hash|Operator] a receiver for option values
+      # @param [OptionParser] opt the parser to fill with options
+      # @return [OptionParser] `opt`
+      def option_parser(receiver, opt = OptionParser.new)
+        options.each do |option|
+          name, dom, defa, descr = option
+          opt.on(option_name(option), descr || "") do |val|
+            if receiver.is_a?(Hash)
+              receiver[name] = val
+            else
+              receiver.send(:"#{name}=", val)
+            end
+          end
+        end
+        opt
+      end
+
+      # Installs the signature on the operator class
+      #
+      # This method installs an attr reader and an attr writer for each
+      # signature argument and each signature option.
+      #
+      # @return [Hash] the default options to use
+      def install
+        clazz = operator
+        code = (arguments + options).each{|siginfo|
+          name, domain, = siginfo
+          clazz.send(:attr_reader, name)
+          clazz.send(:define_method, :"#{name}=") do |val|
+            instance_variable_set(:"@#{name}", Support.coerce(val, domain))
+          end
+          clazz.send(:private, :"#{name}=")
+        }
+        default_options
+      end
+
+      # Parses arguments `args` passed to the operator `initialize` and
+      # sets attributes accordingly on `receiver`.
+      #
+      # @param [Array] args an array of initialize arguments
+      # @param [Operator] receiver an operator instance
+      # @return [Operator] installed `receiver`
+      def parse_args(args, receiver)
+
+        # 1) Check and set operands, passed as an array as first argument
+        invalid_args!(args) unless args.first.is_a?(Array)
+        receiver.send(:operands=, args.shift.map{|op| Operand.coerce(op)})
+
+        # 2) Extract options if provided
+        optargs = default_options
+        if args.size == (1+arguments.size)
+          # options are passed as last argument
+          invalid_args!(args) unless args.last.is_a?(Hash)
+          optargs = optargs.merge(args.pop)
+        elsif args.size > arguments.size
+          # too many arguments here
+          invalid_args!(args)
+        end
+
+        # 3) Set options now, including default ones
+        optargs.each_pair do |name,val|
+          receiver.send(:"#{name}=", val)
+        end
+
+        # 4) Parse other arguments now
+        with_each_arg(args) do |name,dom,value|
+          invalid_args!(args) if value.nil?
+          receiver.send(:"#{name}=", value)
+        end
+
+        receiver
+      end
+
+      # Collects signature values on a given operator.
+      #
+      # This methods returns a triple `[datasets, arguments, options]` with
+      # the respective values collected on `op`.
+      #
+      # @param [Operator] op an operator, which should be an instance of
+      #                   `self.operator`
+      # @return [Array] a triple [datasets, arguments, options] with operands,
+      #                 then signature values
+      def collect_on(op)
+        oper = op.operands
+        args = arguments.map{|name,_| op.send(name) }
+        opts = Hash[options.map{|name,dom,defa,_|
+          val = op.send(name)
+          (val == defa) ? nil : [name, val]
+        }.compact]
+        [oper, args, opts]
+      end
+
+      # Returns a lispy synopsis for this signature
+      #
+      # Example:
+      #
+      #     Alf::Algebra::Project.signature.to_shell
+      #     # => "(project operand, attributes:AttrList, {allbut: Boolean})"
+      def to_lispy
+        cmd  = operator.rubycase_name
+        oper = operator.nullary? ? "" :
+              (operator.unary? ? "operand" : "left, right")
+
+        args = arguments.map{|name,dom,_|
+          dom.to_s =~ /::([A-Za-z]+)$/
+          "#{name}:#{$1}"
+        }.join(", ")
+        args = (args.empty? ? "#{oper}" : "#{oper}, #{args}").strip
+
+        opts = options.map{|name,dom,_|
+          dom.to_s =~ /::([A-Za-z]+)$/
+          "#{name}: #{$1}"
+        }.join(', ')
+        opts = opts.empty? ? "" : "{#{opts}}"
+
+        argopt = [args, opts].select{|s| !s.empty?}.join(', ')
+        "(#{cmd} #{argopt}".strip + ")"
+      end
+
+      private
+
+      # @return the default options as a Hash
+      def default_options
+        @default_options ||=
+          Hash[options.select{|opt| !opt[2].nil? }.
+                       map{|opt| [opt[0], opt[2]]}]
+      end
+
+      # @return the name to use in shell for `option`
+      def option_name(option)
+        name, domain, defa, = option
+        domain == Boolean ? "--#{name}" : "--#{name}=#{name.to_s.upcase}"
+      end
+
+      # Yields `(name,dom,value)` triples for each argument value
+      def with_each_arg(args)
+        arguments.zip(args).map do |sigpart,subargs|
+          name, dom, default = sigpart
+          val = Array(subargs).empty? ? default : subargs
+          yield(name, dom, val)
+        end
+      end
+
+      def invalid_args!(args, msg = "Invalid `#{args.inspect}` for #{self}")
+        raise ArgumentError, msg, caller
+      end
+
+    end # class Signature
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/support/to_dot.rb

@@ -0,0 +1,196 @@
+module Alf
+  module Algebra
+    class ToDot < Compiler
+      include Alf::Support::DotUtils
+
+      def call(expr, buf = "")
+        buf << "/* #{expr} */\n"
+        buf << "digraph \"Alf\" {\n"
+        buf << "node [width=0.375,height=0.25,shape=record];\n"
+        super
+        buf << "}\n"
+        buf
+      end
+
+      def on_unary_operator(expr, buf, label)
+        buf << "#{expr.object_id} [label=#{dot_label(label)}];\n"
+        apply(expr.operand, buf)
+        buf << "#{expr.object_id} -> #{expr.operand.object_id} [label=\"operand\"];\n"
+      end
+
+      def on_binary_operator(expr, buf, label)
+        buf << "#{expr.object_id} [label=#{dot_label(label)}];\n"
+        apply(expr.left, buf)
+        apply(expr.right, buf)
+        buf << "#{expr.object_id} -> #{expr.left.object_id} [label=\"left\"];\n"
+        buf << "#{expr.object_id} -> #{expr.right.object_id} [label=\"right\"];\n"
+      end
+
+      def on_leaf_operand(expr, buf = "")
+        case expr
+        when Operand::Named
+          buf << "#{expr.object_id} [label=#{dot_label(expr.name)}];\n"
+        when Operand::Proxy
+          buf << "#{expr.object_id} [label=#{dot_label(expr.subject)}];\n"
+        when Relvar::Virtual
+          buf << "#{expr.object_id} [label=\"Relvar::Virtual\"];\n"
+          apply(expr.expr, buf)
+          buf << "#{expr.object_id} -> #{expr.expr.object_id} [label=\"definition\"];\n"
+        when Relation
+          buf << "#{expr.object_id} [label=\"Relation\"];\n"
+        else
+          buf << "#{expr.object_id} [label=#{dot_label(expr)}];\n"
+        end
+      end
+
+      ###
+
+      def on_autonum(expr, buf = "")
+        on_unary_operator(expr, buf, "Autonum|#{as(expr)}")
+      end
+
+      def on_clip(expr, buf = "")
+        on_unary_operator(expr, buf, "Clip|#{allbut(expr)}#{attributes(expr)}")
+      end
+
+      def on_coerce(expr, buf = "")
+        on_unary_operator(expr, buf, "Coerce|#{expr.coercions}")
+      end
+
+      def on_compact(expr, buf = "")
+        on_unary_operator(expr, buf, "Compact")
+      end
+
+      def on_defaults(expr, buf = "")
+        on_unary_operator(expr, buf, "Defaults|#{strict}#{expr.defaults}")
+      end
+
+      def on_extend(expr, buf = "")
+        on_unary_operator(expr, buf, "Extend|#{expr.ext}")
+      end
+
+      def on_generator(expr, buf = "")
+        on_unary_operator(expr, buf, "Generator|#{expr.size}#{as(expr)}")
+      end
+
+      def on_group(expr, buf = "")
+        on_unary_operator(expr, buf, "Group|#{allbut(expr)}#{attributes(expr)}#{as(expr)}")
+      end
+
+      def on_infer_heading(expr, buf = "")
+        on_unary_operator(expr, buf, "InferHeading")
+      end
+
+      def on_intersect(expr, buf = "")
+        on_binary_operator(expr, buf, "Intersect")
+      end
+
+      def on_join(expr, buf = "")
+        on_binary_operator(expr, buf, "Join")
+      end
+
+      def on_matching(expr, buf = "")
+        on_binary_operator(expr, buf, "Matching")
+      end
+
+      def on_minus(expr, buf = "")
+        on_binary_operator(expr, buf, "Minus")
+      end
+
+      def on_not_matching(expr, buf = "")
+        on_binary_operator(expr, buf, "NotMatching")
+      end
+
+      def on_project(expr, buf = "")
+        on_unary_operator(expr, buf, "Project|#{allbut(expr)}#{attributes(expr)}")
+      end
+
+      def on_quota(expr, buf = "")
+        on_unary_operator(expr, buf, "Quota|#{by(expr)}")
+      end
+
+      def on_rank(expr, buf = "")
+        on_unary_operator(expr, buf, "Rank|#{order(expr)}#{as(expr)}")
+      end
+
+      def on_rename(expr, buf = "")
+        on_unary_operator(expr, buf, "Rename|#{renaming(expr)}")
+      end
+
+      def on_restrict(expr, buf = "")
+        on_unary_operator(expr, buf, "Restrict|#{predicate(expr)}")
+      end
+
+      def on_sort(expr, buf = "")
+        on_unary_operator(expr, buf, "Sort|#{ordering(expr)}")
+      end
+
+      def on_summarize(expr, buf = "")
+        on_unary_operator(expr, buf, "Sumarize|#{allbut(expr)}#{by(expr)}")
+      end
+
+      def on_type_safe(expr, buf = "")
+        on_unary_operator(expr, buf, "TypeSafe|#{strict(expr)}#{heading(expr)}")
+      end
+
+      def on_ungroup(expr, buf = "")
+        on_unary_operator(expr, buf, "Ungroup|#{expr.attribute}")
+      end
+
+      def on_union(expr, buf = "")
+        on_binary_operator(expr, buf, "Union")
+      end
+
+      def on_unwrap(expr, buf = "")
+        on_unary_operator(expr, buf, "Unwrap|#{expr.attribute}")
+      end
+
+      def on_wrap(expr, buf = "")
+        on_unary_operator(expr, buf, "Wrap|#{allbut(expr)}#{attributes(expr)}#{as(expr)}")
+      end
+
+    private
+
+      def allbut(expr)
+        expr.allbut ? 'allbut ' : ''
+      end
+
+      def as(expr)
+        "|#{expr.as}"
+      end
+
+      def attributes(expr)
+        "#{expr.attributes.to_a.join(',')}"
+      end
+
+      def by(expr)
+        "#{expr.by}"
+      end
+
+      def order(expr)
+        "#{expr.ordering}"
+      end
+
+      def renaming(expr)
+        "#{expr.renaming}"
+      end
+
+      def predicate(expr)
+        "#{expr.predicate}"
+      end
+
+      def heading(expr)
+        "#{expr.heading}"
+      end
+
+      def ordering(expr)
+        "#{expr.ordering}"
+      end
+
+      def strict(expr)
+        expr.strict ? "strict " : ''
+      end
+
+    end # class ToDot
+  end # module Algebra
+end # module Alf