alf-core 0.13.0

data/lib/alf-types/alf/types/type_check.rb

@@ -0,0 +1,58 @@
+module Alf
+  module Types
+    class TypeCheck
+
+      Error = Class.new(Alf::Error)
+
+      def initialize(heading, strict = true)
+        @heading   = heading
+        @attr_list = heading.to_attr_list
+        @strict    = strict
+      end
+
+      def strict?
+        @strict
+      end
+
+      def ===(tuple)
+        return nil unless TupleLike===tuple
+        case @attr_list <=> (AttrList.new(tuple.keys) rescue nil)
+        when 1      # some attributes are missing
+          return false if @strict
+        when -1     # extra attributes are present
+          return false
+        when nil    # both missing and extra attributes
+          return nil
+        end
+        tuple.to_hash.all?{|(k,v)| v.nil? or (@heading[k] === v) }
+      end
+
+      def check!(tuple)
+        unless TupleLike===tuple
+          error("not a tuple")
+        end
+        expec_keys, tuple_keys = @attr_list, AttrList.new(tuple.keys)
+        unless (missing = expec_keys - tuple_keys).empty?
+          error("Missing attribute", missing.to_a)
+        end
+        unless (extra = tuple_keys - expec_keys).empty?
+          error("Unexpected attribute", extra.to_a)
+        end
+        tuple.to_hash.each_pair do |k,v|
+          expected = @heading[k]
+          unless v.nil? or (expected === v)
+            error("Invalid value `#{k}` for `#{expected}`")
+          end
+        end
+      end
+
+      def error(msg, what = nil)
+        unless what.nil?
+          msg << (what.size == 1 ? " `" : "s `") << what.join(', ') << "`"
+        end
+        raise Error, msg
+      end
+
+    end # class TypeCheck
+  end # module Types
+end # module Alf

data/lib/alf-update/alf/update.rb

@@ -0,0 +1,3 @@
+require_relative 'update/inserter'
+require_relative 'update/deleter'
+require_relative 'update/updater'

data/lib/alf-update/alf/update/deleter.rb

@@ -0,0 +1,101 @@
+module Alf
+  module Update
+    class Deleter < Algebra::Compiler
+
+      ### overridings
+
+      def not_supported(expr, *args)
+        raise NotSupportedError, "Unable to delete through `#{expr}`"
+      end
+
+      ### Reusable rules
+
+      def apply_and_split(expr, predicate, list)
+        top, down = predicate.and_split(list)
+        if top.tautology?
+          apply(expr.operand, predicate)
+        else
+          raise NotSupportedError
+        end
+      end
+
+      def on_unary_delegate(expr, predicate)
+        apply(expr.operand, predicate)
+      end
+
+      ### leaf Operand, recursion end :-)
+
+      def on_leaf_operand(expr, predicate)
+        expr.to_relvar.delete(predicate)
+      end
+
+      ### non relational
+
+      def on_autonum(expr, predicate)
+        apply_and_split(expr, predicate, AttrList[expr.as])
+      end
+
+      alias :on_clip :on_unary_delegate
+
+      alias :on_coerce  :not_supported
+      alias :on_compact :not_supported
+
+      def on_defaults(expr, predicate)
+        apply_and_split(expr, predicate, expr.defaults.to_attr_list)
+      end
+
+      alias :on_generator  :not_supported
+      alias :on_type_safe :not_supported
+
+      alias :on_sort :on_unary_delegate
+
+      ### relational
+
+      def on_extend(expr, predicate)
+        apply_and_split(expr, predicate, expr.ext.to_attr_list)
+      end
+
+      def on_group(expr, predicate)
+        apply_and_split(expr, predicate, AttrList[expr.as])
+      end
+
+      alias :on_infer_heading :not_supported
+
+      def on_intersect(expr, predicate)
+        apply(expr.left, predicate)
+        apply(expr.right, predicate)
+      end
+
+      alias :on_join      :not_supported
+      alias :on_matching  :not_supported
+      alias :on_minus     :not_supported
+      alias :not_matching :not_supported
+
+      alias :on_project :on_unary_delegate
+
+      alias :on_quota :not_supported
+
+      def on_rank(expr, predicate)
+        apply_and_split(expr, predicate, AttrList[expr.as])
+      end
+
+      def on_rename(expr, predicate)
+        apply_and_split(expr, predicate, expr.renaming.invert.to_attr_list)
+      end
+
+      def on_restrict(expr, predicate)
+        apply(expr.operand, expr.predicate & predicate)
+      end
+
+      alias :on_summarize :not_supported
+      alias :on_ungroup   :not_supported
+      alias :on_union     :not_supported
+      alias :on_unwrap    :not_supported
+
+      def on_wrap(expr, predicate)
+        apply_and_split(expr, predicate, AttrList[expr.as])
+      end
+
+    end # class Deleter
+  end # module Update
+end # module Alf

data/lib/alf-update/alf/update/inserter.rb

