sequel 3.28.0 → 3.29.0

data/doc/sharding.rdoc

@@ -10,7 +10,13 @@ that ship with Sequel.
 
 Both features use the :servers Database option.  The :servers option should
 be a hash with symbol keys and values that are either hashes or procs that
-return hashes.  Note that all servers should have the same schema for all
+return hashes. These hashes are merged into the Database object's default
+options hash to get the connection options for the shard, so you don't need
+to override all options, just the ones that need to be modified.  For example,
+if you are using the same user, password, and database name and just the
+host is changing, you only need a :host entry in each shard's hash.
+
+Note that all servers should have the same schema for all
 tables you are accessing, unless you really know what you are doing.
 
 == Master and Slave Database Configurations

data/doc/testing.rdoc

@@ -6,12 +6,14 @@ Whether or not you use Sequel in your application, you are usually going to want
 
 These run each test in its own transaction, the recommended way to test.
 
+Make sure you are using Sequel 3.29.0 or above when using these examples, as older versions don't support the <tt>:rollback=>:always</tt> option.
+
 === RSpec 1
 
   class Spec::Example::ExampleGroup
     def execute(*args, &block)
       x = nil
-      Sequel::Model.db.transaction{x = super(*args, &block); raise Sequel::Rollback}
+      Sequel::Model.db.transaction(:rollback=>:always){x = super(*args, &block)}
       x
     end
   end
@@ -20,7 +22,7 @@ These run each test in its own transaction, the recommended way to test.
 
   class Spec::Example::ExampleGroup
     around do |example|
-      Sequel::Model.db.transaction{example.call; raise Sequel::Rollback}
+      Sequel::Model.db.transaction(:rollback=>:always){example.call}
     end
   end
 
@@ -29,13 +31,20 @@ These run each test in its own transaction, the recommended way to test.
   # Must use this class as the base class for your tests
   class SequelTestCase < Test::Unit::TestCase
     def run(*args, &block)
-      Sequel::Model.db.transaction do
-        super
-        raise Sequel::Rollback
-      end
+      Sequel::Model.db.transaction(:rollback=>:always){super}
     end
   end
 
+== Transactional testing with multiple databases
+
+You can use the Sequel.transaction method to run a transaction on multiple databases, rolling all of them back.  Instead of:
+
+  Sequel::Model.db.transaction(:rollback=>:always)
+
+Use Sequel.transaction with an array of databases:
+
+  Sequel.transaction([DB1, DB2, DB3], :rollback=>:always)
+
 == Nontransactional tests
 
 In some cases, it is not possible to use transactions.  For example, if you are testing a web application that is running in a separate process, you don't have access to that process's database connections, so you can't run your examples in transactions.  In that case, the best way to handle things is to cleanup after each test by deleting or truncating the database tables used in the test.
@@ -77,13 +86,13 @@ The +spec_plugin+ rake task runs the specs for the plugins and extensions that s
 
 == rake spec_<i>adapter</i> (e.g. rake spec_postgres)
 
-The <tt>spec_<i>adapter</i></tt> specs run against a real database connection with nothing mocked, and test for correct results.  They are much slower than the standard specs, but they will catch errors that are mocked out by the default specs, as well show issues that only occur on a certain database, adapter, interpreter, or some combination of those.
+The <tt>spec_<i>adapter</i></tt> specs run against a real database connection with nothing mocked, and test for correct results.  They are slower than the standard specs, but they will catch errors that are mocked out by the default specs, as well as show issues that only occur on a certain database, adapter, or a combination of the two.
 
 These specs are broken down into two parts.  For each database, there are specific specs that only apply to that database, and these are called the adapter specs.  There are also shared specs that apply to all (or almost all) databases, these are called the integration specs.
 
 == Environment variables
 
