alf-sequel 0.14.0 → 0.15.0

data/lib/alf/sequel/connection.rb

@@ -6,7 +6,11 @@ module Alf
     class Connection < Alf::Adapter::Connection
 
       def compiler
-        Compiler.new
+        @compiler ||= Compiler.new(self)
+      end
+
+      def translator
+        @translator ||= Translator.new(self)
       end
 
       require_relative 'connection/schema_methods'

data/lib/alf/sequel/connection/connection_methods.rb

@@ -28,12 +28,14 @@ module Alf
           @sequel_db.disconnect if @sequel_db && @sequel_db != conn_spec
         end
 
+        def close!
+          @sequel_db.disconnect if @sequel_db
+        end
+
         def with_sequel_db
           yield(sequel_db)
         end
 
-      private
-
         # Yields a Sequel::Database object
         def sequel_db
           @sequel_db ||= Adapter.sequel_db(conn_spec)

data/lib/alf/sequel/connection/schema_methods.rb

@@ -11,12 +11,8 @@ module Alf
           sequel_db[name]
         end
 
-        def cog(name, expr = nil, opts = {})
-          if as = opts[:alias]
-            Cog.new(expr, self, dataset: dataset(:"#{name}___#{as}"), as: as)
-          else
-            Cog.new(expr, self, dataset: dataset(name))
-          end
+        def cog(plan, expr)
+          plan.join(compiler).on_leaf_operand(plan, expr)
         end
 
         def heading(name)

data/lib/alf/sequel/connection/update_methods.rb

@@ -38,7 +38,7 @@ module Alf
         def with_dataset(name, predicate = nil)
           ds = name.is_a?(Symbol) ? sequel_db[name] : name
           if predicate && !predicate.tautology?
-            ds = ds.filter(Compiler::Predicate.call(predicate))
+            ds = ds.where(Translator.new(sequel_db).call(predicate.sexpr))
           end
           yield(ds) if block_given?
         end

data/lib/alf/sequel/loader.rb

@@ -1,2 +1,3 @@
 require "alf-core"
+require "alf-sql"
 require "sequel"

data/lib/alf/sequel/translator.rb