@@ -0,0 +1,126 @@
+module Alf
+  module Update
+    class Inserter < Algebra::Compiler
+      include Lang::Functional
+
+      ### overridings
+
+      def call(expr, tuples)
+        super(expr, Algebra::Operand.coerce(tuples))
+      end
+
+      def not_supported(expr, *args)
+        raise NotSupportedError, "Unable to insert through `#{expr}`"
+      end
+
+      ### leaf Operand, recursion end :-)
+
+      def on_leaf_operand(expr, inserted)
+        inserted = Engine::Compiler.new.call(inserted)
+        expr.to_relvar.insert(inserted)
+      end
+
+      ### non relational
+
+      alias :on_coerce     :not_supported
+      alias :on_generator  :not_supported
+
+      def on_autonum(expr, inserted)
+        apply(expr.operand, allbut(inserted, [expr.as]))
+      end
+
+      def on_clip(expr, inserted)
+        defaults = expr.attributes.project_tuple(expr.defaults, expr.allbut)
+        apply(expr.operand, extend(inserted, defaults))
+      end
+
+      def on_compact(expr, inserted)
+        apply(expr.operand, inserted)
+      end
+
+      def on_defaults(expr, inserted)
+        apply(expr.operand, defaults(inserted, expr.defaults))
+      end
+
+      def on_sort(expr, inserted)
+        apply(expr.operand, sort(inserted, expr.ordering))
+      end
+
+      def on_type_safe(expr, inserted)
+        apply(expr.operand, type_safe(inserted, expr.type_safe_heading, strict: expr.strict))
+      end
+
+      ### relational
+
+      def on_extend(expr, inserted)
+        apply(expr.operand, allbut(inserted, expr.ext.to_attr_list))
+      end
+
+      def on_group(expr, inserted)
+        apply(expr.operand, ungroup(inserted, expr.as))
+      end
+
+      alias :on_infer_heading :not_supported
+
+      def on_intersect(expr, inserted)
+        apply(expr.left, inserted)
+        apply(expr.right, inserted)
+      end
+
+      def on_join(expr, inserted)
+        apply(expr.left,  project(inserted, expr.left.heading.to_attr_list))
+        apply(expr.right, project(inserted, expr.right.heading.to_attr_list))
+      end
+
+      def on_matching(expr, inserted)
+        # TODO: check that not_matching(inserted, expr.right) is empty
+        apply(expr.left, inserted)
+      end
+
+      def on_minus(expr, inserted)
+        # TODO: check that intersect(inserted, expr.right) is empty
+        apply(expr.left, inserted)
+      end
+
+      def on_not_matching(expr, inserted)
+        # TODO: check that matching(inserted, expr.right) is empty
+        apply(expr.left, inserted)
+      end
+
+      def on_project(expr, inserted)
+        defaults = expr.attributes.project_tuple(expr.defaults, expr.allbut)
+        apply(expr.operand, extend(inserted, defaults))
+      end
+
+      alias :on_quota :not_supported
+
+      def on_rank(expr, inserted)
+        apply(expr.operand, allbut(inserted, [expr.as]))
+      end
+
+      def on_rename(expr, inserted)
+        apply(expr.operand, rename(inserted, expr.renaming.invert))
+      end
+
+      def on_restrict(expr, inserted)
+        # TODO: check that restrict(inserted, expr.predicate)==inserted
+        apply(expr.operand, inserted)
+      end
+
+      alias :on_summarize :not_supported
+      alias :on_ungroup :not_supported
+
+      def on_union(expr, inserted)
+        apply(expr.left,  inserted)
+        apply(expr.right, inserted)
+      end
+
+      alias :on_unwrap :not_supported
+
+      def on_wrap(expr, inserted)
+        apply(expr.operand, unwrap(inserted, expr.as))
+      end
+
+    end # class Inserter
+  end # module Update
+end # module Alf

data/lib/alf-update/alf/update/updater.rb

@@ -0,0 +1,55 @@
+module Alf
+  module Update
+    class Updater < Algebra::Compiler
+
+      ### overridings
+
+      def not_supported(expr, *args)
+        raise NotSupportedError, "Unable to update through `#{expr}`"
+      end
+
+      ### leaf Operand, recursion end :-)
+
+      def on_leaf_operand(expr, updating, predicate)
+        expr.to_relvar.update(updating, predicate)
+      end
+
+      ### non relational
+
+      alias :on_autonum    :not_supported
+      alias :on_clip       :not_supported
+      alias :on_coerce     :not_supported
+      alias :on_compact    :not_supported
+      alias :on_defaults   :not_supported
+      alias :on_generator  :not_supported
+      alias :on_sort       :not_supported
+      alias :on_type_safe :not_supported
+
+      ### relational
+
+      alias :on_extend        :not_supported
+      alias :on_group         :not_supported
+      alias :on_infer_heading :not_supported
+      alias :on_intersect     :not_supported
+      alias :on_join          :not_supported
+      alias :on_matching      :not_supported
+      alias :on_minus         :not_supported
+      alias :not_matching     :not_supported
+      alias :on_project       :not_supported
+      alias :on_quota         :not_supported
+      alias :on_rank          :not_supported
+      alias :on_rename        :not_supported
+
+      def on_restrict(expr, updating, predicate)
+        apply(expr.operand, updating, expr.predicate & predicate)
+      end
+
+      alias :on_summarize     :not_supported
+      alias :on_ungroup       :not_supported
+      alias :on_union         :not_supported
+      alias :on_unwrap        :not_supported
+      alias :on_wrap          :not_supported
+
+    end # class Deleter
+  end # module Update
+end # module Alf

