alf-sequel 0.13.0

data/lib/alf/sequel/connection.rb

@@ -0,0 +1,23 @@
+module Alf
+  module Sequel
+    #
+    # Specialization of Alf::Connection to distribute Sequel datasets
+    #
+    class Connection < Alf::Adapter::Connection
+
+      def compiler
+        Compiler.new
+      end
+
+      require_relative 'connection/schema_methods'
+      require_relative 'connection/connection_methods'
+      require_relative 'connection/update_methods'
+      include SchemaMethods
+      include ConnectionMethods
+      include UpdateMethods
+
+      alias_method :to_s, :connection_uri
+
+    end # class Connection
+  end # module Sequel
+end # module Alf

data/lib/alf/sequel/loader.rb

@@ -0,0 +1,2 @@
+require "alf-core"
+require "sequel"

data/lib/alf/sequel/unit_of_work/atomic.rb

@@ -0,0 +1,35 @@
+module Alf
+  module Sequel
+    module UnitOfWork
+      module Atomic
+
+        def initialize(connection)
+          @connection = connection
+          @ran        = false
+          @failure    = nil
+        end
+        attr_reader :connection, :failure
+
+        def ran?
+          @ran
+        end
+
+        def failed?
+          not(@failure.nil?)
+        end
+
+        def run
+          raise IllegalStateError, "Unit of work already ran" if ran?
+          _run
+          self
+        rescue => ex
+          @failure = ex
+          raise
+        ensure
+          @ran = true
+        end
+
+      end # module Atomic
+    end # module UnitOfWork
+  end # module Sequel
+end # module Alf

data/lib/alf/sequel/unit_of_work/delete.rb

@@ -0,0 +1,24 @@
+module Alf
+  module Sequel
+    module UnitOfWork
+      class Delete
+        include UnitOfWork::Atomic
+
+        def initialize(connection, relvar_name, predicate)
+          super(connection)
+          @relvar_name   = relvar_name
+          @predicate     = predicate
+        end
+
+      private
+
+        def _run
+          connection.with_dataset(@relvar_name, @predicate) do |d|
+            d.delete
+          end
+        end
+
+      end # class Delete
+    end # module UnitOfWork
+  end # module Sequel
+end # module Alf

data/lib/alf/sequel/unit_of_work/insert.rb

@@ -0,0 +1,60 @@
+module Alf
+  module Sequel
+    module UnitOfWork
+      class Insert
+        include UnitOfWork::Atomic
+
+        def initialize(connection, relvar_name, inserted)
+          super(connection)
+          @relvar_name   = relvar_name
+          @inserted      = inserted
+          @insert_result = nil
+        end
+
+        def matching_relation
+          @matching_relation ||= begin
+            raise IllegalStateError, "Unit of work not ran" unless ran?
+            unless @insert_result
+              raise UnsupportedError, "Composite keys insertion feedback is unsupported."
+            end
+            Relation(@insert_result)
+          end
+        end
+
+      private
+
+        def candidate_keys
+          @candidate_keys ||= connection.keys(@relvar_name)
+        end
+
+        def primary_key
+          candidate_keys.first
+        end
+
+        def best_candidate_key
+          best = candidate_keys.to_a.find{|k| k.size == 1}
+          best || candidate_keys.first
+        end
+
+        def _run
+          connection.with_dataset(@relvar_name) do |d|
+            bk = best_candidate_key
+            if bk and bk.size == 1
+              pk_field_name = bk.to_a.first
+              supported = d.supports_returning?(:insert)
+              d = d.returning(pk_field_name) if supported
+              @insert_result = @inserted.map{|t|
+                res = d.insert(t.to_hash)
+                supported ? res.first : { pk_field_name => res }
+              }
+            else
+              @inserted.each{|t| d.insert(t.to_hash) }
+              @insert_result = nil
+            end
+          end
+        end
+
+      end # class Insert
+    end # module UnitOfWork
+  end # module Sequel
+end # module Alf