-Sequel often uses environment variables when testing to specify either the database to be tested or specify how testing should be done.
+Sequel often uses environment variables when testing to specify either the database to be tested or specify how testing should be done.  You can also specify the databases to test by copying spec/spec_config.rb.example to spec/spec_config.rb and modifying it.  See that file for details.  It may be necessary to use spec_config.rb as opposed to an environment variable if you database connection cannot be specified by a connection string.
 
 === Connection Strings
 
@@ -101,6 +110,6 @@ The following environment variables specify Database connection URL strings:
 
 * SEQUEL_MSSQL_SPEC_REQUIRE: Separate file to require when running mssql adapter specs
 * SEQUEL_DB2_SPEC_REQUIRE: Separate file to require when running db2 adapter specs
-* SEQUEL_COLUMNS_INTROSPECTION: Whehter to run the specs with the columns_introspection extension loaded by default
+* SEQUEL_COLUMNS_INTROSPECTION: Whether to run the specs with the columns_introspection extension loaded by default
 * SEQUEL_NO_PENDING: Don't mark any specs as pending, try running all specs
 * SKIPPED_TEST_WARN: Warn when skipping any tests because libraries aren't available

data/doc/transactions.rdoc

@@ -33,6 +33,46 @@ If any other exception is raised, the transaction is rolled back, and the except
   end # ROLLBACK
   # ArgumentError raised
 
+If you want Sequel::Rollback exceptions to be reraised, use the <tt>:rollback => :reraise</tt> option:
+
+  DB.transaction(:rollback => :reraise) do # BEGIN
+    raise Sequel::Rollback
+  end # ROLLBACK
+  # Sequel::Rollback raised
+
+If you always want to rollback (useful for testing), use the <tt>:rollback => :always</tt> option:
+
+  DB.transaction(:rollback => :always) do # BEGIN
+    DB[:foo].insert(1) # INSERT
+  end # ROLLBACK
+
+If you want to check whether you are currently in a transaction, use the Database#in_transaction? method:
+
+  DB.in_transaction? # false
+  DB.transaction do
+    DB.in_transaction? # true
+  end
+
+== Transaction Hooks
+
+You can add hooks to an in progress transaction that are called after the transaction commits or rolls back:
+
+  x = nil
+  DB.transaction do
+    DB.after_commit{x = 1}
+    DB.after_rollback{x = 2}
+    x # nil
+  end
+  x # 1
+  
+  x = nil
+  DB.transaction do
+    DB.after_commit{x = 1}
+    DB.after_rollback{x = 2}
+    raise Sequel::Rollback
+  end
+  x # 2
+
 == Nested Transaction Calls / Savepoints
 
 You can nest calls to transaction, which by default just reuses the existing transaction:
@@ -71,7 +111,7 @@ Other exceptions, unless rescued inside the outer transaction block, will rollba
 
 == Prepared Transactions / Two-Phase Commit
 
-Sequel supports database prepared transactions on PostreSQL, MySQL, and H2.  With prepared transactions, at the end of the transaction, the transaction is not immediately committed (it acts like a rollback).  Later, you can call +commit_prepared_transaction+ to commit the transaction or +rollback_prepared_transaction+ to roll the transaction back.  Prepared transactions are usually used with distributed databases to make sure all databases commit the same transaction or none of them do.
+Sequel supports database prepared transactions on PostgreSQL, MySQL, and H2.  With prepared transactions, at the end of the transaction, the transaction is not immediately committed (it acts like a rollback).  Later, you can call +commit_prepared_transaction+ to commit the transaction or +rollback_prepared_transaction+ to roll the transaction back.  Prepared transactions are usually used with distributed databases to make sure all databases commit the same transaction or none of them do.
 
 To use prepared transactions in Sequel, you provide a string as the value of the :prepare option:
 

data/lib/sequel/adapters/ado.rb

@@ -14,12 +14,14 @@ module Sequel
         when /Microsoft\.(Jet|ACE)\.OLEDB/io
           Sequel.ts_require 'adapters/shared/access'
           extend Sequel::Access::DatabaseMethods
