sequel 3.21.0 → 3.36.0

data/lib/sequel/adapters/db2.rb

@@ -1,139 +1,228 @@
 require 'db2/db2cli'
+Sequel.require %w'shared/db2', 'adapters'
 
 module Sequel
   module DB2
+
+    @convert_smallint_to_bool = true
+
+    # Underlying error raised by Sequel, since ruby-db2 doesn't
+    # use exceptions.
+    class DB2Error < StandardError
+    end
+
+    class << self
+      # Whether to convert smallint values to bool, true by default.
+      # Can also be overridden per dataset.
+      attr_accessor :convert_smallint_to_bool
+    end
+
+    tt = Class.new do
+      def boolean(s) !s.to_i.zero? end
+      def date(s) Date.new(s.year, s.month, s.day) end
+      def time(s) Sequel::SQLTime.create(s.hour, s.minute, s.second) end
+    end.new
+
+    # Hash holding type translation methods, used by Dataset#fetch_rows.
+    DB2_TYPES = {
+      :boolean  => tt.method(:boolean),
+      DB2CLI::SQL_BLOB => ::Sequel::SQL::Blob.method(:new),
+      DB2CLI::SQL_TYPE_DATE => tt.method(:date),
+      DB2CLI::SQL_TYPE_TIME => tt.method(:time),
+      DB2CLI::SQL_DECIMAL => ::BigDecimal.method(:new)
+    }
+    DB2_TYPES[DB2CLI::SQL_CLOB] = DB2_TYPES[DB2CLI::SQL_BLOB]
+
     class Database < Sequel::Database
-      set_adapter_scheme :db2
+      include DatabaseMethods
 
-      include DB2CLI
+      set_adapter_scheme :db2
 
       TEMPORARY = 'GLOBAL TEMPORARY '.freeze
+      rc, NullHandle = DB2CLI.SQLAllocHandle(DB2CLI::SQL_HANDLE_ENV, DB2CLI::SQL_NULL_HANDLE)
       
-      rc, @@env = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE)
-      #check_error(rc, "Could not allocate DB2 environment")
+      # Hash of connection procs for converting
+      attr_reader :conversion_procs
+
+      def initialize(opts={})
+        super
+        @conversion_procs = DB2_TYPES.dup
+        @conversion_procs[DB2CLI::SQL_TYPE_TIMESTAMP] = method(:to_application_timestamp_db2)
+      end
 
       def connect(server)
         opts = server_opts(server)
-        rc, dbc = SQLAllocHandle(SQL_HANDLE_DBC, @@env) 
-        check_error(rc, "Could not allocate database connection")
-        
-        rc = SQLConnect(dbc, opts[:database], opts[:user], opts[:password]) 
-        check_error(rc, "Could not connect to database")
-        
+        dbc = checked_error("Could not allocate database connection"){DB2CLI.SQLAllocHandle(DB2CLI::SQL_HANDLE_DBC, NullHandle)}
+        checked_error("Could not connect to database"){DB2CLI.SQLConnect(dbc, opts[:database], opts[:user], opts[:password])}
         dbc
       end
       
-      def test_connection(server=nil)
-        synchronize(server){|conn|}
-        true
+      def execute(sql, opts={}, &block)
+        synchronize(opts[:server]){|conn| log_connection_execute(conn, sql, &block)}
       end
+      alias do execute
 
-      def dataset(opts = nil)
-        DB2::Dataset.new(self, opts)
-      end
-      
-      def execute(sql, opts={})
+      def execute_insert(sql, opts={})
         synchronize(opts[:server]) do |conn|
