alf-core 0.13.0

data/lib/alf-algebra/alf/algebra/operand/named.rb

@@ -0,0 +1,36 @@
+module Alf
+  module Algebra
+    module Operand
+      class Named
+        include Operand
+
+        def initialize(name, connection = nil)
+          @name = name
+          @connection = connection
+        end
+        attr_reader :name
+
+        def keys
+          connection!.keys(name)
+        end
+
+        def heading
+          connection!.heading(name)
+        end
+
+        def to_relvar
+          Relvar::Base.new(name, connection)
+        end
+
+        def to_s
+          "Operand::Named(#{name.inspect})"
+        end
+
+        def to_lispy
+          name.to_s
+        end
+
+      end # Named
+    end # module Operand
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/operand/proxy.rb

@@ -0,0 +1,25 @@
+module Alf
+  module Algebra
+    module Operand
+      class Proxy
+        include Operand
+
+        def initialize(subject)
+          @subject = subject
+        end
+        attr_reader :subject
+
+        def to_cog
+          return subject.to_cog if subject.respond_to?(:to_cog)
+          Alf::Engine::Leaf.new(subject)
+        end
+
+        def to_relvar
+          return subject.to_relvar if subject.respond_to?(:to_relvar)
+          super
+        end
+
+      end # class Proxy
+    end # module Operand
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/operator.rb

@@ -0,0 +1,134 @@
+module Alf
+  module Algebra
+    module Operator
+      include Operand
+
+    ### Class-based tools
+
+      # Encapsulates method that allows making operator introspection, that is,
+      # knowing operator cardinality and similar stuff.
+      module ClassMethods
+
+        # Returns the ruby case name of this operator
+        def rubycase_name
+          Support.rubycase_name(self)
+        end
+
+        # Installs or set the operator signature
+        def signature
+          if block_given?
+            @signature = Signature.new(self, &Proc.new)
+            @signature.install
+          else
+            @signature ||= Signature.new(self)
+          end
+        end
+
+      end # module ClassMethods
+
+      class << self
+        include Support::Registry
+
+        # Installs the class methods needed on all operators
+        def included(mod)
+          super
+          mod.extend(ClassMethods)
+          mod.extend(Classification)
+          register(mod, Operator)
+        end
+      end # class << self
+
+    ### PORO
+
+      # @param [Array] operands Operator operands
+      attr_accessor :operands
+
+      # Create an operator instance
+      def initialize(*args)
+        signature.parse_args(args, self)
+      end
+
+      # Binds to a connection
+      def bind(connection)
+        super{|c| c.operands = operands.map{|op| op.bind(connection) } }
+      end
+
+      # @return [Signature] the operator signature.
+      def signature
+        self.class.signature
+      end
+
+    ### -> to_xxx
+
+      def to_lispy
+        cmdname  = self.class.rubycase_name
+        oper, args, opts = signature.collect_on(self)
+        args = opts.empty? ? (oper + args) : (oper + args + [ opts ])
+        args = args.map{|arg| Support.to_lispy(arg) }
+        "#{cmdname}(#{args.join(', ')})"
+      end
+      alias :to_s :to_lispy
+
+      def to_relvar
+        Relvar::Virtual.new(self, connection)
+      end
+
+    ### identity and pseudo-mutability
+
+      def with_operands(*operands)
+        dup{|copy|
+          copy.operands = operands
+          copy.clean_computed_attributes!
+        }
+      end
+
+      def dup(&bl)
+        bl.nil? ? super : super.tap(&bl)
+      end
+
+      def ==(other)
+        (other.object_id == self.object_id) ||
+        ((other.class == self.class) &&
+         (other.operands == self.operands) &&
+         (other.signature.collect_on(self) == self.signature.collect_on(self)))
+      end
+
+    protected
+
+      def clean_computed_attributes!
+        @heading = nil
+        @common_heading = nil
+        @common_attributes = nil
+        @keys = nil
+      end
+
+    end # module Operator
+  end # module Algebra
+end # module Alf
+require_relative 'operator/autonum'
+require_relative 'operator/defaults'
+require_relative 'operator/compact'
+require_relative 'operator/sort'
+require_relative 'operator/clip'
+require_relative 'operator/coerce'
+require_relative 'operator/type_safe'
+require_relative 'operator/generator'
+
+require_relative 'operator/extend'
+require_relative 'operator/project'
+require_relative 'operator/restrict'
+require_relative 'operator/rename'
+require_relative 'operator/union'
+require_relative 'operator/minus'
+require_relative 'operator/intersect'
+require_relative 'operator/join'
+require_relative 'operator/matching'
+require_relative 'operator/not_matching'
+require_relative 'operator/wrap'
+require_relative 'operator/unwrap'
+require_relative 'operator/group'
+require_relative 'operator/ungroup'
+require_relative 'operator/summarize'
+require_relative 'operator/rank'
+require_relative 'operator/quota'
+require_relative 'operator/infer_heading'

data/lib/alf-algebra/alf/algebra/operator/autonum.rb

@@ -0,0 +1,20 @@
+module Alf
+  module Algebra
+    class Autonum
+      include Operator, NonRelational, Unary
+
+      signature do |s|
+        s.argument :as, AttrName, :autonum
+      end
+
+      def heading
+        @heading ||= operand.heading + Heading[as => Integer]
+      end
+
+      def keys
+        @keys ||= operand.keys + [ [ as ] ]
+      end
+
+    end # class Autonum
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/operator/clip.rb