+          extend_datasets(Sequel::Access::DatasetMethods)
         else
           @opts[:driver] ||= 'SQL Server'
           case @opts[:driver]
           when 'SQL Server'
             Sequel.ts_require 'adapters/ado/mssql'
             extend Sequel::ADO::MSSQL::DatabaseMethods
+            @dataset_class = ADO::MSSQL::Dataset
             set_mssql_unicode_strings
           end
         end
@@ -55,10 +57,6 @@ module Sequel
         handle
       end
       
-      def dataset(opts = nil)
-        ADO::Dataset.new(self, opts)
-      end
-    
       def execute(sql, opts={})
         synchronize(opts[:server]) do |conn|
           begin
@@ -77,18 +75,14 @@ module Sequel
       # The ADO adapter's default provider doesn't support transactions, since it 
       # creates a new native connection for each query.  So Sequel only attempts
       # to use transactions if an explicit :provider is given.
-      def _transaction(conn, o={})
-        return super if opts[:provider]
-        th = Thread.current
-        begin
-          @transactions << th
-          yield conn
-        rescue Sequel::Rollback
-        ensure
-          @transactions.delete(th)
-        end
+      def begin_transaction(conn, opts={})
+        super if @opts[:provider]
       end
-      
+
+      def commit_transaction(conn, opts={})
+        super if @opts[:provider]
+      end
+
       def database_error_classes
         [::WIN32OLERuntimeError]
       end
@@ -100,13 +94,30 @@ module Sequel
       def disconnect_error?(e, opts)
         super || (e.is_a?(::WIN32OLERuntimeError) && e.message =~ DISCONNECT_ERROR_RE)
       end
+
+      def rollback_transaction(conn, opts={})
+        super if @opts[:provider]
+      end
     end
     
     class Dataset < Sequel::Dataset
+      Database::DatasetClass = self
+
       def fetch_rows(sql)
         execute(sql) do |s|
-          @columns = cols = s.Fields.extend(Enumerable).map{|column| output_identifier(column.Name)}
-          s.getRows.transpose.each{|r| yield cols.inject({}){|m,c| m[c] = r.shift; m}} unless s.eof
+          columns = cols = s.Fields.extend(Enumerable).map{|column| output_identifier(column.Name)}
+          if opts[:offset] && offset_returns_row_number_column?
+            rn = row_number_column
+            columns = columns.dup
+            columns.delete(rn)
+          end
+          @columns = columns
+          s.getRows.transpose.each do |r|
+            row = {}
+            cols.each{|c| row[c] = r.shift}
+            row.delete(rn) if rn
+            yield row
+          end unless s.eof
         end
       end
       

data/lib/sequel/adapters/ado/mssql.rb

@@ -11,11 +11,6 @@ module Sequel
         # delete query.
         ROWS_AFFECTED = "SELECT @@ROWCOUNT AS AffectedRows"
         
-        # Return instance of Sequel::ADO::MSSQL::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::ADO::MSSQL::Dataset.new(self, opts)
-        end
-        
         # Just execute so it doesn't attempt to return the number of rows modified.
         def execute_ddl(sql, opts={})
           execute(sql, opts)
@@ -37,11 +32,28 @@ module Sequel
             end
           end
         end
+
+        private
+
+        # The ADO adapter's default provider doesn't support transactions, since it 
+        # creates a new native connection for each query.  So Sequel only attempts
+        # to use transactions if an explicit :provider is given.
+        def begin_transaction(conn, opts={})
+          super if @opts[:provider]
+        end
+
+        def commit_transaction(conn, opts={})
+          super if @opts[:provider]
+        end
+
+        def rollback_transaction(conn, opts={})
+          super if @opts[:provider]
+        end
       end
       
       class Dataset < ADO::Dataset
         include Sequel::MSSQL::DatasetMethods
-        
+
         # Use a nasty hack of multiple SQL statements in the same call and
         # having the last one return the most recently inserted id.  This
         # is necessary as ADO's default :provider uses a separate native

