sequel 2.2.0 → 2.3.0

data/lib/sequel_core/adapters/informix.rb

@@ -0,0 +1,78 @@
+require 'informix'
+
+module Sequel
+  module Informix
+    class Database < Sequel::Database
+      set_adapter_scheme :informix
+      
+      # AUTO_INCREMENT = 'IDENTITY(1,1)'.freeze
+      # 
+      # def auto_increment_sql
+      #   AUTO_INCREMENT
+      # end
+      
+      def connect
+        ::Informix.connect(@opts[:database], @opts[:user], @opts[:password])
+      end
+      
+      def disconnect
+        @pool.disconnect {|c| c.close}
+      end
+    
+      def dataset(opts = nil)
+        Sequel::Informix::Dataset.new(self, opts)
+      end
+      
+      # Returns number of rows affected
+      def execute_dui(sql)
+        log_info(sql)
+        @pool.hold {|c| c.immediate(sql)}
+      end
+      alias_method :do, :execute_dui
+      
+      def execute(sql, &block)
+        log_info(sql)
+        @pool.hold {|c| block[c.cursor(sql)]}
+      end
+      alias_method :query, :execute
+    end
+    
+    class Dataset < Sequel::Dataset
+      def literal(v)
+        case v
+        when Time
+          literal(v.iso8601)
+        when Date, DateTime
+          literal(v.to_s)
+        else
+          super
+        end
+      end
+
+      def select_sql(opts = nil)
+        limit = opts.delete(:limit)
+        offset = opts.delete(:offset)
+        sql = super
+        if limit
+          limit = "FIRST #{limit}"
+          offset = offset ? "SKIP #{offset}" : ""
+          sql.sub!(/^select /i,"SELECT #{offset} #{limit} ")
+        end
+        sql
+      end
+      
+      def fetch_rows(sql, &block)
+        @db.synchronize do
+          @db.execute(sql) do |cursor|
+            begin
+              cursor.open.each_hash(&block)
+            ensure
+              cursor.drop
+            end
+          end
+        end
+        self
+      end
+    end
+  end
+end

data/lib/sequel_core/adapters/jdbc.rb

