alf-sequel 0.13.0

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+# 0.13.0 / 2013-07-29
+
+The 0.13.0 version is a new birthday for alf. See `alf` main for CHANGELOG
+history.

data/Gemfile

@@ -0,0 +1,19 @@
+source 'http://rubygems.org'
+
+group :runtime do
+  #gem "alf-core", :git => "git://github.com/alf-tool/alf-core.git"
+  gem "alf-core", "~> 0.13.0"
+  gem "sequel", "~> 3.48"
+end
+
+group :test do
+  gem "rake", "~> 10.1"
+  gem "rspec", "~> 2.14"
+  gem "sqlite3", "~> 1.3",      :platforms => ['mri', 'rbx']
+  gem "jdbc-sqlite3", "~> 3.7", :platforms => ['jruby']
+end
+
+group :development do
+  gem "rake", "~> 10.1"
+  gem "rspec", "~> 2.14"
+end

data/Gemfile.lock

@@ -0,0 +1,38 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    alf-core (0.13.0)
+      domain (~> 1.0)
+      myrrha (~> 3.0)
+      path (~> 1.3)
+      sexpr (~> 0.5.1)
+    diff-lcs (1.2.4)
+    domain (1.0.0)
+    jdbc-sqlite3 (3.7.2.1)
+    myrrha (3.0.0)
+      domain (~> 1.0)
+    path (1.3.1)
+    rake (10.1.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.4)
+    rspec-expectations (2.14.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.1)
+    sequel (3.48.0)
+    sexpr (0.5.1)
+    sqlite3 (1.3.7)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  alf-core (~> 0.13.0)
+  jdbc-sqlite3 (~> 3.7)
+  rake (~> 10.1)
+  rspec (~> 2.14)
+  sequel (~> 3.48)
+  sqlite3 (~> 1.3)

data/LICENCE.md

@@ -0,0 +1,22 @@
+# The MIT Licence
+
+    Copyright (c) 2012 - Bernard Lambeau
+
+    Permission is hereby granted, free of charge, to any person obtaining
+    a copy of this software and associated documentation files (the
+    "Software"), to deal in the Software without restriction, including
+    without limitation the rights to use, copy, modify, merge, publish,
+    distribute, sublicense, and/or sell copies of the Software, and to
+    permit persons to whom the Software is furnished to do so, subject to
+    the following conditions:
+
+    The above copyright notice and this permission notice shall be
+    included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+    LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,12 @@
+sequel.gemspec
+sequel.noespec
+CHANGELOG.md
+Gemfile
+Gemfile.lock
+lib/**/*
+LICENCE.md
+Manifest.txt
+Rakefile
+README.md
+spec/**/*
+tasks/**/*

data/README.md