@@ -0,0 +1,198 @@
+module Alf
+  module Sequel
+    class Translator < Sexpr::Processor
+
+      def initialize(connection)
+        @connection = connection
+      end
+      attr_reader :connection
+
+      def on_with_exp(sexpr)
+        if sequel_db.select(1).supports_cte?
+          dataset = apply(sexpr.select_exp)
+          apply(sexpr.with_spec).each_pair do |name,subquery|
+            dataset = dataset.with(name, subquery)
+          end
+          dataset
+        else
+          apply(Sql::Processor::Flatten.new(Sql::Builder.new).call(sexpr))
+        end
+      end
+
+      def on_with_spec(sexpr)
+        sexpr.each_with_object({}){|child,hash|
+          next if child == :with_spec
+          hash[apply(child.table_name)] = apply(child.subquery)
+        }
+      end
+
+      def on_set_operator(sexpr)
+        left, right = apply(sexpr.left), apply(sexpr.right)
+        left.send(sexpr.first, right, all: sexpr.all?, from_self: false)
+      end
+      alias :on_union     :on_set_operator
+      alias :on_intersect :on_set_operator
+      alias :on_except    :on_set_operator
+
+      def on_select_exp(sexpr)
+        dataset   = sequel_db.select(1)
+        dataset   = dataset(apply(sexpr.from_clause)) if sexpr.from_clause
+        #
+        selection = apply(sexpr.select_list)
+        predicate = apply(sexpr.predicate)       if sexpr.predicate
+        order     = apply(sexpr.order_by_clause) if sexpr.order_by_clause
+        limit     = apply(sexpr.limit_clause)    if sexpr.limit_clause
+        offset    = apply(sexpr.offset_clause)   if sexpr.offset_clause
+        #
+        dataset   = dataset.select(*selection)
+        dataset   = dataset.distinct             if sexpr.distinct?
+        dataset   = dataset.where(predicate)     if predicate
+        dataset   = dataset.order_by(*order)     if order
+        dataset   = dataset.limit(limit, offset) if limit or offset
+        dataset
+      end
+
+      def on_select_list(sexpr)
+        sexpr.sexpr_body.map{|c| apply(c) }
+      end
+
+      def on_select_star(sexpr)
+        ::Sequel.lit('*')
+      end
+
+      def on_select_item(sexpr)
+        ::Sequel.as(apply(sexpr.left), apply(sexpr.right))
+      end
+
+      def on_qualified_name(sexpr)
+        apply(sexpr.last).qualify(sexpr.qualifier)
+      end
+
+      def on_column_name(sexpr)
+        ::Sequel.expr(sexpr.last.to_sym)
+      end
+
+      def on_from_clause(sexpr)
+        apply(sexpr.table_spec)
+      end
+
+      def on_table_name(sexpr)
+        ::Sequel.identifier(sexpr.last)
+      end
+
+      def on_cross_join(sexpr)
+        left, right = apply(sexpr.left), apply(sexpr.right)
+        dataset(left).cross_join(right)
+      end
+
+      def on_inner_join(sexpr)
+        left, right = apply(sexpr.left), apply(sexpr.right)
+        options = {qualify: false, table_alias: false}
+        dataset(left).join_table(:inner, right, nil, options){|*args|
+          apply(sexpr.predicate)
+        }
+      end
+
+      def on_table_as(sexpr)
+        ::Sequel.as(sexpr.table_name.to_sym, sexpr.as_name)
+      end
+
+      def on_subquery_as(sexpr)
+        ::Sequel.as(apply(sexpr.subquery), sexpr.as_name)
+      end
+
+      def on_order_by_clause(sexpr)
+        sexpr.sexpr_body.map{|c| apply(c)}
+      end
+
+      def on_order_by_term(sexpr)
+        ::Sequel.send(sexpr.direction, apply(sexpr.qualified_name))
+      end
+
+      def on_limit_clause(sexpr)
+        sexpr.last
+      end
+
+      def on_offset_clause(sexpr)
+        sexpr.last
+      end
+
+    ### Predicate
+
+      def on_identifier(sexpr)
+        ::Sequel.identifier(sexpr.last)
+      end
+
+      def on_qualified_identifier(sexpr)
+        ::Sequel.as(sexpr.qualifier, sexpr.name)
+      end
+
+      def on_tautology(sexpr)
+        ::Sequel::SQL::BooleanConstant.new(true)
+      end
+
+      def on_contradiction(sexpr)
+        ::Sequel::SQL::BooleanConstant.new(false)
+      end
+
+      def on_literal(sexpr)
+        sexpr.last.nil? ? nil : ::Sequel.expr(sexpr.last)
+      end
+
+      def on_eq(sexpr)
+        left, right = apply(sexpr.left), apply(sexpr.right)
+        ::Sequel.expr(left => right)
+      end
+
+      def on_neq(sexpr)
+        left, right = apply(sexpr.left), apply(sexpr.right)
+        ~::Sequel.expr(left => right)
+      end
+
+      def on_dyadic_comp(sexpr)
+        left, right = apply(sexpr.left), apply(sexpr.right)
+        left.send(sexpr.operator_symbol, right)
+      end
+      alias :on_lt  :on_dyadic_comp
+      alias :on_lte :on_dyadic_comp
+      alias :on_gt  :on_dyadic_comp
+      alias :on_gte :on_dyadic_comp
+
+      def on_in(sexpr)
+        left, right = apply(sexpr.identifier), sexpr.last
+        right = apply(right) if sexpr.subquery?
+        ::Sequel.expr(left => right)
+      end
+
+      def on_exists(sexpr)
+        apply(sexpr.last).exists
+      end
+
+      def on_not(sexpr)
+        ~apply(sexpr.last)
+      end
+
+      def on_and(sexpr)
+        body = sexpr.sexpr_body
+        body[1..-1].inject(apply(body.first)){|f,t| f & apply(t) }
+      end
+
+      def on_or(sexpr)
+        body = sexpr.sexpr_body
+        body[1..-1].inject(apply(body.first)){|f,t| f | apply(t) }
+      end
+
+    private
+
+      def sequel_db
+        connection.sequel_db
+      end
+
+      def dataset(expr)
+        return expr if ::Sequel::Dataset===expr
+        sequel_db[expr]
+      end
+
+    end # class Translator
+  end # module Sequel
+end # module Alf

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