data/lib/alf/sequel/unit_of_work/update.rb

@@ -0,0 +1,60 @@
+module Alf
+  module Sequel
+    module UnitOfWork
+      class Update
+        include UnitOfWork::Atomic
+
+        def initialize(connection, relvar_name, updating, predicate)
+          super(connection)
+          @relvar_name = relvar_name
+          @updating    = updating
+          @predicate   = predicate
+        end
+
+        def matching_relation
+          raise IllegalStateError, "Unit of work not ran" unless ran?
+
+          # Check that updating is understandable
+          unless TupleLike===@updating
+            raise UnsupportedError, "Non-tuple update feedback is unsupported."
+          end
+          updating = @updating.to_hash
+          updating_keys = updating.keys
+
+          # extract all keys, and pk in particular
+          keys = connection.keys(@relvar_name)
+          pk   = keys.first
+
+          # Strategy 1), @updating contains a key
+          if key = keys.to_a.find{|k| !(k & updating_keys).empty? }
+            return Relation(@updating.project(key).to_hash)
+          end
+
+          raise UnsupportedError, "Unable to extract update matching relation"
+        end
+
+        def pk_matching_relation
+          mr, pkey = matching_relation, connection.keys(@relvar_name).first
+          if mr.to_attr_list == pkey.to_attr_list
+            mr
+          else
+            filter = mr.tuple_extract.to_hash
+            tuples = connection.cog(@relvar_name)
+                               .filter(filter)
+                               .select(pkey.to_a)
+            Relation(tuples)
+          end
+        end
+
+      private
+
+        def _run
+          connection.with_dataset(@relvar_name, @predicate) do |d|
+            d.update Tuple(@updating).to_hash
+          end
+        end
+
+      end # class Update
+    end # module UnitOfWork
+  end # module Sequel
+end # module Alf

data/lib/alf/sequel/unit_of_work.rb

@@ -0,0 +1,11 @@
+module Alf
+  module Sequel
+    module UnitOfWork
+
+    end # module UnitOfWork
+  end # module Sequel
+end # module Alf
+require_relative 'unit_of_work/atomic'
+require_relative 'unit_of_work/insert'
+require_relative 'unit_of_work/delete'
+require_relative 'unit_of_work/update'

data/lib/alf/sequel/version.rb

@@ -0,0 +1,16 @@
+module Alf
+  module Sequel
+    module Version
+
+      MAJOR = 0
+      MINOR = 13
+      TINY  = 0
+
+      def self.to_s
+        [ MAJOR, MINOR, TINY ].join('.')
+      end
+
+    end
+    VERSION = Version.to_s
+  end
+end

data/lib/alf/sequel.rb

@@ -0,0 +1,7 @@
+require_relative 'sequel/version'
+require_relative 'sequel/loader'
+require_relative 'sequel/adapter'
+require_relative 'sequel/connection'
+require_relative 'sequel/compiler'
+require_relative 'sequel/cog'
+require_relative 'sequel/unit_of_work'

data/lib/alf-sequel.rb

@@ -0,0 +1 @@
+require_relative "alf/sequel"