@@ -0,0 +1,11 @@
+# Alf::Sequel
+
+[![Build Status](https://secure.travis-ci.org/alf-tool/alf-sequel.png)](http://travis-ci.org/alf-tool/alf-sequel)
+[![Dependency Status](https://gemnasium.com/alf-tool/alf-sequel.png)](https://gemnasium.com/alf-tool/alf-sequel)
+
+A sequel adapter for alf
+
+## Links
+
+http://github.com/alf-tool/alf
+http://github.com/alf-tool/alf-sequel

data/Rakefile

@@ -0,0 +1,11 @@
+# We run tests by default
+task :default => :test
+
+#
+# Install all tasks found in tasks folder
+#
+# See .rake files there for complete documentation.
+#
+Dir["tasks/*.rake"].each do |taskfile|
+  load taskfile
+end

data/lib/alf/sequel/adapter.rb

@@ -0,0 +1,57 @@
+module Alf
+  module Sequel
+    class Adapter < Alf::Adapter
+
+      class << self
+
+        def recognizes?(conn_spec)
+          case conn_spec
+          when ::Sequel::Database
+            true
+          when String
+            require 'uri'
+            uri = URI::parse(conn_spec) rescue nil
+            (uri && uri.scheme) or looks_a_sqlite_file?(conn_spec)
+          when Hash
+            conn_spec = Tools.symbolize_keys(conn_spec)
+            conn_spec[:adapter] && conn_spec[:database]
+          else
+            looks_a_sqlite_file?(conn_spec)
+          end
+        end
+
+        # Returns true if `f` looks like a sqlite file
+        def looks_a_sqlite_file?(f)
+          return false unless Path.like?(f)
+          path = Path(f)
+          path.parent.directory? and ['db', 'sqlite', 'sqlite3'].include?(path.ext)
+        end
+
+        def sqlite_protocol
+          defined?(JRUBY_VERSION) ? "jdbc:sqlite" : "sqlite"
+        end
+
+        def sequel_db(conn_spec)
+          require 'sequel' unless defined?(::Sequel)
+          case conn_spec
+          when ::Sequel::Database
+            conn_spec
+          when String, Path
+            conn_spec = "#{sqlite_protocol}://#{conn_spec}" if looks_a_sqlite_file?(conn_spec)
+            ::Sequel.connect(conn_spec)
+          else
+            raise ArgumentError, "Unrecognized connection specification `#{conn_spec.inspect}`"
+          end
+        end
+
+      end # class << self
+
+      # Returns a low-level connection on this adapter
+      def connection
+        Connection.new(conn_spec)
+      end
+
+      ::Alf::Adapter.register(:sequel, self)
+    end # class Adapter
+  end # module Sequel
+end # module Alf

data/lib/alf/sequel/cog.rb

@@ -0,0 +1,92 @@
+module Alf
+  module Sequel
+    class Cog
+      include Engine::Cog
+
+      def initialize(connection, opts)
+        @connection = connection
+        @opts = opts
+      end
+      attr_reader :connection, :opts
+
+      def as;         opts[:as];         end
+      def dataset;    opts[:dataset];    end
+
+    ### Cog
+
+      def to_relation
+        Relation.coerce(to_a)
+      end
+
+      def each
+        dataset.each(&Proc.new)
+      end
+
+    ### Delegation to Dataset, that is, facade over ::Sequel itself
+
+      def select(attrs)
+        branch dataset: dataset.select(*qualify(attrs))
+      end
+
+      def rename(attrs, opts)
+        branch dataset: dataset.select(*qualify(attrs)).from_self(opts),
+                    as: opts[:alias]
+      end
+
+      def distinct(*args, &bl)
+        branch dataset: dataset.distinct(*args, &bl)
+      end
+
+      def order(*args, &bl)
+        branch dataset: dataset.order(*args, &bl)
+      end
+
+      def filter(*args, &bl)
+        branch dataset: dataset.filter(*args, &bl)
+      end
+
+      def intersect(other, opts={})
+        branch dataset: dataset.intersect(other.dataset, opts),
+                    as: opts[:alias]
+      end
+
+      def join(other, cols, opts={})
+        join = dataset.inner_join(other.dataset, cols, :table_alias => opts[:alias])
+        branch dataset: join.from_self(opts),
+                    as: opts[:alias]
+      end
+
+      def union(other, opts={})
+        branch dataset: dataset.union(other.dataset, opts),
+                    as: opts[:alias]
+      end
+
+    ### compilation tools
+
+      def sql
+        dataset.sql
+      end
+
+      def qualify(attributes)
+        return attributes unless as
+        case attributes
+        when Symbol
+          ::Sequel.qualify(as, attributes)
+        when Hash
+          attributes.map{|k,v| ::Sequel.as(::Sequel.qualify(as, k), v) }
+        else
+          attributes.map{|a| ::Sequel.qualify(as, a)}
+        end
+      end
+
+      def branch(opts = {})
+        Cog.new connection, self.opts.merge(opts)
+      end
+
+      def to_s
+        "Alf::Sequel::Cog|#{sql}"
+      end
+
+    end # class Operand
+  end # module Sequel
+end # module Alf

data/lib/alf/sequel/compiler/predicate.rb

@@ -0,0 +1,76 @@
+module Alf
+  module Sequel
+    class Compiler
+      class Predicate < Sexpr::Processor
+
+        def call(predicate)
+          super(predicate.expr)
+        end
+
+        def on_missing(sexpr)
+          throw :pass
+        end
+        alias :on_native :on_missing
+
+        def on_tautology(sexpr)
+          ::Sequel::SQL::BooleanConstant.new(true)
+        end
+
+        def on_contradiction(sexpr)
+          ::Sequel::SQL::BooleanConstant.new(false)
+        end
+
+        def on_var_ref(sexpr)
+          if qualifier = options[:qualifier]
+            ::Sequel.qualify(qualifier, sexpr.last)
+          else
+            ::Sequel.expr(sexpr.last)
+          end
+        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 = apply(sexpr.var_ref)
+          ::Sequel.expr(left => sexpr.values)
+        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
+
+      end # class Predicate
+    end # class Compiler
+  end # module Sequel
+end # module Alf

data/lib/alf/sequel/compiler.rb

@@ -0,0 +1,168 @@
+module Alf
+  module Sequel
+    class Compiler < Algebra::Compiler
+
+      def pass(expr)
+        rewrite(expr)
+      end
+      alias :on_missing :pass
+
+      def next_alias
+        @as ||= 0
+        :"t#{@as += 1}"
+      end
+
+      def on_leaf_operand(expr)
+        if Algebra::Operand::Named===expr
+          expr.connection.cog(expr.name, :alias => next_alias)
+        else
+          expr.to_cog
+        end
+      end
+
+    ### non relational
+
+      alias :on_autonum   :pass
+      alias :on_coerce    :pass
+      alias :on_defaults  :pass
+      alias :on_generator :pass
+
+      def on_clip(expr)
+        rewrite(expr){|rw|
+          rw.operand.select(expr.stay_attributes)
+        }
+      end
+
+      def on_compact(expr)
+        rewrite(expr){|rw|
+          rw.operand.distinct
+        }
+      end
+
+      def on_sort(expr)
+        rewrite(expr){|rw|
+          operand = rw.operand
+          ordering = expr.ordering.to_a.map{|(col,dir)|
+            ::Sequel.send(dir, operand.qualify(col))
+          }
+          operand.order(*ordering)
+        }
+      end
+
+    ### relational
+
+      alias :on_extend :pass
+      alias :on_group  :pass
+      alias :on_infer_heading :pass
+
+      def on_intersect(expr)
+        rewrite(expr){|rw|
+          rw.left.intersect(rw.right, :alias => next_alias)
+        }
+      end
+
+      def on_join(expr)
+        rewrite(expr){|rw|
+          rw.left.join(rw.right, expr.common_attributes.to_a, :alias => next_alias)
+        }
+      end
+
+      def on_matching(expr)
+        rewrite(expr) do |rw|
+          rw.left.filter(matching2filter(expr, rw))
+        end
+      end
+
+      def on_not_matching(expr)
+        rewrite(expr) do |rw|
+          rw.left.filter(~matching2filter(expr, rw))
+        end
+      end
+
+      def matching2filter(expr, rw)
+        commons = expr.common_attributes.to_a
+        if commons.size==1
+          # (NOT) IN (SELECT ...)
+          pred = ::Alf::Predicate.in(commons.first, rw.right.select(commons).dataset)
+          Predicate.new(:qualifier => rw.left.as).call(pred)
+        elsif commons.size==0
+          # (NOT) EXISTS (SELECT ... no join condition ...)
+          rw.right.dataset.exists
+        else
+          # (NOT) EXISTS (SELECT ...)
+          filter = Hash[rw.left.qualify(commons).zip(rw.right.qualify(commons))]
+          filter = ::Sequel.expr filter
+          filter = rw.right.filter(filter)
+          filter.dataset.exists
+        end
+      end
+
+      alias :on_minus :pass
+
+      def on_project(expr)
+        rewrite(expr){|rw|
+          compiled = rw.operand.select(expr.stay_attributes)
+          compiled = compiled.distinct unless key_preserving?(expr){ false }
+          compiled
+        }
+      end
+
+      alias :on_quota :pass
+      alias :on_rank  :pass
+
+      def on_rename(expr)
+        rewrite(expr){|rw|
+          rw.operand.rename(expr.complete_renaming.to_hash, :alias => next_alias)
+        }
+      end
+
+      def on_restrict(expr)
+        rewrite(expr){|rw|
+          filter = Predicate.new(:qualifier => rw.operand.as).call(rw.predicate)
+          rw.operand.filter(filter)
+        }
+      end
+
+      alias :on_summarize :pass
+      alias :on_ungroup :pass
+
+      def on_union(expr)
+        rewrite(expr){|rw|
+          rw.left.union(rw.right, :alias => next_alias)
+        }
+      end
+
+      alias :on_unwrap :pass
+      alias :on_wrap :pass
+
+    private
+
+      def key_preserving?(expr)
+        expr.key_preserving?
+      rescue NotSupportedError
+        block_given? ? yield : raise
+      end
+
+    private
+
+      def rewrite(expr)
+        rewrited = copy_and_apply(expr)
+        if block_given? and rewrited.operands.all?{|op| recognized?(op) }
+          catch(:pass){ rewrited = yield(rewrited) }
+        end
+        rewrited = engine.call(rewrited) unless recognized?(rewrited)
+        rewrited
+      end
+
+      def recognized?(op)
+        op.is_a?(Cog)
+      end
+
+      def engine
+        @engine ||= Engine::Compiler.new
+      end
+
+    end # class Compiler
+  end # module Sequel
+end # module Alf
+require_relative 'compiler/predicate'

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

@@ -0,0 +1,46 @@
+module Alf
+  module Sequel
+    class Connection
+      module ConnectionMethods
+
+        def connection_uri(with_password = false)
+          if conn_spec.is_a?(Hash)
+            cs = Tuple(self.conn_spec)
+            adapter, host, port, database, user, password = cs.values_at(:adapter, :host, :port, :database, :user, :password)
+            user = "#{user}:#{password}" if user and password and with_password
+            user = "#{user}@"            if user
+            host = "localhost"           if host.nil? and not(adapter =~ /sqlite/)
+            host = "#{host}:#{port}"     if host and port
+            host = "/#{user}#{host}"     if host or user
+            "#{adapter}:/#{host}/#{database}"
+          elsif conn_spec.is_a?(String)
+            conn_spec
+          else
+            "Alf::Sequel::Connection(#{conn_spec})"
+          end
+        end
+
+        def ping
+          sequel_db.test_connection
+        end
+
+        def close
+          @sequel_db.disconnect if @sequel_db && @sequel_db != conn_spec
+        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)
+          block_given? ? yield(@sequel_db) : @sequel_db
+        end
+
+      end # module ConnectionMethods
+    end # module Connection
+  end # module Sequel
+end # module Alf

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

@@ -0,0 +1,76 @@
+module Alf
+  module Sequel
+    class Connection
+      module SchemaMethods
+
+        def knows?(name)
+          sequel_db.table_exists?(name)
+        end
+
+        def dataset(name)
+          sequel_db[name]
+        end
+
+        def cog(name, opts={})
+          if as = opts[:alias]
+            Cog.new(self, dataset: dataset(:"#{name}___#{as}"), as: as)
+          else
+            Cog.new(self, dataset: dataset(name))
+          end
+        end
+
+        def heading(name)
+          h = {}
+          sequel_db.schema(name).each do |pair|
+            column_name, info = pair
+            h[column_name] = dbtype_to_ruby_type(info)
+          end
+          Heading.new(h)
+        end
+
+        def keys(name)
+          # take the indexes
+          indexes = sequel_db.indexes(name).
+                              values.
+                              select{|i| i[:unique] == true }.
+                              map{|i| AttrList.coerce(i[:columns]) }.
+                              sort{|a1, a2| a1.size <=> a2.size}
+
+          # take single keys as well
+          key = sequel_db.schema(name).
+                          select{|(colname, colinfo)| colinfo[:primary_key] }.
+                          map(&:first)
+          indexes.unshift(AttrList.coerce(key)) unless key.empty?
+
+          Keys.new(indexes)
+        end
+
+        def migrate!(opts)
+          unless f = opts.migrations_folder
+            raise Alf::ConfigError, "Migrations folder not set"
+          end
+          with_sequel_db do |db|
+            ::Sequel.extension(:migration)
+            ::Sequel::Migrator.apply(db, f)
+          end
+        end
+
+      private
+
+        def dbtype_to_ruby_type(info)
+          return Object unless info[:type]
+          begin
+            Kernel.eval(info[:type].to_s.capitalize)
+          rescue NameError
+            case info[:type]
+            when :datetime then DateTime
+            when :boolean  then Alf::Boolean
+            else Object
+            end
+          end
+        end
+
+      end # module SchemaMethods
+    end # module Connection
+  end # module Sequel
+end # module Alf

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

@@ -0,0 +1,63 @@
+module Alf
+  module Sequel
+    class Connection
+      module UpdateMethods
+
+        # Yields the block in a transaction
+        def in_transaction(&bl)
+          sequel_db.transaction(&bl)
+        end
+
+        def lock(name, mode, &bl)
+          with_dataset(name){|ds|
+            if ds.respond_to?(:lock)
+              ds.lock(mode.to_s.upcase, &bl)
+            else
+              yield
+            end
+          }
+        end
+
+        # Inserts `tuples` in the relvar called `name`
+        def insert(name, tuples)
+          insert_uow(name, tuples).run
+        end
+
+        # Delete from the relvar called `name`
+        def delete(name, predicate)
+          delete_uow(name, predicate).run
+        end
+
+        # Updates the relvar called `name`
+        def update(name, updating, predicate)
+          update_uow(name, updating, predicate).run
+        end
+
+      public # should be private
+
+        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))
+          end
+          yield(ds) if block_given?
+        end
+
+      private
+
+        def insert_uow(name, tuples)
+          UnitOfWork::Insert.new(self, name, tuples)
+        end
+
+        def delete_uow(name, predicate)
+          UnitOfWork::Delete.new(self, name, predicate)
+        end
+
+        def update_uow(name, updating, predicate)
+          UnitOfWork::Update.new(self, name, updating, predicate)
+        end
+
+      end # module UpdateMethods
+    end # module Connection
+  end # module Sequel
+end # module Alf