-          rc, sth = SQLAllocHandle(SQL_HANDLE_STMT, @handle) 
-          check_error(rc, "Could not allocate statement")
-
-          begin
-            rc = log_yield(sql){SQLExecDirect(sth, sql)}
-            check_error(rc, "Could not execute statement")
-            
-            yield(sth) if block_given?
-
-            rc, rpc = SQLRowCount(sth)
-            check_error(rc, "Could not get RPC") 
-            rpc
-          ensure
-            rc = SQLFreeHandle(SQL_HANDLE_STMT, sth)
-            check_error(rc, "Could not free statement")
+          log_connection_execute(conn, sql)
+          sql = "SELECT IDENTITY_VAL_LOCAL() FROM SYSIBM.SYSDUMMY1"
+          log_connection_execute(conn, sql) do |sth|
+            name, buflen, datatype, size, digits, nullable = checked_error("Could not describe column"){DB2CLI.SQLDescribeCol(sth, 1, 256)}
+            if DB2CLI.SQLFetch(sth) != DB2CLI::SQL_NO_DATA_FOUND
+              v, _ = checked_error("Could not get data"){DB2CLI.SQLGetData(sth, 1, datatype, size)}
+              if v.is_a?(String) 
+                return v.to_i
+              else
+                return nil
+              end
+            end
           end
         end
       end
-      alias_method :do, :execute
-      
-      private
       
+      ERROR_MAP = {}
+      %w'SQL_INVALID_HANDLE SQL_STILL_EXECUTING SQL_ERROR'.each do |s|
+        ERROR_MAP[DB2CLI.const_get(s)] = s
+      end
       def check_error(rc, msg)
         case rc
-        when SQL_SUCCESS, SQL_SUCCESS_WITH_INFO
+        when DB2CLI::SQL_SUCCESS, DB2CLI::SQL_SUCCESS_WITH_INFO, DB2CLI::SQL_NO_DATA_FOUND
           nil
+        when DB2CLI::SQL_INVALID_HANDLE, DB2CLI::SQL_STILL_EXECUTING
+          e = DB2Error.new("#{ERROR_MAP[rc]}: #{msg}")
+          e.set_backtrace(caller)
+          raise_error(e, :disconnect=>true)
         else