@@ -0,0 +1,28 @@
+module Alf
+  module Algebra
+    class Clip
+      include Operator, NonRelational, Unary
+
+      signature do |s|
+        s.argument :attributes, AttrList, []
+        s.option   :allbut,     Boolean, false, "Apply an allbut clipping?"
+      end
+
+      def heading
+        @heading ||= operand.heading.project(attributes, allbut)
+      end
+
+      def keys
+        @keys ||= operand.keys.
+                          project(attributes, allbut).
+                          compact.
+                          if_empty{ Keys[ heading.to_attr_list ] }
+      end
+
+      def stay_attributes
+        allbut ? heading.to_attr_list : attributes
+      end
+
+    end # class Clip
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/operator/coerce.rb

@@ -0,0 +1,20 @@
+module Alf
+  module Algebra
+    class Coerce
+      include Operator, NonRelational, Unary
+
+      signature do |s|
+        s.argument :coercions, Heading, {}
+      end
+
+      def heading
+        @heading ||= operand.heading.merge(coercions)
+      end
+
+      def keys
+        @keys ||= operand.keys
+      end
+
+    end # class Coerce
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/operator/compact.rb

@@ -0,0 +1,19 @@
+module Alf
+  module Algebra
+    class Compact
+      include Operator, NonRelational, Unary
+
+      signature do |s|
+      end
+
+      def heading
+        @heading ||= operand.heading
+      end
+
+      def keys
+        @keys ||= operand.keys.if_empty{ Keys[ heading.to_attr_list ] }
+      end
+
+    end # class Compact
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/operator/defaults.rb

@@ -0,0 +1,24 @@
+module Alf
+  module Algebra
+    class Defaults
+      include Operator, NonRelational, Unary
+
+      signature do |s|
+        s.argument :defaults, TupleComputation, {}
+        s.option   :strict,   Boolean, false, "Restrict to default attributes only?"
+      end
+
+      def heading
+        @heading ||= begin
+          defh = defaults.to_heading
+          strict ? defh : operand.heading.merge(defh)
+        end
+      end
+
+      def keys
+        @keys ||= operand.keys
+      end
+
+    end # class Defaults
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/operator/extend.rb

@@ -0,0 +1,23 @@
+module Alf
+  module Algebra
+    class Extend
+      include Operator, Relational, Unary
+
+      signature do |s|
+        s.argument :ext, TupleComputation, {}
+      end
+
+      def heading
+        @heading ||= operand.heading.merge(ext.to_heading)
+      end
+
+      def keys
+        @keys ||= begin
+          attrs = ext.to_attr_list
+          operand.keys.reject{|k| k.intersect?(attrs) }
+        end
+      end
+
+    end # class Extend
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/operator/generator.rb

@@ -0,0 +1,21 @@
+module Alf
+  module Algebra
+    class Generator
+      include Operator, NonRelational, Nullary
+
+      signature do |s|
+        s.argument :size, Size, 10
+        s.argument :as,   AttrName, :num
+      end
+
+      def heading
+        @heading ||= Heading[as => Integer]
+      end
+
+      def keys
+        @keys ||= Keys[ [as] ]
+      end
+
+    end # class Generator
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/operator/group.rb

@@ -0,0 +1,28 @@
+module Alf
+  module Algebra
+    class Group
+      include Operator, Relational, Unary
+
+      signature do |s|
+        s.argument :attributes, AttrList, []
+        s.argument :as,         AttrName, :group
+        s.option   :allbut,     Boolean,  false, 'Group all but specified attributes?'
+      end
+
+      def heading
+        @heading ||= begin
+          keep, sub = operand.heading.split(attributes, !allbut)
+          keep.merge(as => Relation[sub])
+        end
+      end
+
+      def keys
+        @keys ||= operand.keys.map{|k|
+          proj = k.project(attributes, !allbut)
+          proj.empty? ? AttrList[as] : proj
+        }.freeze
+      end
+
+    end # class Group
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/operator/infer_heading.rb

@@ -0,0 +1,19 @@
+module Alf
+  module Algebra
+    class InferHeading
+      include Operator, Relational, Unary, Experimental
+
+      signature do |s|
+      end
+
+      def heading
+        raise NotSupportedError
+      end
+
+      def keys
+        @keys ||= Keys[ [] ]
+      end
+
+    end # class InferHeading
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/operator/intersect.rb

@@ -0,0 +1,24 @@
+module Alf
+  module Algebra
+    class Intersect
+      include Operator, Relational, Binary
+
+      signature do |s|
+      end
+
+      def heading
+        @heading ||= left.heading + right.heading
+      end
+
+      def keys
+        @keys ||= begin
+          k1s, k2s = left.keys, right.keys
+          k2s = k2s.reject{|k| k1s.any?{|l| k.superset?(l) } }
+          k1s = k1s.reject{|k| k2s.any?{|l| k.superset?(l) } }
+          k1s + k2s
+        end
+      end
+
+    end # class Intersect
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/operator/join.rb

@@ -0,0 +1,27 @@
+module Alf
+  module Algebra
+    class Join
+      include Operator, Relational, Binary
+
+      signature do |s|
+      end
+
+      def heading
+        @heading ||= left.heading + right.heading
+      end
+
+      def keys
+        @keys ||= begin
+          keys = []
+          left.keys.each do |k1|
+            right.keys.each do |k2|
+              keys << (k1 | k2)
+            end
+          end
+          Keys.new keys.uniq
+        end
+      end
+
+    end # class Join
+  end # module Algebra
+end # module Alf