@@ -0,0 +1,186 @@
+require 'java'
+
+module Sequel
+  module JDBC
+    module JavaLang; include_package 'java.lang'; end
+    module JavaSQL; include_package 'java.sql'; end
+    DATABASE_SETUP = {:postgresql=>proc do |db|
+        require 'sequel_core/adapters/jdbc/postgresql'
+        db.extend(Sequel::JDBC::Postgres::DatabaseMethods)
+        JDBC.load_gem('postgres')
+        org.postgresql.Driver
+      end,
+      :mysql=>proc do |db|
+        require 'sequel_core/adapters/jdbc/mysql'
+        db.extend(Sequel::JDBC::MySQL::DatabaseMethods)
+        JDBC.load_gem('mysql')
+        com.mysql.jdbc.Driver
+      end,
+      :sqlite=>proc do |db|
+        require 'sequel_core/adapters/jdbc/sqlite'
+        db.extend(Sequel::JDBC::SQLite::DatabaseMethods)
+        JDBC.load_gem('sqlite3')
+        org.sqlite.JDBC
+      end,
+      :oracle=>proc{oracle.jdbc.driver.OracleDriver},
+      :sqlserver=>proc{com.microsoft.sqlserver.jdbc.SQLServerDriver}
+    }
+    
+    def self.load_gem(name)
+      begin
+        require "jdbc/#{name}"
+      rescue LoadError
+        # jdbc gem not used, hopefully the user has the .jar in their CLASSPATH
+      end
+    end
+
+    class Database < Sequel::Database
+      set_adapter_scheme :jdbc
+      
+      # The type of database we are connecting to
+      attr_reader :database_type
+      
+      def initialize(opts)
+        super(opts)
+        raise(Error, "No connection string specified") unless uri
+        if match = /\Ajdbc:([^:]+)/.match(uri) and prok = DATABASE_SETUP[match[1].to_sym]
+          prok.call(self)
+        end
+      end
+      
+      def connect
+        setup_connection(JavaSQL::DriverManager.getConnection(uri))
+      end
+      
+      def dataset(opts = nil)
+        JDBC::Dataset.new(self, opts)
+      end
+      
+      def disconnect
+        @pool.disconnect {|c| c.close}
+      end
+      
+      def execute(sql)
+        log_info(sql)
+        @pool.hold do |conn|
+          stmt = conn.createStatement
+          begin
+            yield stmt.executeQuery(sql)
+          rescue NativeException, JavaSQL::SQLException => e
+            raise Error, e.message
+          ensure
+            stmt.close
+          end
+        end
+      end
+      
+      def execute_ddl(sql)
+        log_info(sql)
+        @pool.hold do |conn|
+          stmt = conn.createStatement
+          begin
+            stmt.execute(sql)
+          rescue NativeException, JavaSQL::SQLException => e
+            raise Error, e.message
+          ensure
+            stmt.close
+          end
+        end
+      end
+      
+      def execute_dui(sql)
+        log_info(sql)
+        @pool.hold do |conn|
+          stmt = conn.createStatement
+          begin
+            stmt.executeUpdate(sql)
+          rescue NativeException, JavaSQL::SQLException => e
+            raise Error, e.message
+          ensure
+            stmt.close
+          end
+        end
+      end
+      
+      def setup_connection(conn)
+        conn
+      end
+      
+      def transaction
+        @pool.hold do |conn|
+          @transactions ||= []
+          return yield(conn) if @transactions.include?(Thread.current)
+          stmt = conn.createStatement
+          begin
+            log_info(Sequel::Database::SQL_BEGIN)
+            stmt.execute(Sequel::Database::SQL_BEGIN)
+            @transactions << Thread.current
+            yield(conn)
+          rescue Exception => e
+            log_info(Sequel::Database::SQL_ROLLBACK)
+            stmt.execute(Sequel::Database::SQL_ROLLBACK)
+            raise e unless Error::Rollback === e
+          ensure
+            unless e
+              log_info(Sequel::Database::SQL_COMMIT)
+              stmt.execute(Sequel::Database::SQL_COMMIT)
+            end
+            stmt.close
+            @transactions.delete(Thread.current)
+          end
+        end
+      end
+      
+      def uri
+        ur = @opts[:uri] || @opts[:url] || @opts[:database]
+        ur =~ /^\Ajdbc:/ ? ur : "jdbc:#{ur}"
+      end
+      alias url uri
+      
+      private
+      
+      def connection_pool_default_options
+        super.merge(:pool_convert_exceptions=>false)
+      end
+    end
+    
+    class Dataset < Sequel::Dataset
+      def literal(v)
+        case v
+        when Time
+          literal(v.iso8601)
+        when Date, DateTime, Java::JavaSql::Timestamp
+          literal(v.to_s)
+        else
+          super
+        end
+      end
+
+      def fetch_rows(sql, &block)
+        @db.synchronize do
+          @db.execute(sql) do |result|
+            # get column names
+            meta = result.getMetaData
+            column_count = meta.getColumnCount
+            @columns = []
+            column_count.times {|i| @columns << meta.getColumnName(i+1).to_sym}
+
+            # get rows
+            while result.next
+              row = {}
+              @columns.each_with_index {|v, i| row[v] = result.getObject(i+1)}
+              yield row
+            end
+          end
+        end
+        self
+      end
+    end
+  end
+end
+
+class Java::JavaSQL::Timestamp
+  def usec
+    getNanos/1000
+  end
+end

data/lib/sequel_core/adapters/jdbc/mysql.rb