-          raise DatabaseError, msg
+          e = DB2Error.new("#{ERROR_MAP[rc] || "Error code #{rc}"}: #{msg}")
+          e.set_backtrace(caller)
+          raise_error(e, :disconnect=>true)
         end
       end
 
-      def disconnect_connection(conn)
-        rc = SQLDisconnect(conn)
-        check_error(rc, "Could not disconnect from database")
+      def checked_error(msg)
+        rc, *ary= yield
+        check_error(rc, msg)
+        ary.length <= 1 ? ary.first : ary
+      end
+
+      def to_application_timestamp_db2(v)
+        to_application_timestamp(v.to_s)
+      end
+
+      private
+
+      def begin_transaction(conn, opts={})
+        log_yield(TRANSACTION_BEGIN){DB2CLI.SQLSetConnectAttr(conn, DB2CLI::SQL_ATTR_AUTOCOMMIT, DB2CLI::SQL_AUTOCOMMIT_OFF)}
+      end
+
+      def remove_transaction(conn, committed)
+        DB2CLI.SQLSetConnectAttr(conn, DB2CLI::SQL_ATTR_AUTOCOMMIT, DB2CLI::SQL_AUTOCOMMIT_ON)
+      ensure
+        super
+      end
+
+      def rollback_transaction(conn, opts={})
+        log_yield(TRANSACTION_ROLLBACK){DB2CLI.SQLEndTran(DB2CLI::SQL_HANDLE_DBC, conn, DB2CLI::SQL_ROLLBACK)}
+      end
 
-        rc = SQLFreeHandle(SQL_HANDLE_DBC, conn)
-        check_error(rc, "Could not free Database handle")
+      def commit_transaction(conn, opts={})
+        log_yield(TRANSACTION_COMMIT){DB2CLI.SQLEndTran(DB2CLI::SQL_HANDLE_DBC, conn, DB2CLI::SQL_COMMIT)}
+      end
+    
+      def log_connection_execute(conn, sql)
+        sth = checked_error("Could not allocate statement"){DB2CLI.SQLAllocHandle(DB2CLI::SQL_HANDLE_STMT, conn)}
+
+        begin
+          checked_error("Could not execute statement: #{sql}"){log_yield(sql){DB2CLI.SQLExecDirect(sth, sql)}}
+          
+          if block_given?
+            yield(sth)
+          else
+            checked_error("Could not get RPC"){DB2CLI.SQLRowCount(sth)}
+          end
+        ensure
+          checked_error("Could not free statement"){DB2CLI.SQLFreeHandle(DB2CLI::SQL_HANDLE_STMT, sth)}
+        end
+      end
+
+      # Convert smallint type to boolean if convert_smallint_to_bool is true
+      def schema_column_type(db_type)
+        if DB2.convert_smallint_to_bool && db_type =~ /smallint/i 
+          :boolean
+        else
+          super
+        end
+      end
+
+      def disconnect_connection(conn)
+        checked_error("Could not disconnect from database"){DB2CLI.SQLDisconnect(conn)}
+        checked_error("Could not free Database handle"){DB2CLI.SQLFreeHandle(DB2CLI::SQL_HANDLE_DBC, conn)}
       end
     end
     
     class Dataset < Sequel::Dataset
+      include DatasetMethods
+
+      Database::DatasetClass = self
       MAX_COL_SIZE = 256
       
+      # Whether to convert smallint to boolean arguments for this dataset.
+      # Defaults to the DB2 module setting.
+      def convert_smallint_to_bool
+        defined?(@convert_smallint_to_bool) ? @convert_smallint_to_bool : (@convert_smallint_to_bool = DB2.convert_smallint_to_bool)
+      end
+
+      # Override the default DB2.convert_smallint_to_bool setting for this dataset.
+      attr_writer :convert_smallint_to_bool
+
       def fetch_rows(sql)
         execute(sql) do |sth|
-          @column_info = get_column_info(sth)
-          @columns = @column_info.map {|c| output_identifier(c[:name])}
-          while (rc = SQLFetch(@handle)) != SQL_NO_DATA_FOUND
-            @db.check_error(rc, "Could not fetch row")
-            yield hash_row(sth)
+          offset = @opts[:offset]
+          db = @db
+          i = 1
+          column_info = get_column_info(sth)
+          cols = column_info.map{|c| c.at(1)}
+          cols.delete(row_number_column) if offset
+          @columns = cols
+          errors = [DB2CLI::SQL_NO_DATA_FOUND, DB2CLI::SQL_ERROR]
+          until errors.include?(rc = DB2CLI.SQLFetch(sth))
+            db.check_error(rc, "Could not fetch row")
+            row = {}
+            column_info.each do |i, c, t, s, pr|
+              v, _ = db.checked_error("Could not get data"){DB2CLI.SQLGetData(sth, i, t, s)}
+              row[c] = if v == DB2CLI::Null
+                nil
+              elsif pr
+                pr.call(v)
+              else
+                v
+              end
+            end
+            row.delete(row_number_column) if offset
+            yield row
           end
         end
         self
       end
       
-      # DB2 supports window functions
-      def supports_window_functions?
-        true
-      end
-      
       private
 
       def get_column_info(sth)
-        rc, column_count = SQLNumResultCols(sth)
-        @db.check_error(rc, "Could not get number of result columns")
+        db = @db
+        column_count = db.checked_error("Could not get number of result columns"){DB2CLI.SQLNumResultCols(sth)}
+        convert = convert_smallint_to_bool
+        cps = db.conversion_procs
 
         (1..column_count).map do |i| 
-          rc, name, buflen, datatype, size, digits, nullable = SQLDescribeCol(sth, i, MAX_COL_SIZE)
-          @b.check_error(rc, "Could not describe column")
-          
-          {:name => name, :db2_type => datatype, :precision => size}
+          name, buflen, datatype, size, digits, nullable = db.checked_error("Could not describe column"){DB2CLI.SQLDescribeCol(sth, i, MAX_COL_SIZE)}
+          pr = if datatype == DB2CLI::SQL_SMALLINT && convert && size <= 5 && digits <= 1
+            cps[:boolean]
+          else
+            cps[datatype]
+          end
+          [i, output_identifier(name), datatype, size, pr]
         end 
       end
-      
-      def hash_row(sth)
-        row = {}
-        @column_info.each_with_index do |c, i|
-          rc, v = SQLGetData(sth, i+1, c[:db2_type], c[:precision]) 
-          @db.check_error(rc, "Could not get data")
-          
-          row[output_identifier(c[:name])] = convert_type(v)
-        end
-        row
-      end
-      
-      def convert_type(v)
-        case v
-        when DB2CLI::Date 
-          DBI::Date.new(v.year, v.month, v.day)
-        when DB2CLI::Time
-          DBI::Time.new(v.hour, v.minute, v.second)
-        when DB2CLI::Timestamp 
-          DBI::Timestamp.new(v.year, v.month, v.day,
-            v.hour, v.minute, v.second, v.fraction)
-        when DB2CLI::Null
-          nil
-        else  
-          v
-        end
-      end
     end
   end
 end

data/lib/sequel/adapters/dbi.rb

@@ -63,10 +63,6 @@ module Sequel
         ::DBI.connect(dbname, opts[:user], opts[:password])
       end
       
-      def dataset(opts = nil)
-        DBI::Dataset.new(self, opts)
-      end
-    
       def execute(sql, opts={})
         synchronize(opts[:server]) do |conn|
           r = log_yield(sql){conn.execute(sql)}
@@ -88,26 +84,30 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
+      Database::DatasetClass = self
+
       def fetch_rows(sql)
         execute(sql) do |s|
           begin
-            @columns = s.column_names.map{|c| output_identifier(c)}
-            s.fetch{|r| yield hash_row(s, r)}
+            columns = cols = s.column_names.map{|c| output_identifier(c)}
+            if opts[:offset] && offset_returns_row_number_column?
+              rn = row_number_column
+              columns = columns.dup
+              columns.delete(rn)
+            end
+            @columns = columns
+            s.fetch do |r|
+              row = {}
+              cols.each{|c| row[c] = r.shift}
+              row.delete(rn) if rn
+              yield row
+            end
           ensure
             s.finish rescue nil
           end
         end
         self
       end
-      
-      private
-      
-      def hash_row(stmt, row)
-        @columns.inject({}) do |m, c|
-          m[c] = row.shift
-          m
-        end
-      end
     end
   end
 end

data/lib/sequel/adapters/do/mysql.rb

@@ -9,11 +9,6 @@ module Sequel
       module DatabaseMethods
         include Sequel::MySQL::DatabaseMethods
         
-        # Return instance of Sequel::DataObjects::MySQL::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::DataObjects::MySQL::Dataset.new(self, opts)
-        end
-        
         private
         
         # The database name for the given database.  Need to parse it out
@@ -23,25 +18,36 @@ module Sequel
           (m = /\/(.*)/.match(URI.parse(uri).path)) && m[1]
         end
 
+        # Recognize the tinyint(1) column as boolean.
         def schema_column_type(db_type)
           db_type == 'tinyint(1)' ? :boolean : super
         end
+
+        # Apply the connectiong setting SQLs for every new connection.
+        def setup_connection(conn)
+          mysql_connection_setting_sqls.each{|sql| log_yield(sql){conn.create_command(sql).execute_non_query}}
+          super
+        end
       end
       
       # Dataset class for MySQL datasets accessed via DataObjects.
       class Dataset < DataObjects::Dataset
         include Sequel::MySQL::DatasetMethods
+        APOS = Dataset::APOS
+        APOS_RE = Dataset::APOS_RE
+        DOUBLE_APOS = Dataset::DOUBLE_APOS
         
-        # Use execute_insert to execute the replace_sql.
-        def replace(*args)
-          execute_insert(replace_sql(*args))
+        # The DataObjects MySQL driver uses the number of rows actually modified in the update,
+        # instead of the number of matched by the filter.
+        def provides_accurate_rows_matched?
+          false
         end
-        
+      
         private
         
         # do_mysql sets NO_BACKSLASH_ESCAPES, so use standard SQL string escaping
-        def literal_string(s)
-          "'#{s.gsub("'", "''")}'"
+        def literal_string_append(sql, s)
+          sql << APOS << s.gsub(APOS_RE, DOUBLE_APOS) << APOS
         end
       end
     end

data/lib/sequel/adapters/do/postgres.rb

@@ -7,40 +7,6 @@ module Sequel
     # Adapter, Database, and Dataset support for accessing a PostgreSQL
     # database via DataObjects.
     module Postgres
-      # Methods to add to the DataObjects adapter/connection to allow it to work
-      # with the shared PostgreSQL code.
-      module AdapterMethods
-        include Sequel::Postgres::AdapterMethods
-        
-        # Give the DataObjects adapter a direct execute method, which creates
-        # a statement with the given sql and executes it.
-        def execute(sql, args=nil)
-          command = create_command(sql)
-          begin
-            if block_given?
-              begin
-                yield(reader = @db.log_yield(sql){command.execute_reader})
-              ensure
-                reader.close if reader
-              end
-            else
-              @db.log_yield(sql){command.execute_non_query}
-            end
-          rescue ::DataObjects::Error => e
-            @db.send(:raise_error, e)
-          end
-        end
-        
-        private
-        
-        # DataObjects specific method of getting specific values from a result set.
-        def single_value(reader)
-          while(reader.next!) do
-            return reader.values.at(0)
-          end
-        end
-      end
-    
       # Methods to add to Database instances that access PostgreSQL via
       # DataObjects.
       module DatabaseMethods
@@ -55,37 +21,15 @@ module Sequel
           end
         end
         
-        # Return instance of Sequel::DataObjects::Postgres::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::DataObjects::Postgres::Dataset.new(self, opts)
-        end
-        
-        # Run the INSERT sql on the database and return the primary key
-        # for the record.
-        def execute_insert(sql, opts={})
-          synchronize(opts[:server]) do |conn|
-            com = conn.create_command(sql)
-            log_yield(sql){com.execute_non_query}
-            insert_result(conn, opts[:table], opts[:values])
-          end
-        end
-        
         private
         
         # Extend the adapter with the DataObjects PostgreSQL AdapterMethods
         def setup_connection(conn)
           conn = super(conn)
-          conn.extend(Sequel::DataObjects::Postgres::AdapterMethods)
-          conn.db = self
-          conn.apply_connection_settings
+          connection_configuration_sqls.each{|sql| log_yield(sql){conn.create_command(sql).execute_non_query}}
           conn
         end
       end
-      
-      # Dataset subclass used for datasets that connect to PostgreSQL via DataObjects.
-      class Dataset < DataObjects::Dataset
-        include Sequel::Postgres::DatasetMethods
-      end
     end
   end
 end

data/lib/sequel/adapters/do/sqlite.rb

@@ -8,11 +8,6 @@ module Sequel
       module DatabaseMethods
         include Sequel::SQLite::DatabaseMethods
         
-        # Return Sequel::DataObjects::SQLite::Dataset object with the given opts.
-        def dataset(opts=nil)
-          Sequel::DataObjects::SQLite::Dataset.new(self, opts)
-        end
-        
         private
         
         # Default to a single connection for a memory database.
@@ -30,11 +25,6 @@ module Sequel
           super
         end
       end
-      
-      # Dataset class for SQLite datasets accessed via DataObjects.
-      class Dataset < DataObjects::Dataset
-        include Sequel::SQLite::DatasetMethods
-      end
     end
   end
 end

data/lib/sequel/adapters/do.rb

@@ -17,16 +17,20 @@ module Sequel
         Sequel.tsk_require 'do_postgres'
         Sequel.ts_require 'adapters/do/postgres'
         db.extend(Sequel::DataObjects::Postgres::DatabaseMethods)
+        db.extend_datasets Sequel::Postgres::DatasetMethods
       end,
       :mysql=>proc do |db|
         Sequel.tsk_require 'do_mysql'
         Sequel.ts_require 'adapters/do/mysql'
         db.extend(Sequel::DataObjects::MySQL::DatabaseMethods)
+        db.dataset_class = Sequel::DataObjects::MySQL::Dataset
       end,
       :sqlite3=>proc do |db|
         Sequel.tsk_require 'do_sqlite3'
         Sequel.ts_require 'adapters/do/sqlite'
         db.extend(Sequel::DataObjects::SQLite::DatabaseMethods)
+        db.extend_datasets Sequel::SQLite::DatasetMethods
+        db.set_integer_booleans
       end
     }
       
