sequel 3.28.0 → 3.29.0

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

@@ -17,16 +17,19 @@ module Sequel
         Sequel.tsk_require 'do_postgres'
         Sequel.ts_require 'adapters/do/postgres'
         db.extend(Sequel::DataObjects::Postgres::DatabaseMethods)
+        db.dataset_class = Sequel::DataObjects::Postgres::Dataset
       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.dataset_class = Sequel::DataObjects::SQLite::Dataset
       end
     }
       
@@ -57,11 +60,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).
@@ -116,31 +114,6 @@ 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
@@ -167,12 +140,6 @@ module Sequel
         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)
@@ -182,6 +149,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)

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

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

@@ -55,11 +55,6 @@ 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={})

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.

data/lib/sequel/adapters/firebird.rb

@@ -28,14 +28,10 @@ module Sequel
           :password => opts[:password]).connect
       end
 
-      def dataset(opts = nil)
-        Firebird::Dataset.new(self, opts)
-      end
-
       def execute(sql, opts={})
         begin
           synchronize(opts[:server]) do |conn|
-            if conn.transaction_started && !@transactions.include?(Thread.current)
+            if conn.transaction_started && !@transactions.has_key?(conn)
               conn.rollback
               raise DatabaseDisconnectError, "transaction accidently left open, rolling back and disconnecting"
             end
@@ -59,7 +55,6 @@ module Sequel
             raise_error(e, :disconnect=>true) 
           end
         end
-        conn
       end
 
       def commit_transaction(conn, opts={})
@@ -83,6 +78,8 @@ module Sequel
     class Dataset < Sequel::Dataset
       include Sequel::Firebird::DatasetMethods
 
+      Database::DatasetClass = self
+
       # Yield all rows returned by executing the given SQL and converting
       # the types.
       def fetch_rows(sql)

data/lib/sequel/adapters/ibmdb.rb

@@ -23,8 +23,7 @@ module Sequel
       :int => tt.method(:int),
       :blob => ::Sequel::SQL::Blob.method(:new),
       :time => ::Sequel.method(:string_to_time),
-      :date => ::Sequel.method(:string_to_date),
-      :timestamp => ::Sequel.method(:database_to_application_timestamp)
+      :date => ::Sequel.method(:string_to_date)
     }
     DB2_TYPES[:clob] = DB2_TYPES[:blob]
 
@@ -163,6 +162,15 @@ module Sequel
 
       set_adapter_scheme :ibmdb
 
+      # Hash of connection procs for converting
+      attr_reader :conversion_procs
+
+      def initialize(opts={})
+        super
+        @conversion_procs = DB2_TYPES.dup
+        @conversion_procs[:timestamp] = method(:to_application_timestamp)
+      end
+
       # REORG the related table whenever it is altered.  This is not always
       # required, but it is necessary for compatibilty with other Sequel
       # code in many cases.
@@ -190,11 +198,6 @@ module Sequel
         Connection.new(connection_string)
       end
 
-      # Return a related IBMDB::Dataset instance with the given options.
-      def dataset(opts = nil)
-        IBMDB::Dataset.new(self, opts)
-      end
-
       # Execute the given SQL on the database.
       def execute(sql, opts={}, &block)
         if sql.is_a?(Symbol)
@@ -250,7 +253,7 @@ module Sequel
         if Sequel::IBMDB.convert_smallint_to_bool && db_type =~ /smallint/i 
           :boolean
         else
-          db_type =~ /[bc]lob/i ? :blob : super
+          super
         end
       end
 
@@ -293,15 +296,12 @@ module Sequel
       # So starting a transaction just turns autocommit off.
       def begin_transaction(conn, opts={})
         log_yield(TRANSACTION_BEGIN){conn.autocommit = false}
-        conn
       end
 
       # This commits transaction in progress on the
       # connection and sets autocommit back on.
       def commit_transaction(conn, opts={})
-        log_yield(TRANSACTION_COMMIT){conn.commit} if conn
-      ensure
-        conn.autocommit = true if conn
+        log_yield(TRANSACTION_COMMIT){conn.commit}
       end
     
       # Close the given connection.
@@ -332,18 +332,25 @@ module Sequel
         end
       end
 
+      # Set autocommit back on
+      def remove_transaction(conn, committed)
+        conn.autocommit = true
+      ensure
+        super
+      end
+
       # This rolls back the transaction in progress on the
       # connection and sets autocommit back on.
       def rollback_transaction(conn, opts={})
