sequel 3.21.0 → 3.32.0

data/doc/transactions.rdoc

@@ -0,0 +1,137 @@
+= Database Transactions 
+
+Sequel uses autocommit mode by default for all of its database adapters, so in general in Sequel if you want to use database transactions, you need to be explicit about it.  There are a few cases where transactions are used implicitly by default:
+
+* Dataset#import to insert many records at once
+* Model#save
+* Model#destroy
+* Migrations
+* A few model plugins
+
+Everywhere else, it is up to use to use a database transaction if you want to.
+
+== Basic Transaction Usage
+
+In Sequel, the <tt>Database#transaction</tt> method should be called if you want to use a database transaction.  This method must be called with a block.  If the block does not raise an exception, the transaction is committed:
+
+  DB.transaction do # BEGIN
+    DB[:foo].insert(1) # INSERT
+  end # COMMIT
+   
+If the block raises a Sequel::Rollback exception, the transaction is rolled back, but no exception is raised outside the block:
+
+  DB.transaction do # BEGIN
+    raise Sequel::Rollback
+  end # ROLLBACK
+  # no exception raised
+
+If any other exception is raised, the transaction is rolled back, and the exception is raised outside the block:
+
+  # ArgumentError raised
+  DB.transaction do # BEGIN
+    raise ArgumentError
+  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:
+
+  DB.transaction do # BEGIN
+    DB.transaction do
+      DB[:foo].insert(1) # INSERT
+    end
+  end # COMMIT
+
+You can use the <tt>:savepoint => true</tt> option in the inner transaction to explicitly use a savepoint (if the database supports it):
+
+  DB.transaction do # BEGIN
+    DB.transaction(:savepoint => true) do # SAVEPOINT
+      DB[:foo].insert(1) # INSERT
+    end # RELEASE SAVEPOINT
+  end # COMMIT
+
+If a Sequel::Rollback exception is raised inside the savepoint block, it will only rollback to the savepoint:
+
+  DB.transaction do # BEGIN
+    DB.transaction(:savepoint => true) do # SAVEPOINT
+      raise Sequel::Rollback
+    end # ROLLBACK TO SAVEPOINT
+    # no exception raised
+  end # COMMIT
+
+Other exceptions, unless rescued inside the outer transaction block, will rollback the savepoint and the outer transactions, since they are reraised by the transaction code:
+
+  DB.transaction do # BEGIN
+    DB.transaction(:savepoint => true) do # SAVEPOINT
+      raise ArgumentError
+    end # ROLLBACK TO SAVEPOINT
+  end # ROLLBACK
+  # ArgumentError raised
+
+== Prepared Transactions / Two-Phase Commit
+
+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:
+
+  DB.transaction(:prepare => 'foo') do # BEGIN
+    DB[:foo].insert(1) # INSERT
+  end # PREPARE TRANSACTION 'foo'
+   
+Later, you can commit the prepared transaction:
+
+  DB.commit_prepared_transaction('foo')
+
+or roll the prepared transaction back:
+
+  DB.rollback_prepared_transaction('foo')
+
+== Transaction Isolation Levels
+
+The SQL standard supports 4 isolation levels: READ UNCOMMITTED, READ COMMITTED, REPEATABLE READ, and SERIALIZABLE.  Not all databases implement the levels as specified in the standard (or implement the levels at all), but on PostgreSQL, MySQL, and Microsoft SQL Server, you can specify which transaction isolation level you want to use via the :isolation option to <tt>Database#transaction</tt>.  The isolation level is specified as one of the following symbols: :uncommitted, :committed, :repeatable, and :serializable.  Using this option make Sequel use the correct transaction isolation syntax for your database:
+
+  DB.transaction(:isolation => :serializable) do # BEGIN
+    # SET TRANSACTION ISOLATION LEVEL SERIALIZABLE
+    DB[:foo].insert(1) # INSERT
+  end # COMMIT

data/doc/virtual_rows.rdoc

@@ -40,7 +40,7 @@ available.  For example, you are no longer able to do:
   # WHERE a AND (b OR NOT c)
   
 Because Symbol#&, Symbol#| and Symbol#~ are not defined when the core
-extensions are turned off.  However, with virtual rows allow almost the same
+extensions are turned off.  However, virtual rows allow almost the same
 syntax even without the core extensions:
 
   dataset.filter{a & (b | ~c)}
@@ -87,7 +87,7 @@ and second is the difference between the the use of "a".  In the regular proc,
 you couldn't call c without an explicit receiver in the proc, unless the self of the
 surrounding scope responded to it.  For a, note how ruby calls the method on
 the receiver of the surrounding scope in the regular proc, which returns an integer,
-and does the substraction before Sequel gets access to it.  In the instance evaled
+and does the substitution before Sequel gets access to it.  In the instance evaled
 proc, calling a without a receiver calls the a method on the VirtualRow instance.
 For b, note that it operates the same in both cases, as it is a local variable.
 

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/ado.rb

@@ -4,6 +4,8 @@ module Sequel
   # The ADO adapter provides connectivity to ADO databases in Windows.
   module ADO
     class Database < Sequel::Database
+      DISCONNECT_ERROR_RE = /Communication link failure/
+
       set_adapter_scheme :ado
 
       def initialize(opts)
@@ -12,12 +14,15 @@ module Sequel
         when /Microsoft\.(Jet|ACE)\.OLEDB/io
           Sequel.ts_require 'adapters/shared/access'
           extend Sequel::Access::DatabaseMethods
-        when nil
+          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
       end
@@ -52,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
@@ -74,28 +75,49 @@ 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
+
       def disconnect_connection(conn)
         conn.Close
       end
+
+      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/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,11 @@ 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)
+        Sequel.string_to_time(s)
       end
       
       # Don't raise an error if the value is a string and the declared
@@ -68,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
       
@@ -77,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)}}
@@ -151,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)
@@ -168,8 +176,8 @@ module Sequel
       private
       
       # Quote the string using the adapter instance method.
-      def literal_string(v)
-        db.synchronize{|c| c.quote(v)}
+      def literal_string_append(sql, v)
+        db.synchronize{|c| sql << c.quote(v)}
       end
     end
   end

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