data/spec/adapter/test_recognize.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+module Alf
+  module Sequel
+    describe Adapter, "recognizes?" do
+
+      it "recognizes ::Sequel::Database objects" do
+        begin
+          db = ::Sequel.connect(sequel_database_memory)
+          Adapter.recognizes?(db).should be_true
+        ensure
+          db.disconnect if db
+        end
+      end
+
+      it "recognizes sqlite files" do
+        Adapter.recognizes?("#{sequel_database_path}").should be_true
+      end
+
+      it "recognizes in memory sqlite databases" do
+        Adapter.recognizes?(sequel_database_memory).should be_true
+      end
+
+      it "recognizes a Path to a sqlite databases" do
+        Adapter.recognizes?(sequel_database_path).should be_true
+        Adapter.recognizes?("nosuchone.db").should be_true
+      end
+
+      it "recognizes database uris" do
+        Adapter.recognizes?("postgres://localhost/database").should be_true
+        Adapter.recognizes?(sequel_database_uri).should be_true
+      end
+
+      it "recognizes a Hash ala Rails" do
+        config = {"adapter" => "sqlite", "database" => "#{sequel_database_path}"}
+        Adapter.recognizes?(config).should be_true
+        Adapter.recognizes?(Tools.symbolize_keys(config)).should be_true
+      end
+
+      it "should not be too permissive" do
+        Adapter.recognizes?(nil).should be_false
+      end
+
+      it "should let Adapter autodetect sqlite files" do
+        Alf::Adapter.autodetect(sequel_database_path).should be(Adapter)
+        Alf::Adapter.autodetect("#{sequel_database_path}").should be(Adapter)
+      end
+
+    end
+  end
+end

data/spec/compiler/test_clip.rb

@@ -0,0 +1,40 @@
+require 'compiler_helper'
+module Alf
+  module Sequel
+    describe Compiler, "clip" do
+
+      subject{ compile(expr) }
+
+      context 'when the operand is fully compilable' do
+        let(:expr){ clip(suppliers, [:sid, :name]) }
+
+        specify{
+          subject.sql.should eq("SELECT `t1`.`sid`, `t1`.`name` FROM `suppliers` AS 't1'")
+        }
+      end
+
+      context 'when the operand is fully compilable (distinct normally needed)' do
+        let(:expr){ clip(suppliers, [:city]) }
+
+        specify{
+          subject.sql.should eq("SELECT `t1`.`city` FROM `suppliers` AS 't1'")
+        }
+      end
+
+      context 'when the operand is fully compilable (allbut, distinct)' do
+        let(:expr){ clip(suppliers, [:sid, :name, :status], :allbut => true) }
+
+        specify{
+          subject.sql.should eq("SELECT `t1`.`city` FROM `suppliers` AS 't1'")
+        }
+      end
+
+      context 'when the operand is not compilable' do
+        let(:expr){ clip(an_operand, [:sid, :name]) }
+
+        it{ should be_a(Engine::Cog) }
+      end
+
+    end
+  end
+end

data/spec/compiler/test_compact.rb

@@ -0,0 +1,18 @@
+require 'compiler_helper'
+module Alf
+  module Sequel
+    describe Compiler, "compact" do
+
+      subject{ compile(expr) }
+
+      context 'when the operand is fully compilable' do
+        let(:expr){ compact(suppliers) }
+
+        specify{
+          subject.sql.should eq("SELECT DISTINCT * FROM `suppliers` AS 't1'")
+        }
+      end
+
+    end
+  end
+end

data/spec/compiler/test_extend.rb

@@ -0,0 +1,16 @@
+require 'compiler_helper'
+module Alf
+  module Sequel
+    describe Compiler, "extend" do
+
+      subject{ compile(expr) }
+
+      context 'with a native predicate' do
+        let(:expr){ extend(suppliers, :big => lambda{}) }
+      
+        it{ should be_a(Engine::SetAttr) }
+      end
+      
+    end
+  end
+end

data/spec/compiler/test_intersect.rb

@@ -0,0 +1,18 @@
+require 'compiler_helper'
+module Alf
+  module Sequel
+    describe Compiler, "intersect" do
+
+      subject{ compile(expr) }
+
+      context 'when the operand is fully compilable' do
+        let(:expr){ intersect(suppliers, supplies) }
+
+        specify do
+          subject.sql.should eq("SELECT * FROM (SELECT * FROM `suppliers` AS 't1' INTERSECT SELECT * FROM `supplies` AS 't2') AS 't3'")
+        end
+      end
+
+    end
+  end
+end

data/spec/compiler/test_join.rb