-        log_yield(TRANSACTION_ROLLBACK){conn.rollback} if conn
-      ensure
-        conn.autocommit = true if conn
+        log_yield(TRANSACTION_ROLLBACK){conn.rollback}
       end
     end
     
     class Dataset < Sequel::Dataset
       include Sequel::DB2::DatasetMethods
 
+      Database::DatasetClass = self
+
       module CallableStatementMethods
         # Extend given dataset with this module so subselects inside subselects in
         # prepared statements work.
@@ -400,13 +407,14 @@ module Sequel
           offset = @opts[:offset]
           columns = []
           convert = convert_smallint_to_bool
+          cps = db.conversion_procs
           stmt.num_fields.times do |i|
             k = stmt.field_name i
             key = output_identifier(k)
             type = stmt.field_type(k).downcase.to_sym
             # decide if it is a smallint from precision
             type = :boolean  if type ==:int && convert && stmt.field_precision(k) < 8
-            columns << [key, DB2_TYPES[type]]
+            columns << [key, cps[type]]
           end
           cols = columns.map{|c| c.at(0)}
           cols.delete(row_number_column) if offset

data/lib/sequel/adapters/informix.rb

@@ -13,10 +13,6 @@ module Sequel
         ::Informix.connect(opts[:database], opts[:user], opts[:password])
       end
     
-      def dataset(opts = nil)
-        Sequel::Informix::Dataset.new(self, opts)
-      end
-      
       # Returns number of rows affected
       def execute_dui(sql, opts={})
         synchronize(opts[:server]){|c| log_yield(sql){c.immediate(sql)}}
@@ -38,6 +34,8 @@ module Sequel
     class Dataset < Sequel::Dataset
       include DatasetMethods
 
+      Database::DatasetClass = self
+
       def fetch_rows(sql)
         execute(sql) do |cursor|
           begin

data/lib/sequel/adapters/jdbc.rb