data/lib/alf-viewpoint/alf/viewpoint.rb

@@ -0,0 +1,41 @@
+module Alf
+  module Viewpoint
+
+    module ClassMethods
+
+      def parser(connection = nil)
+        Lang::Lispy.new([ self ], connection)
+      end
+
+      def parse(*args, &bl)
+        parser.parse(*args, &bl)
+      end
+
+      def native(as, native_name = as)
+        define_method(as) do
+          Algebra.named_operand(native_name)
+        end
+      end
+
+      def namespace(name, *viewpoints)
+        define_method(name) do
+          Lang::Lispy.new(viewpoints, connection)
+        end
+      end
+    end
+    extend ClassMethods
+
+    def self.included(mod)
+      mod.extend(ClassMethods)
+    end
+
+    NATIVE = Module.new{
+      include ::Alf::Viewpoint
+
+      def method_missing(name, *args, &bl)
+        (!args.empty? || bl) ? super : ::Alf::Algebra.named_operand(name)
+      end
+    }
+
+  end # module Viewpoint
+end # module Alf

data/spec/integration/__database__/group.alf

@@ -0,0 +1,3 @@
+#!/usr/bin/env alf
+(group :supplies, [:pid, :qty], :supplying)
+(group :supplies, [:sid], :supplying, :allbut => true)

data/spec/integration/__database__/parts.rash

@@ -0,0 +1,6 @@
+{:pid => 'P1', :name => 'Nut',   :color => 'Red',   :weight => 12.0, :city => 'London'}
+{:pid => 'P2', :name => 'Bolt',  :color => 'Green', :weight => 17.0, :city => 'Paris'}
+{:pid => 'P3', :name => 'Screw', :color => 'Blue',  :weight => 17.0, :city => 'Oslo'}
+{:pid => 'P4', :name => 'Screw', :color => 'Red',   :weight => 14.0, :city => 'London'}
+{:pid => 'P5', :name => 'Cam',   :color => 'Blue',  :weight => 12.0, :city => 'Paris'}
+{:pid => 'P6', :name => 'Cog',   :color => 'Red',   :weight => 19.0, :city => 'London'}

data/spec/integration/__database__/suppliers.rash

@@ -0,0 +1,5 @@
+{:sid => 'S1', :name => 'Smith', :status => 20, :city => 'London'}
+{:sid => 'S2', :name => 'Jones', :status => 10, :city => 'Paris'}
+{:sid => 'S3', :name => 'Blake', :status => 30, :city => 'Paris'}
+{:sid => 'S4', :name => 'Clark', :status => 20, :city => 'London'}
+{:sid => 'S5', :name => 'Adams', :status => 30, :city => 'Athens'}

data/spec/integration/__database__/suppliers_csv.csv

@@ -0,0 +1,6 @@
+sid,name,status,city
+S1,Smith,20,London
+S2,Jones,10,Paris
+S3,Blake,30,Paris
+S4,Clark,20,London
+S5,Adams,30,Athens

data/spec/integration/__database__/supplies.rash

@@ -0,0 +1,12 @@
+{:sid => 'S1', :pid => 'P1', :qty => 300}
+{:sid => 'S1', :pid => 'P2', :qty => 200}
+{:sid => 'S1', :pid => 'P3', :qty => 400}
+{:sid => 'S1', :pid => 'P4', :qty => 200}
+{:sid => 'S1', :pid => 'P5', :qty => 100}
+{:sid => 'S1', :pid => 'P6', :qty => 100}
+{:sid => 'S2', :pid => 'P1', :qty => 300}
+{:sid => 'S2', :pid => 'P2', :qty => 400}
+{:sid => 'S3', :pid => 'P2', :qty => 200}
+{:sid => 'S4', :pid => 'P2', :qty => 200}
+{:sid => 'S4', :pid => 'P4', :qty => 300}
+{:sid => 'S4', :pid => 'P5', :qty => 400}

data/spec/integration/algebra/test_to_dot.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+describe Alf::Algebra, 'to_dot' do
+
+  let(:rel) {
+    examples_database.parse do
+      group((project suppliers, [:city, :name]), [:name], :incity, allbut: true)
+    end
+  }
+
+  it 'recursively converts to sorted arrays' do
+    rel.to_dot.should =~ /digraph/
+  end
+
+end