@@ -0,0 +1,18 @@
+require 'compiler_helper'
+module Alf
+  module Sequel
+    describe Compiler, "join" do
+
+      subject{ compile(expr) }
+
+      context 'when the operand is fully compilable' do
+        let(:expr){ join(suppliers, supplies) }
+
+        specify do
+          subject.sql.should eq("SELECT * FROM (SELECT * FROM `suppliers` AS 't1' INNER JOIN (SELECT * FROM `supplies` AS 't2') AS 't3' USING (`sid`)) AS 't3'")
+        end
+      end
+
+    end
+  end
+end

data/spec/compiler/test_leaf_operand.rb

@@ -0,0 +1,24 @@
+require 'compiler_helper'
+module Alf
+  module Sequel
+    describe Compiler, "leaf_operand" do
+
+      subject{ compile(expr) }
+
+      context 'on the proper context' do
+        let(:expr){ suppliers }
+
+        it{ should be_a(Cog) }
+      end
+
+      context 'on another context' do
+        let(:expr){ Algebra.named_operand(:suppliers, self) }
+
+        pending "support for multiple context is needed" do
+          it{ should_not be_a(Cog) }
+        end
+      end
+
+    end
+  end
+end

data/spec/compiler/test_matching.rb

@@ -0,0 +1,34 @@
+require 'compiler_helper'
+module Alf
+  module Sequel
+    describe Compiler, "matching" do
+
+      subject{ compile(expr) }
+
+      context 'when no common attributes' do
+        let(:expr){ matching(suppliers, project(supplies, [:part_id])) }
+
+        specify do
+          subject.sql.should eq("SELECT * FROM `suppliers` AS 't1' WHERE (EXISTS (SELECT `t2`.`part_id` FROM `supplies` AS 't2'))")
+        end
+      end
+
+      context 'when only one common attributes' do
+        let(:expr){ matching(suppliers, supplies) }
+
+        specify do
+          subject.sql.should eq("SELECT * FROM `suppliers` AS 't1' WHERE (`t1`.`sid` IN (SELECT `t2`.`sid` FROM `supplies` AS 't2'))")
+        end
+      end
+
+      context 'when many common attributes' do
+        let(:expr){ matching(suppliers, parts) }
+
+        specify do
+          subject.sql.should eq("SELECT * FROM `suppliers` AS 't1' WHERE (EXISTS (SELECT * FROM `parts` AS 't2' WHERE ((`t1`.`name` = `t2`.`name`) AND (`t1`.`city` = `t2`.`city`))))")
+        end
+      end
+
+    end
+  end
+end

data/spec/compiler/test_not_matching.rb

@@ -0,0 +1,34 @@
+require 'compiler_helper'
+module Alf
+  module Sequel
+    describe Compiler, "not_matching" do
+
+      subject{ compile(expr) }
+
+      context 'when no common attributes' do
+        let(:expr){ not_matching(suppliers, project(supplies, [:part_id])) }
+
+        specify do
+          subject.sql.should eq("SELECT * FROM `suppliers` AS 't1' WHERE NOT (EXISTS (SELECT `t2`.`part_id` FROM `supplies` AS 't2'))")
+        end
+      end
+
+      context 'when only one common attributes' do
+        let(:expr){ not_matching(suppliers, supplies) }
+
+        specify do
+          subject.sql.should eq("SELECT * FROM `suppliers` AS 't1' WHERE (`t1`.`sid` NOT IN (SELECT `t2`.`sid` FROM `supplies` AS 't2'))")
+        end
+      end
+
+      context 'when many common attributes' do
+        let(:expr){ not_matching(suppliers, parts) }
+
+        specify do
+          subject.sql.should eq("SELECT * FROM `suppliers` AS 't1' WHERE NOT (EXISTS (SELECT * FROM `parts` AS 't2' WHERE ((`t1`.`name` = `t2`.`name`) AND (`t1`.`city` = `t2`.`city`))))")
+        end
+      end
+
+    end
+  end
+end