@@ -0,0 +1,55 @@
+require 'sequel_core/adapters/shared/mysql'
+
+module Sequel
+  module JDBC
+    module MySQL
+      module DatabaseMethods
+        include Sequel::MySQL::DatabaseMethods
+        
+        def dataset(opts=nil)
+          Sequel::JDBC::MySQL::Dataset.new(self, opts)
+        end
+        
+        def execute_insert(sql)
+          begin
+            log_info(sql)
+            @pool.hold do |conn|
+              stmt = conn.createStatement
+              begin
+                stmt.executeUpdate(sql)
+                rs = stmt.executeQuery('SELECT LAST_INSERT_ID()')
+                rs.next
+                rs.getInt(1)
+              rescue NativeException, JavaSQL::SQLException => e
+                raise Error, e.message
+              ensure
+                stmt.close
+              end
+            end
+          rescue NativeException, JavaSQL::SQLException => e
+            raise Error, "#{sql}\r\n#{e.message}"
+          end
+        end
+        
+        private
+        
+        def database_name
+          u = URI.parse(uri.sub(/\Ajdbc:/, ''))
+          (m = /\/(.*)/.match(u.path)) && m[1]
+        end
+      end
+    
+      class Dataset < JDBC::Dataset
+        include Sequel::MySQL::DatasetMethods
+        
+        def insert(*values)
+          @db.execute_insert(insert_sql(*values))
+        end
+        
+        def replace(*args)
+          @db.execute_insert(replace_sql(*args))
+        end
+      end
+    end
+  end
+end

data/lib/sequel_core/adapters/jdbc/postgresql.rb

@@ -0,0 +1,66 @@
+require 'sequel_core/adapters/shared/postgres'
+
+module Sequel
+  Postgres::CONVERTED_EXCEPTIONS << NativeException
+  
+  module JDBC
+    module Postgres
+      module AdapterMethods
+        include Sequel::Postgres::AdapterMethods
+        
+        def execute(sql, method=:execute)
+          method = :executeQuery if block_given?
+          stmt = createStatement
+          begin
+            rows = stmt.send(method, sql)
+            yield(rows) if block_given?
+          rescue NativeException => e
+            raise Error, e.message
+          ensure
+            stmt.close
+          end
+        end
+        
+        def result_set_values(r, *vals)
+          return if r.nil?
+          r.next
+          return if r.getRow == 0
+          case vals.length
+          when 1
+            r.getString(vals.first+1)
+          else
+            vals.collect{|col| r.getString(col+1)}
+          end
+        end
+      end
+    
+      module DatabaseMethods
+        include Sequel::Postgres::DatabaseMethods
+        
+        def dataset(opts=nil)
+          Sequel::JDBC::Postgres::Dataset.new(self, opts)
+        end
+        
+        def setup_connection(conn)
+          conn.extend(Sequel::JDBC::Postgres::AdapterMethods)
+          conn
+        end
+      end
+      
+      class Dataset < JDBC::Dataset
+        include Sequel::Postgres::DatasetMethods
+        
+        def literal(v)
+          case v
+          when SQL::Blob
+            "'#{v.gsub(/[\000-\037\047\134\177-\377]/){|b| "\\#{ b[0].to_s(8).rjust(3, '0') }"}}'"
+          when Java::JavaSql::Timestamp
+            "TIMESTAMP #{literal(v.to_s)}"
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel_core/adapters/jdbc/sqlite.rb

@@ -0,0 +1,47 @@
+require 'sequel_core/adapters/shared/sqlite'
+
+module Sequel
+  module JDBC
+    module SQLite
+      module DatabaseMethods
+        include Sequel::SQLite::DatabaseMethods
+        
+        def dataset(opts=nil)
+          Sequel::JDBC::SQLite::Dataset.new(self, opts)
+        end
+        
+        def execute_insert(sql)
+          begin
+            log_info(sql)
+            @pool.hold do |conn|
+              stmt = conn.createStatement
+              begin
+                stmt.executeUpdate(sql)
+                rs = stmt.executeQuery('SELECT last_insert_rowid()')
+                rs.next
+                rs.getInt(1)
+              rescue NativeException, JavaSQL::SQLException => e
+                raise Error, e.message
+              ensure
+                stmt.close
+              end
+            end
+          rescue NativeException, JavaSQL::SQLException => e
+            raise Error, "#{sql}\r\n#{e.message}"
+          end
+        end
+        
+        private
+        
+        def connection_pool_default_options
+          o = super
+          uri == 'jdbc:sqlite::memory:' ? o.merge(:max_connections=>1) : o
+        end
+      end
+    
+      class Dataset < JDBC::Dataset
+        include Sequel::SQLite::DatasetMethods
+      end
+    end
+  end
+end