@@ -39,13 +39,19 @@ module Alf
         def _run
           connection.with_dataset(@relvar_name) do |d|
             bk = best_candidate_key
-            if bk and bk.size == 1
+            supported = d.supports_returning?(:insert)
+
+            if supported and 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 }
+                d.insert(t.to_hash).first
+              }
+            elsif bk
+              pk_field_name = bk.to_a.first
+              @insert_result = @inserted.map{|t|
+                result = d.insert(t.to_hash)
+                bk.project_tuple(t) || { pk_field_name => result }
               }
             else
               @inserted.each{|t| d.insert(t.to_hash) }

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

@@ -39,9 +39,9 @@ module Alf
             mr
           else
             filter = mr.tuple_extract.to_hash
-            tuples = connection.cog(@relvar_name)
-                               .filter(nil, filter)
-                               .select(nil, pkey.to_a)
+            tuples = connection.dataset(@relvar_name)
+                               .filter(filter)
+                               .select(pkey.to_a)
             Relation(tuples)
           end
         end

data/lib/alf/sequel/version.rb

@@ -3,7 +3,7 @@ module Alf
     module Version
 
       MAJOR = 0
-      MINOR = 14
+      MINOR = 15
       TINY  = 0
 
       def self.to_s

data/spec/connection/test_heading.rb

@@ -6,7 +6,7 @@ module Alf
       subject{ sap.heading(:suppliers) }
 
       let(:expected){
-        Heading[:sid => Integer, :name => String, :status => Integer, :city => String]
+        Heading[:sid => String, :name => String, :status => Integer, :city => String]
       }
 
       it{ should eq(expected) }

data/spec/spec_helper.rb

@@ -2,12 +2,12 @@ $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'alf-sequel'
 require "rspec"
 require 'path'
-require_relative 'fixtures/sap.rb'
+require 'logger'
 
 module Helpers
 
   def sequel_database_path
-    Path.dir/'alf.db'
+    Path.dir/'sap.db'
   end
 
   def sequel_database_uri
@@ -15,15 +15,58 @@ module Helpers
   end
 
   def sequel_database_memory
-    "#{Alf::Sequel::Adapter.sqlite_protocol}::memory:"
+    "#{Alf::Sequel::Adapter.sqlite_protocol}:memory"
   end
 
   def sap
-    @sap ||= Alf.connect Path.relative("fixtures/sap.db")
+    sequel_db = ::Sequel.connect(sequel_database_uri)
+    Alf.connect(sequel_db, schema_cache: false)
   end
 
   def sap_memory