data/spec/compiler/test_predicate.rb

@@ -0,0 +1,141 @@
+require 'compiler_helper'
+module Alf
+  module Sequel
+    class Compiler
+      describe Predicate do
+
+        let(:p)        { Alf::Predicate              }
+        let(:compiler) { Predicate.new               }
+        let(:dataset)  { sap.cog(:suppliers).dataset }
+        let(:compiled) { compiler.call(expr)         }
+
+        subject{ dataset.literal(compiled) }
+
+        context 'tautology' do
+          let(:expr){ p.tautology }
+
+          it{ should eq("(1 = 1)") }
+        end
+
+        context 'contradiction' do
+          let(:expr){ p.contradiction }
+
+          it{ should eq("(1 = 0)") }
+        end
+
+        context 'var_ref' do
+          let(:expr){ p.var_ref(:x) }
+
+          it{ should eq("`x`") }
+        end
+
+        context 'literal' do
+          let(:expr){ p.literal(12) }
+
+          it{ should eq("12") }
+        end
+
+        context 'eq(var, literal)' do
+          let(:expr){ p.eq(:x, 12) }
+
+          it{ should eq("(`x` = 12)") }
+        end
+
+        context 'neq(var, literal)' do
+          let(:expr){ p.neq(:x, 12) }
+
+          it{ should eq("(`x` != 12)") }
+        end
+
+        context 'eq(var, nil)' do
+          let(:expr){ p.eq(:x, nil) }
+
+          it{ should eq("(`x` IS NULL)") }
+        end
+
+        context 'eq(var, var)' do
+          let(:expr){ p.eq(:x, :y) }
+
+          it{ should eq("(`x` = `y`)") }
+        end
+
+        context 'lt(var, literal)' do
+          let(:expr){ p.lt(:x, 2) }
+
+          it{ should eq("(`x` < 2)") }
+        end
+
+        context 'lte(var, literal)' do
+          let(:expr){ p.lte(:x, 2) }
+
+          it{ should eq("(`x` <= 2)") }
+        end
+
+        context 'gt(var, literal)' do
+          let(:expr){ p.gt(:x, 2) }
+
+          it{ should eq("(`x` > 2)") }
+        end
+
+        context 'gte(var, literal)' do
+          let(:expr){ p.gte(:x, 2) }
+
+          it{ should eq("(`x` >= 2)") }
+        end
+
+        context 'not(var)' do
+          let(:expr){ p.not(:x) }
+
+          it{ should eq("NOT `x`") }
+        end
+
+        context 'not(tautology)' do
+          let(:expr){ p.not(true) }
+
+          it{ should eq("(1 = 0)") }
+        end
+
+        context 'and' do
+          let(:expr){ p.eq(:x, 2) & p.eq(:y, 3) }
+
+          it{ should eq("((`x` = 2) AND (`y` = 3))") }
+        end
+
+        context 'or' do
+          let(:expr){ p.eq(:x, 2) | p.eq(:y, 3) }
+
+          it{ should eq("((`x` = 2) OR (`y` = 3))") }
+        end
+
+        context 'comp' do
+          let(:expr){ p.comp(:lt, :x => 2, :y => 3) }
+
+          it{ should eq("((`x` < 2) AND (`y` < 3))") }
+        end
+
+        context 'in' do
+          let(:expr){ p.in(:x, [2, 3]) }
+
+          it{ should eq("(`x` IN (2, 3))") }
+        end
+
+        context 'in with a dataset at right' do
+          let(:expr){ p.in(:x, dataset) }
+
+          it{ should eq("(`x` IN (SELECT * FROM `suppliers`))") }
+        end
+
+        context 'native' do
+          let(:expr){ p.native(lambda{}) }
+
+          specify{
+            lambda{
+              subject
+            }.should throw_symbol(:pass)
+          }
+        end
+
+      end
+    end
+  end
+end