data/lib/sequel/adapters/amalgalite.rb

@@ -14,6 +14,12 @@ module Sequel
         'float' => ['float', 'double', 'real', 'double precision'],
         'decimal' => %w'numeric decimal money'
       )
+
+      # Store the related database object, in order to be able to correctly
+      # handle the database timezone.
+      def initialize(db)
+        @db = db
+      end
       
       # Return blobs as instances of Sequel::SQL::Blob instead of
       # Amalgamite::Blob
@@ -29,7 +35,7 @@ module Sequel
       
       # Return datetime types as instances of Sequel.datetime_class
       def datetime(s)
-        Sequel.database_to_application_timestamp(s)
+        @db.to_application_timestamp(s)
       end
 
       def time(s)
@@ -72,7 +78,8 @@ module Sequel
         opts[:database] = ':memory:' if blank_object?(opts[:database])
         db = ::Amalgalite::Database.new(opts[:database])
         db.busy_handler(::Amalgalite::BusyTimeout.new(opts.fetch(:timeout, 5000)/50, 50))
-        db.type_map = SequelTypeMap.new
+        db.type_map = SequelTypeMap.new(self)
+        connection_pragmas.each{|s| log_yield(s){db.execute_batch(s)}}
         db
       end
       
@@ -81,11 +88,6 @@ module Sequel
         :sqlite
       end
 
-      # Return instance of Sequel::Amalgalite::Dataset with the given options.
-      def dataset(opts = nil)
-        Amalgalite::Dataset.new(self, opts)
-      end
-      
       # Run the given SQL with the given arguments. Returns nil.
       def execute_ddl(sql, opts={})
         _execute(sql, opts){|conn| log_yield(sql){conn.execute_batch(sql)}}
@@ -155,6 +157,8 @@ module Sequel
     # Dataset class for SQLite datasets that use the amalgalite driver.
     class Dataset < Sequel::Dataset
       include ::Sequel::SQLite::DatasetMethods
+
+      Database::DatasetClass = self
       
       # Yield a hash for each row in the dataset.
       def fetch_rows(sql)

data/lib/sequel/adapters/db2.rb

@@ -3,36 +3,60 @@ 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
       include DatabaseMethods
 
       set_adapter_scheme :db2
 
       TEMPORARY = 'GLOBAL TEMPORARY '.freeze
+      rc, NullHandle = DB2CLI.SQLAllocHandle(DB2CLI::SQL_HANDLE_ENV, DB2CLI::SQL_NULL_HANDLE)
       
-      rc, @@env = DB2CLI.SQLAllocHandle(DB2CLI::SQL_HANDLE_ENV, DB2CLI::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 = DB2CLI.SQLAllocHandle(DB2CLI::SQL_HANDLE_DBC, @@env) 
-        check_error(rc, "Could not allocate database connection")
-        
-        rc = DB2CLI.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
-      end
-
-      def dataset(opts = nil)
-        DB2::Dataset.new(self, opts)
-      end
-      
       def execute(sql, opts={}, &block)
         synchronize(opts[:server]){|conn| log_connection_execute(conn, sql, &block)}
       end
@@ -43,11 +67,9 @@ module Sequel
           log_connection_execute(conn, sql)
           sql = "SELECT IDENTITY_VAL_LOCAL() FROM SYSIBM.SYSDUMMY1"
           log_connection_execute(conn, sql) do |sth|
-            rc, name, buflen, datatype, size, digits, nullable = DB2CLI.SQLDescribeCol(sth, 1, 256)
-            check_error(rc, "Could not describe column")
-            if (rc = DB2CLI.SQLFetch(sth)) != DB2CLI::SQL_NO_DATA_FOUND
-              rc, v = DB2CLI.SQLGetData(sth, 1, datatype, size)
-              check_error(rc, "Could not get data")
+            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
@@ -58,67 +80,101 @@ module Sequel
         end
       end
       
+      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 DB2CLI::SQL_SUCCESS, DB2CLI::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 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)}
-        conn
+      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)}
-      ensure
-        DB2CLI.SQLSetConnectAttr(conn, DB2CLI::SQL_ATTR_AUTOCOMMIT, DB2CLI::SQL_AUTOCOMMIT_ON)
       end
 
       def commit_transaction(conn, opts={})
         log_yield(TRANSACTION_COMMIT){DB2CLI.SQLEndTran(DB2CLI::SQL_HANDLE_DBC, conn, DB2CLI::SQL_COMMIT)}