@@ -32,35 +32,41 @@ module Sequel
     DATABASE_SETUP = {:postgresql=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/postgresql'
         db.extend(Sequel::JDBC::Postgres::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::Postgres::Dataset
         JDBC.load_gem('postgres')
         org.postgresql.Driver
       end,
       :mysql=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/mysql'
         db.extend(Sequel::JDBC::MySQL::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::MySQL::Dataset
         JDBC.load_gem('mysql')
         com.mysql.jdbc.Driver
       end,
       :sqlite=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/sqlite'
         db.extend(Sequel::JDBC::SQLite::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::SQLite::Dataset
         JDBC.load_gem('sqlite3')
         org.sqlite.JDBC
       end,
       :oracle=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/oracle'
         db.extend(Sequel::JDBC::Oracle::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::Oracle::Dataset
         Java::oracle.jdbc.driver.OracleDriver
       end,
       :sqlserver=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/sqlserver'
         db.extend(Sequel::JDBC::SQLServer::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::SQLServer::Dataset
         db.send(:set_mssql_unicode_strings)
         com.microsoft.sqlserver.jdbc.SQLServerDriver
       end,
       :jtds=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/jtds'
         db.extend(Sequel::JDBC::JTDS::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::JTDS::Dataset
         db.send(:set_mssql_unicode_strings)
         JDBC.load_gem('jtds')
         Java::net.sourceforge.jtds.jdbc.Driver
@@ -68,27 +74,46 @@ module Sequel
       :h2=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/h2'
         db.extend(Sequel::JDBC::H2::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::H2::Dataset
         JDBC.load_gem('h2')
         org.h2.Driver
       end,
+      :hsqldb=>proc do |db|
+        Sequel.ts_require 'adapters/jdbc/hsqldb'
+        db.extend(Sequel::JDBC::HSQLDB::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::HSQLDB::Dataset
+        # Current gem is 1.8.1.3, but Sequel supports 2.2.5
+        org.hsqldb.jdbcDriver
+      end,
+      :derby=>proc do |db|
+        Sequel.ts_require 'adapters/jdbc/derby'
+        db.extend(Sequel::JDBC::Derby::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::Derby::Dataset
+        JDBC.load_gem('derby')
+        org.apache.derby.jdbc.EmbeddedDriver
+      end,
       :as400=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/as400'
         db.extend(Sequel::JDBC::AS400::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::AS400::Dataset
         com.ibm.as400.access.AS400JDBCDriver
       end,
       :"informix-sqli"=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/informix'
         db.extend(Sequel::JDBC::Informix::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::Informix::Dataset
         com.informix.jdbc.IfxDriver
       end,
       :db2=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/db2'
         db.extend(Sequel::JDBC::DB2::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::DB2::Dataset
         com.ibm.db2.jcc.DB2Driver
       end,
       :firebirdsql=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/firebird'
         db.extend(Sequel::JDBC::Firebird::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::Firebird::Dataset
         org.firebirdsql.jdbc.FBDriver
       end
     }
@@ -197,11 +222,6 @@ module Sequel
         setup_connection(conn)
       end
       
-      # Return instances of JDBC::Dataset with the given opts.
-      def dataset(opts = nil)
-        JDBC::Dataset.new(self, opts)
-      end
-      
       # Execute the given SQL.  If a block is given, if should be a SELECT
       # statement or something else that returns rows.
       def execute(sql, opts={}, &block)
@@ -462,8 +482,8 @@ module Sequel
       
       # Parse the table schema for the given table.
       def schema_parse_table(table, opts={})
-        m = output_identifier_meth
-        im = input_identifier_meth
+        m = output_identifier_meth(opts[:dataset])
+        im = input_identifier_meth(opts[:dataset])
         ds = dataset
         schema, table = schema_and_table(table)
         schema ||= opts[:schema]
@@ -471,11 +491,11 @@ module Sequel
         table = im.call(table)
         pks, ts = [], []
         metadata(:getPrimaryKeys, nil, schema, table) do |h|
-          next if h[:table_schem] == 'INFORMATION_SCHEMA'
+          next if schema_parse_table_skip?(h, schema)
           pks << h[:column_name]
         end
         metadata(:getColumns, nil, schema, table, nil) do |h|
-          next if h[:table_schem] == 'INFORMATION_SCHEMA'
+          next if schema_parse_table_skip?(h, schema)
           s = {:type=>schema_column_type(h[:type_name]), :db_type=>h[:type_name], :default=>(h[:column_def] == '' ? nil : h[:column_def]), :allow_null=>(h[:nullable] != 0), :primary_key=>pks.include?(h[:column_name]), :column_size=>h[:column_size], :scale=>h[:decimal_digits]}
           if s[:db_type] =~ DECIMAL_TYPE_RE && s[:scale] == 0
             s[:type] = :integer
@@ -485,6 +505,12 @@ module Sequel
         ts
       end
       
+      # Whether schema_parse_table should skip the given row when
+      # parsing the schema.
+      def schema_parse_table_skip?(h, schema)
+        h[:table_schem] == 'INFORMATION_SCHEMA'
+      end
+
       # Yield a new statement object, and ensure that it is closed before returning.
       def statement(conn)
         stmt = conn.createStatement
@@ -505,6 +531,8 @@ module Sequel
     
     class Dataset < Sequel::Dataset
       include StoredProcedures
+
+      Database::DatasetClass = self
       
       # Use JDBC PreparedStatements instead of emulated ones.  Statements
       # created using #prepare are cached at the connection level to allow
@@ -590,7 +618,7 @@ module Sequel
       def convert_type(v)
         case v
         when Java::JavaSQL::Timestamp
-          Sequel.database_to_application_timestamp(v.to_string)
+          db.to_application_timestamp(v.to_string)
         when Java::JavaSQL::Time
           Sequel.string_to_time(v.to_string)
         when Java::JavaSQL::Date
@@ -625,7 +653,12 @@ module Sequel
         cols = []
         i = 0
         meta.getColumnCount.times{cols << [output_identifier(meta.getColumnLabel(i+=1)), i]}
-        @columns = cols.map{|c| c.at(0)}
+        columns = cols.map{|c| c.at(0)}
+        if opts[:offset] && offset_returns_row_number_column?
+          rn = row_number_column
+          columns.delete(rn)
+        end
+        @columns = columns
         blk = result_set_object_getter
         # get rows
         while result.next
@@ -633,8 +666,11 @@ module Sequel
           cols.each do |n, i|
             row[n] = blk.call(result, n, i)
           end
+          row.delete(rn) if rn
           yield row
         end
+      ensure
+        result.close
       end
 
       # Proc that takes the ResultSet and an integer field number and returns