@@ -36,6 +40,8 @@ module Sequel
     # Sequel::DataObjects::Database object, or hack DataObjects (or Extlib) to
     # use a pool size at least as large as the pool size being used by Sequel.
     class Database < Sequel::Database
+      DISCONNECT_ERROR_RE = /terminating connection due to administrator command/
+
       set_adapter_scheme :do
       
       # Call the DATABASE_SETUP proc directly after initialization,
@@ -55,11 +61,6 @@ module Sequel
         setup_connection(::DataObjects::Connection.new(uri(server_opts(server))))
       end
       
-      # Return a Sequel::DataObjects::Dataset object for this database.
-      def dataset(opts = nil)
-        DataObjects::Dataset.new(self, opts)
-      end
-    
       # Execute the given SQL.  If a block is given, the DataObjects::Reader
       # created is yielded to it. A block should not be provided unless a
       # a SELECT statement is being used (or something else that returns rows).
@@ -114,53 +115,32 @@ module Sequel
 
       private
       
-      # DataObjects uses a special transaction object to keep track of
-      # transactions.  Unfortunately, it tries to create a new connection
-      # to do a transaction.  So we close the connection created and
-      # substitute our own.
-      def begin_transaction(conn, opts={})
-        return super if supports_savepoints?
-        log_yield(TRANSACTION_BEGIN) do
-          t = ::DataObjects::Transaction.create_for_uri(uri)
-          t.instance_variable_get(:@connection).close
-          t.instance_variable_set(:@connection, conn)
-          t.begin
-          t
-        end
-      end
-      
-      # DataObjects requires transactions be prepared before being
-      # committed, so we do that.
-      def commit_transaction(t, opts={})
-        return super if supports_savepoints?
-        log_yield(TRANSACTION_ROLLBACK) do
-          t.prepare
-          t.commit 
-        end
-      end
-      
       # Method to call on a statement object to execute SQL that does
       # not return any rows.
       def connection_execute_method
         :execute_non_query
       end
       