-      ensure
-        DB2CLI.SQLSetConnectAttr(conn, DB2CLI::SQL_ATTR_AUTOCOMMIT, DB2CLI::SQL_AUTOCOMMIT_ON)
       end
     
       def log_connection_execute(conn, sql)
-        rc, sth = DB2CLI.SQLAllocHandle(DB2CLI::SQL_HANDLE_STMT, conn) 
-        check_error(rc, "Could not allocate statement")
+        sth = checked_error("Could not allocate statement"){DB2CLI.SQLAllocHandle(DB2CLI::SQL_HANDLE_STMT, conn)}
 
         begin
-          rc = log_yield(sql){DB2CLI.SQLExecDirect(sth, sql)}
-          check_error(rc, "Could not execute statement: #{sql}")
+          checked_error("Could not execute statement: #{sql}"){log_yield(sql){DB2CLI.SQLExecDirect(sth, sql)}}
           
-          yield(sth) if block_given?
-
-          rc, rpc = DB2CLI.SQLRowCount(sth)
-          check_error(rc, "Could not get RPC") 
-          rpc
+          if block_given?
+            yield(sth)
+          else
+            checked_error("Could not get RPC"){DB2CLI.SQLRowCount(sth)}
+          end
         ensure
-          rc = DB2CLI.SQLFreeHandle(DB2CLI::SQL_HANDLE_STMT, sth)
-          check_error(rc, "Could not free statement")
+          checked_error("Could not free statement"){DB2CLI.SQLFreeHandle(DB2CLI::SQL_HANDLE_STMT, sth)}
         end
       end
 
-      def disconnect_connection(conn)
-        rc = DB2CLI.SQLDisconnect(conn)
-        check_error(rc, "Could not disconnect from database")
+      # 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
 
-        rc = DB2CLI.SQLFreeHandle(DB2CLI::SQL_HANDLE_DBC, conn)
-        check_error(rc, "Could not free Database handle")
+      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|
           offset = @opts[:offset]
@@ -128,13 +184,19 @@ module Sequel
           cols = column_info.map{|c| c.at(1)}
           cols.delete(row_number_column) if offset
           @columns = cols
-          while (rc = DB2CLI.SQLFetch(sth)) != DB2CLI::SQL_NO_DATA_FOUND
+          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|
-              rc, v = DB2CLI.SQLGetData(sth, i, t, s) 
-              db.check_error(rc, "Could not get data")
-              row[c] = convert_type(v)
+            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
@@ -147,30 +209,20 @@ module Sequel
 
       def get_column_info(sth)
         db = @db
-        rc, column_count = DB2CLI.SQLNumResultCols(sth)
-        db.check_error(rc, "Could not get number of result columns")
+        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 = DB2CLI.SQLDescribeCol(sth, i, MAX_COL_SIZE)
-          db.check_error(rc, "Could not describe column")
-          [i, output_identifier(name), datatype, 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 convert_type(v)
-        case v
-        when DB2CLI::Date 
-          Date.new(v.year, v.month, v.day)
-        when DB2CLI::Time
-          Sequel::SQLTime.create(v.hour, v.minute, v.second)
-        when DB2CLI::Timestamp 
-          Sequel.database_to_application_timestamp(v.to_s)
-        when DB2CLI::Null
-          nil
-        else  
-          v
-        end
-      end
     end
   end
 end