-    Alf.connect(SAP.create!(sequel_database_memory), schema_cache: false)
+    sequel_db = ::Sequel.connect(sequel_database_memory)
+    sequel_db.create_table(:suppliers) do
+      String  :sid
+      String  :name
+      Integer :status
+      String  :city
+      primary_key [:sid]
+      index :name, :unique => true
+    end
+    sequel_db.create_table(:parts) do
+      String :pid
+      String :name
+      String :color
+      Float  :weight
+      String :city
+      primary_key [:pid]
+    end
+    sequel_db.create_table(:supplies) do
+      foreign_key :sid, :suppliers, :null=>false, :key=>[:sid], :deferrable=>true
+      foreign_key :pid, :parts,     :null=>false, :key=>[:pid], :deferrable=>true
+      Integer :qty
+      primary_key [:sid, :pid]
+    end
+    [
+      {: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'}
+    ].each do |tuple|
+      sequel_db[:suppliers].insert(tuple)
+    end
+    [
+      {: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'}
+    ].each do |tuple|
+      sequel_db[:parts].insert(tuple)
+    end
+    Alf.connect(sequel_db, schema_cache: false)
   end
 
 end
@@ -31,5 +74,4 @@ end
 RSpec.configure do |c|
   c.include Helpers
   c.extend  Helpers
-  c.filter_run_excluding :ruby19 => (RUBY_VERSION < "1.9")
 end

data/spec/unit_of_work/delete/test_delete.rb

@@ -25,11 +25,11 @@ module Alf
 
         context 'when predicate is not a tautology' do
           let(:relvar_name){ :suppliers }
-          let(:predicate){ Predicate.eq(sid: 1) }
+          let(:predicate){ Predicate.eq(sid: "S1") }
 
           it 'removes only targetted tuples' do
             conn.dataset(relvar_name).should_not be_empty
-            conn.dataset(relvar_name).where(sid: 1).should be_empty
+            conn.dataset(relvar_name).where(sid: "S1").should be_empty
           end
         end
 

data/spec/unit_of_work/insert/test_run.rb

@@ -18,30 +18,30 @@ module Alf
           let(:relvar_name){ :suppliers }
 
           context 'with only one tuple' do
-            let(:tuples){ [{sid: 10, name: "Marcus", city: "Ouagadougou", status: 55}] }
+            let(:tuples){ [{sid: 'S10', name: "Marcus", city: "Ouagadougou", status: 55}] }
 
             it "inserts the tuple" do
-              conn.dataset(:suppliers).where(sid: 10).should_not be_empty
+              conn.dataset(:suppliers).where(sid: "S10").should_not be_empty
             end
 
             it 'keeps information about inserted tuples' do
-              uow.matching_relation.should eq(Relation sid: 10)
+              uow.matching_relation.should eq(Relation sid: 'S10')
             end
           end
 
           context 'with multiple tuples' do
             let(:tuples){ [
-              {sid: 10, name: "Marcus", city: "Ouagadougou", status: 55},
-              {sid: 11, name: "Demete", city: "Albertville", status: 56}
+              {sid: "S10", name: "Marcus", city: "Ouagadougou", status: 55},
+              {sid: "S11", name: "Demete", city: "Albertville", status: 56}
             ]}
 
             it "inserts the tuples" do
-              conn.dataset(:suppliers).where(sid: 10).should_not be_empty
-              conn.dataset(:suppliers).where(sid: 11).should_not be_empty
+              conn.dataset(:suppliers).where(sid: "S10").should_not be_empty
+              conn.dataset(:suppliers).where(sid: "S11").should_not be_empty
             end
 
             it 'keeps information about inserted tuples' do
-              uow.matching_relation.should eq(Relation sid: [10, 11])
+              uow.matching_relation.should eq(Relation sid: ["S10", "S11"])
             end
           end
         end
@@ -50,18 +50,16 @@ module Alf
           let(:relvar_name){ :supplies }
 
           let(:tuples){ [
-            {sid: 5, pid: 1},
-            {sid: 5, pid: 2}
+            {sid: "S5", pid: "P1"},
+            {sid: "S5", pid: "P2"}
           ]}
 
           it "inserts the tuples" do
-            conn.dataset(:supplies).where(sid: 5).to_a.size.should eq(2)
+            conn.dataset(:supplies).where(sid: "S5").to_a.size.should eq(2)
           end
 
           it 'keeps information about inserted tuples' do
-            pending{
-              uow.matching_relation.should eq(Relation(tuples))
-            }
+            uow.matching_relation.should eq(Relation(tuples))
           end
         end