data/lib/sequel_core/adapters/mysql.rb

@@ -0,0 +1,231 @@
+require 'mysql'
+require 'sequel_core/adapters/shared/mysql'
+
+# Monkey patch Mysql::Result to yield hashes with symbol keys
+class Mysql::Result
+  MYSQL_TYPES = {
+    0   => :to_d,     # MYSQL_TYPE_DECIMAL
+    1   => :to_i,     # MYSQL_TYPE_TINY
+    2   => :to_i,     # MYSQL_TYPE_SHORT
+    3   => :to_i,     # MYSQL_TYPE_LONG
+    4   => :to_f,     # MYSQL_TYPE_FLOAT
+    5   => :to_f,     # MYSQL_TYPE_DOUBLE
+    # 6   => ??,        # MYSQL_TYPE_NULL
+    7   => :to_sequel_time,  # MYSQL_TYPE_TIMESTAMP
+    8   => :to_i,     # MYSQL_TYPE_LONGLONG
+    9   => :to_i,     # MYSQL_TYPE_INT24
+    10  => :to_date,  # MYSQL_TYPE_DATE
+    11  => :to_time,  # MYSQL_TYPE_TIME
+    12  => :to_sequel_time,  # MYSQL_TYPE_DATETIME
+    13  => :to_i,     # MYSQL_TYPE_YEAR
+    14  => :to_date,  # MYSQL_TYPE_NEWDATE
+    # 15  => :to_s      # MYSQL_TYPE_VARCHAR
+    # 16  => :to_s,     # MYSQL_TYPE_BIT
+    246 => :to_d,     # MYSQL_TYPE_NEWDECIMAL
+    247 => :to_i,     # MYSQL_TYPE_ENUM
+    248 => :to_i,      # MYSQL_TYPE_SET
+    249 => :to_blob,     # MYSQL_TYPE_TINY_BLOB
+    250 => :to_blob,     # MYSQL_TYPE_MEDIUM_BLOB
+    251 => :to_blob,     # MYSQL_TYPE_LONG_BLOB
+    252 => :to_blob,     # MYSQL_TYPE_BLOB
+    # 253 => :to_s,     # MYSQL_TYPE_VAR_STRING
+    # 254 => :to_s,     # MYSQL_TYPE_STRING
+    # 255 => :to_s      # MYSQL_TYPE_GEOMETRY
+  }
+
+  def convert_type(v, type)
+    if v
+      if type == 1 && Sequel.convert_tinyint_to_bool
+        # We special case tinyint here to avoid adding
+        # a method to an ancestor of Fixnum
+        v.to_i == 0 ? false : true
+      else
+        (t = MYSQL_TYPES[type]) ? v.send(t) : v
+      end
+    else
+      nil
+    end
+  end
+
+  def columns(with_table = nil)
+    unless @columns
+      @column_types = []
+      @columns = fetch_fields.map do |f|
+        @column_types << f.type
+        (with_table ? "#{f.table}.#{f.name}" : f.name).to_sym
+      end
+    end
+    @columns
+  end
+
+  def each_array(with_table = nil)
+    c = columns
+    while row = fetch_row
+      c.each_with_index do |f, i|
+        if (t = MYSQL_TYPES[@column_types[i]]) && (v = row[i])
+          row[i] = v.send(t)
+        end
+      end
+      yield row
+    end
+  end
+
+  def sequel_each_hash(with_table = nil)
+    c = columns
+    while row = fetch_row
+      h = {}
+      c.each_with_index {|f, i| h[f] = convert_type(row[i], @column_types[i])}
+      yield h
+    end
+  end
+  
+end
+
+module Sequel
+  module MySQL    
+    class Database < Sequel::Database
+      include Sequel::MySQL::DatabaseMethods
+      
+      set_adapter_scheme :mysql
+
+      def connect
+        conn = Mysql.init
+        conn.options(Mysql::OPT_LOCAL_INFILE, "client")
+        conn.real_connect(
+          @opts[:host] || 'localhost',
+          @opts[:user],
+          @opts[:password],
+          @opts[:database],
+          @opts[:port],
+          @opts[:socket],
+          Mysql::CLIENT_MULTI_RESULTS +
+          Mysql::CLIENT_MULTI_STATEMENTS +
+          Mysql::CLIENT_COMPRESS
+        )
+        conn.query_with_result = false
+        if encoding = @opts[:encoding] || @opts[:charset]
+          conn.query("set character_set_connection = '#{encoding}'")
+          conn.query("set character_set_client = '#{encoding}'")
+          conn.query("set character_set_database = '#{encoding}'")
+          conn.query("set character_set_server = '#{encoding}'")
+          conn.query("set character_set_results = '#{encoding}'")
+        end
+        conn.reconnect = true
+        conn
+      end
+      
+      def dataset(opts = nil)
+        MySQL::Dataset.new(self, opts)
+      end
+
+      def disconnect
+        @pool.disconnect {|c| c.close}
+      end
+
+      def execute(sql, &block)
+        begin
+          log_info(sql)
+          @pool.hold do |conn|
+            conn.query(sql)
+            block[conn] if block
+          end
+        rescue Mysql::Error => e
+          raise Error.new(e.message)
+        end
+      end
+
+      def execute_select(sql, &block)
+        execute(sql) do |c|
+          r = c.use_result
+          begin
+            block[r]
+          ensure
+            r.free
+          end
+        end
+      end
+      
+      def server_version
+        @server_version ||= (synchronize{|conn| conn.server_version if conn.respond_to?(:server_version)} || super)
+      end
+      
+      def tables
+        @pool.hold do |conn|
+          conn.list_tables.map {|t| t.to_sym}
+        end
+      end
+      
+      def transaction
+        @pool.hold do |conn|
+          @transactions ||= []
+          return yield(conn) if @transactions.include? Thread.current
+          log_info(SQL_BEGIN)
+          conn.query(SQL_BEGIN)
+          begin
+            @transactions << Thread.current
+            yield(conn)
+          rescue ::Exception => e
+            log_info(SQL_ROLLBACK)
+            conn.query(SQL_ROLLBACK)
+            raise (Mysql::Error === e ? Error.new(e.message) : e) unless Error::Rollback === e
+          ensure
+            unless e
+              log_info(SQL_COMMIT)
+              conn.query(SQL_COMMIT)
+            end
+            @transactions.delete(Thread.current)
+          end
+        end
+      end
+
+      private
+      
+      def connection_pool_default_options
+        super.merge(:pool_convert_exceptions=>false)
+      end
+      
+      def database_name
+        @opts[:database]
+      end
+    end
+
+    class Dataset < Sequel::Dataset
+      include Sequel::MySQL::DatasetMethods
+
+      def delete(opts = nil)
+        @db.execute(delete_sql(opts)) {|c| c.affected_rows}
+      end
+
+      def fetch_rows(sql)
+        @db.execute_select(sql) do |r|
+          @columns = r.columns
+          r.sequel_each_hash {|row| yield row}
+        end
+        self
+      end
+
+      def insert(*values)
+        @db.execute(insert_sql(*values)) {|c| c.insert_id}
+      end
+      
+      def literal(v)
+        case v
+        when LiteralString
+          v
+        when String
+          "'#{::Mysql.quote(v)}'"
+        else
+          super
+        end
+      end
+      
+      def replace(*args)
+        @db.execute(replace_sql(*args)) {|c| c.insert_id}
+      end
+      
+      def update(*args)
+        @db.execute(update_sql(*args)) {|c| c.affected_rows}
+      end
+    end
+  end
+end