+      # dataobjects uses the DataObjects::Error class as the main error class.
+      def database_error_classes
+        [::DataObjects::Error]
+      end
+
       # Close the given database connection.
       def disconnect_connection(c)
         c.close
       end
+
+      # Recognize DataObjects::ConnectionError instances as disconnect errors.
+      def disconnect_error?(e, opts)
+        super || (e.is_a?(::DataObjects::Error) && (e.is_a?(::DataObjects::ConnectionError) || e.message =~ DISCONNECT_ERROR_RE))
+      end
       
       # Execute SQL on the connection by creating a command first
       def log_connection_execute(conn, sql)
         log_yield(sql){conn.create_command(sql).execute_non_query}
       end
       
-      # We use the transactions rollback method to rollback.
-      def rollback_transaction(t, opts={})
-        return super if supports_savepoints?
-        log_yield(TRANSACTION_COMMIT){t.rollback}
-      end
-      
       # Allow extending the given connection when it is first created.
       # By default, just returns the connection.
       def setup_connection(conn)
@@ -170,6 +150,8 @@ module Sequel
     
     # Dataset class for Sequel::DataObjects::Database objects.
     class Dataset < Sequel::Dataset
+      Database::DatasetClass = self
+
       # Execute the SQL on the database and yield the rows as hashes
       # with symbol keys.
       def fetch_rows(sql)