sequel 4.26.0 → 5.37.0

data/lib/sequel/adapters/jdbc/sqlanywhere.rb

@@ -1,5 +1,7 @@
-Sequel.require 'adapters/shared/sqlanywhere'
-Sequel.require 'adapters/jdbc/transactions'
+# frozen-string-literal: true
+
+require_relative '../shared/sqlanywhere'
+require_relative 'transactions'
 
 module Sequel
   module JDBC
@@ -21,57 +23,45 @@ module Sequel
     Sequel.synchronize do
       DATABASE_SETUP[:sqlanywhere] = proc do |db|
         db.extend(Sequel::JDBC::SqlAnywhere::DatabaseMethods)
+        db.convert_smallint_to_bool = true
         db.dataset_class = Sequel::JDBC::SqlAnywhere::Dataset
         drv
       end
     end
 
-    class TypeConvertor
-      def SqlAnywhereBoolean(r, i)
-        if v = Short(r, i)
-          v != 0
-        end
-      end
-    end
-
     module SqlAnywhere
-      # Database instance methods for Sybase databases accessed via JDBC.
       module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::SqlAnywhere::DatabaseMethods
         include Sequel::JDBC::Transactions
 
-        LAST_INSERT_ID = 'SELECT @@IDENTITY'.freeze
-
         private
 
-        # Get the last inserted id.
+        # Use @@IDENTITY to get the last inserted id
         def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
-            sql = LAST_INSERT_ID
-            rs = log_yield(sql){stmt.executeQuery(sql)}
+            sql = 'SELECT @@IDENTITY'
+            rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
             rs.next
             rs.getLong(1)
           end
         end
-
-        def setup_type_convertor_map
-          super
-          @type_convertor_map[:SqlAnywhereBoolean] = TypeConvertor::INSTANCE.method(:SqlAnywhereBoolean)
-        end
       end
 
-      #Dataset class for Sybase datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
         include Sequel::SqlAnywhere::DatasetMethods
 
         private
 
         SMALLINT_TYPE = Java::JavaSQL::Types::SMALLINT
+        BOOLEAN_METHOD = Object.new
+        def BOOLEAN_METHOD.call(r, i)
+          v = r.getShort(i)
+          v != 0 unless r.wasNull
+        end
 
         def type_convertor(map, meta, type, i)
           if convert_smallint_to_bool && type == SMALLINT_TYPE
-            map[:SqlAnywhereBoolean]
+            BOOLEAN_METHOD
           else
             super
           end

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

@@ -1,5 +1,7 @@
+# frozen-string-literal: true
+
 Sequel::JDBC.load_driver('org.sqlite.JDBC', :SQLite3)
-Sequel.require 'adapters/shared/sqlite'
+require_relative '../shared/sqlite'
 
 module Sequel
   module JDBC
@@ -12,21 +14,34 @@ module Sequel
       end
     end
 
-    # Database and Dataset support for SQLite databases accessed via JDBC.
     module SQLite
-      # Instance methods for SQLite Database objects accessed via JDBC.
+      module ForeignKeyListPragmaConvertorFix
+        # For the use of the convertor for String, working around a bug
+        # in jdbc-sqlite3 that reports fields are of type
+        # java.sql.types.NUMERIC even though they contain non-numeric data.
+        def type_convertor(_, _, _, i)
+          i > 2 ? TypeConvertor::CONVERTORS[:String] : super
+        end
+      end
+
+      module TableInfoPragmaConvertorFix
+        # For the use of the convertor for String, working around a bug
+        # in jdbc-sqlite3 that reports dflt_value field is of type
+        # java.sql.types.NUMERIC even though they contain string data.
+        def type_convertor(_, _, _, i)
+          i == 5 ? TypeConvertor::CONVERTORS[:String] : super
+        end
+      end
+
       module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::SQLite::DatabaseMethods
-        LAST_INSERT_ROWID = 'SELECT last_insert_rowid()'.freeze
-        FOREIGN_KEY_ERROR_RE = /query does not return ResultSet/.freeze
         
         # Swallow pointless exceptions when the foreign key list pragma
         # doesn't return any rows.
         def foreign_key_list(table, opts=OPTS)
           super
         rescue Sequel::DatabaseError => e
-          raise unless e.message =~ FOREIGN_KEY_ERROR_RE
+          raise unless foreign_key_error?(e)
           []
         end
 
@@ -35,11 +50,22 @@ module Sequel
         def indexes(table, opts=OPTS)
           super
         rescue Sequel::DatabaseError => e
-          raise unless e.message =~ FOREIGN_KEY_ERROR_RE
+          raise unless foreign_key_error?(e)
           {}
         end
 
         private
+
+
+        # Add workaround for bug when running foreign_key_list pragma
+        def _foreign_key_list_ds(_)
+          super.with_extend(ForeignKeyListPragmaConvertorFix)
+        end
+
+        # Add workaround for bug when running table_info pragma
+        def _parse_pragma_ds(_, _)
+          super.with_extend(TableInfoPragmaConvertorFix)
+        end
         
         DATABASE_ERROR_REGEXPS = Sequel::SQLite::DatabaseMethods::DATABASE_ERROR_REGEXPS.merge(/Abort due to constraint violation/ => ConstraintViolation).freeze
         def database_error_regexps
@@ -49,7 +75,7 @@ module Sequel
         # Use last_insert_rowid() to get the last inserted id.
         def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
-            rs = stmt.executeQuery(LAST_INSERT_ROWID)
+            rs = stmt.executeQuery('SELECT last_insert_rowid()')
             rs.next
             rs.getLong(1)
           end
@@ -65,23 +91,30 @@ module Sequel
         def setup_connection(conn)
           conn = super(conn)
           statement(conn) do |stmt|
-            connection_pragmas.each{|s| log_yield(s){stmt.execute(s)}}
+            connection_pragmas.each{|s| log_connection_yield(s, conn){stmt.execute(s)}}
           end
           conn
         end
 
+        # Whether the given exception is due to a foreign key error.
+        def foreign_key_error?(exception)
+          exception.message =~ /query does not return ResultSet/
+        end
+
         # Use getLong instead of getInt for converting integers on SQLite, since SQLite does not enforce a limit of 2**32.
         # Work around regressions in jdbc-sqlite 3.8.7 for date and blob types.
         def setup_type_convertor_map
           super
           @type_convertor_map[Java::JavaSQL::Types::INTEGER] = @type_convertor_map[Java::JavaSQL::Types::BIGINT]
           @basic_type_convertor_map[Java::JavaSQL::Types::INTEGER] = @basic_type_convertor_map[Java::JavaSQL::Types::BIGINT]
-          @type_convertor_map[Java::JavaSQL::Types::DATE] = lambda do |r, i|
+          x = @type_convertor_map[Java::JavaSQL::Types::DATE] = Object.new
+          def x.call(r, i)
             if v = r.getString(i)
               Sequel.string_to_date(v)
             end
           end
-          @type_convertor_map[Java::JavaSQL::Types::BLOB] = lambda do |r, i|
+          x = @type_convertor_map[Java::JavaSQL::Types::BLOB] = Object.new
+          def x.call(r, i)
             if v = r.getBytes(i)
               Sequel::SQL::Blob.new(String.from_java_bytes(v))
             elsif !r.wasNull
@@ -89,6 +122,11 @@ module Sequel
             end
           end
         end
+
+        # The result code for the exception, if the jdbc driver supports result codes for exceptions.
+        def sqlite_error_code(exception)
+          exception.resultCode.code if exception.respond_to?(:resultCode)
+        end
       end
     end
   end

data/lib/sequel/adapters/jdbc/sqlserver.rb

@@ -1,5 +1,7 @@
+# frozen-string-literal: true
+
 Sequel::JDBC.load_driver('com.microsoft.sqlserver.jdbc.SQLServerDriver')
-Sequel.require 'adapters/jdbc/mssql'
+require_relative 'mssql'
 
 module Sequel
   module JDBC
@@ -12,14 +14,39 @@ module Sequel
       end
     end
 
-    # Database and Dataset instance methods for SQLServer specific
-    # support via JDBC.
     module SQLServer
-      # Database instance methods for SQLServer databases accessed via JDBC.
+      MSSQL_RUBY_TIME = Object.new
+      def MSSQL_RUBY_TIME.call(r, i)
+        # MSSQL-Server TIME should be fetched as string to keep the precision intact, see:
+        # https://docs.microsoft.com/en-us/sql/t-sql/data-types/time-transact-sql#a-namebackwardcompatibilityfordownlevelclientsa-backward-compatibility-for-down-level-clients
+        if v = r.getString(i)
+          Sequel.string_to_time("#{v}")
+        end
+      end
+
       module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::JDBC::MSSQL::DatabaseMethods
 
+        def setup_type_convertor_map
+          super
+          map = @type_convertor_map
+          map[Java::JavaSQL::Types::TIME] = MSSQL_RUBY_TIME
+
+          # Work around constant lazy loading in some drivers
+          begin
+            dto = Java::MicrosoftSql::Types::DATETIMEOFFSET
+          rescue NameError
+          end
+
+          if dto
+            map[dto] = lambda do |r, i|
+              if v = r.getDateTimeOffset(i)
+                to_application_timestamp(v.to_s)
+              end
+            end
+          end
+        end
+
         # Work around a bug in SQL Server JDBC Driver 3.0, where the metadata
         # for the getColumns result set specifies an incorrect type for the
         # IS_AUTOINCREMENT column. The column is a string, but the type is
@@ -46,12 +73,12 @@ module Sequel
           end
         end
         
-        def metadata_dataset
-          super.extend(MetadataDatasetMethods)
-        end
-
         private
 
+        def _metadata_dataset
+          super.with_extend(MetadataDatasetMethods)
+        end
+
         def disconnect_error?(exception, opts)
           super || (exception.message =~ /connection is closed/)
         end

data/lib/sequel/adapters/jdbc/transactions.rb

@@ -1,12 +1,12 @@
+# frozen-string-literal: true
+
 module Sequel
   module JDBC
     module Transactions
-      TRANSACTION_BEGIN = 'Transaction.begin'.freeze
-      TRANSACTION_COMMIT = 'Transaction.commit'.freeze
-      TRANSACTION_RELEASE_SP = 'Transaction.release_savepoint'.freeze
-      TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
-      TRANSACTION_ROLLBACK_SP = 'Transaction.rollback_savepoint'.freeze
-      TRANSACTION_SAVEPOINT= 'Transaction.savepoint'.freeze
+      def freeze
+        supports_savepoints?
+        super
+      end
 
       # Check the JDBC DatabaseMetaData for savepoint support
       def supports_savepoints?
@@ -25,7 +25,7 @@ module Sequel
       JDBC_TRANSACTION_ISOLATION_LEVELS = {:uncommitted=>JavaSQL::Connection::TRANSACTION_READ_UNCOMMITTED,
         :committed=>JavaSQL::Connection::TRANSACTION_READ_COMMITTED,
         :repeatable=>JavaSQL::Connection::TRANSACTION_REPEATABLE_READ,
-        :serializable=>JavaSQL::Connection::TRANSACTION_SERIALIZABLE}
+        :serializable=>JavaSQL::Connection::TRANSACTION_SERIALIZABLE}.freeze
 
       # Set the transaction isolation level on the given connection using
       # the JDBC API.
@@ -34,7 +34,7 @@ module Sequel
         if (jdbc_level = JDBC_TRANSACTION_ISOLATION_LEVELS[level]) &&
             conn.getMetaData.supportsTransactionIsolationLevel(jdbc_level)
           _trans(conn)[:original_jdbc_isolation_level] = conn.getTransactionIsolation
-          log_yield("Transaction.isolation_level = #{level}"){conn.setTransactionIsolation(jdbc_level)}
+          log_connection_yield("Transaction.isolation_level = #{level}", conn){conn.setTransactionIsolation(jdbc_level)}
         end
       end
 
@@ -43,47 +43,38 @@ module Sequel
         true
       end
 
+      # JDBC savepoint object for the current savepoint for the connection.
+      def savepoint_obj(conn)
+        _trans(conn)[:savepoints][-1][:obj]
+      end
+
       # Use JDBC connection's setAutoCommit to false to start transactions
       def begin_transaction(conn, opts=OPTS)
-        if supports_savepoints?
-          th = _trans(conn)
-          if sps = th[:savepoint_objs]
-            sps << log_yield(TRANSACTION_SAVEPOINT){conn.set_savepoint}
-          else
-            log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
-            th[:savepoint_objs] = []
-            set_transaction_isolation(conn, opts)
-          end
+        if in_savepoint?(conn)
+          _trans(conn)[:savepoints][-1][:obj] = log_connection_yield('Transaction.savepoint', conn){conn.set_savepoint}
         else
-          log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
+          log_connection_yield('Transaction.begin', conn){conn.setAutoCommit(false)}
           set_transaction_isolation(conn, opts)
         end
       end
       
       # Use JDBC connection's commit method to commit transactions
       def commit_transaction(conn, opts=OPTS)
-        if supports_savepoints?
-          sps = _trans(conn)[:savepoint_objs]
-          if sps.empty?
-            log_yield(TRANSACTION_COMMIT){conn.commit}
-          elsif supports_releasing_savepoints?
-            log_yield(TRANSACTION_RELEASE_SP){supports_releasing_savepoints? ? conn.release_savepoint(sps.last) : sps.last}
+        if in_savepoint?(conn)
+          if supports_releasing_savepoints?
+            log_connection_yield('Transaction.release_savepoint', conn){conn.release_savepoint(savepoint_obj(conn))}
           end
         else
-          log_yield(TRANSACTION_COMMIT){conn.commit}
+          log_connection_yield('Transaction.commit', conn){conn.commit}
         end
       end
       
       # Use JDBC connection's setAutoCommit to true to enable non-transactional behavior
       def remove_transaction(conn, committed)
         if jdbc_level = _trans(conn)[:original_jdbc_isolation_level]
-          conn.setTransactionIsolation(jdbc_level)
+          log_connection_yield("Transaction.restore_isolation_level", conn){conn.setTransactionIsolation(jdbc_level)}
         end
-        if supports_savepoints?
-          sps = _trans(conn)[:savepoint_objs]
-          conn.setAutoCommit(true) if sps.empty?
-          sps.pop
-        else
+        unless in_savepoint?(conn)
           conn.setAutoCommit(true)
         end
       ensure
@@ -92,15 +83,10 @@ module Sequel
       
       # Use JDBC connection's rollback method to rollback transactions
       def rollback_transaction(conn, opts=OPTS)
-        if supports_savepoints?
-          sps = _trans(conn)[:savepoint_objs]
-          if sps.empty?
-            log_yield(TRANSACTION_ROLLBACK){conn.rollback}
-          else
-            log_yield(TRANSACTION_ROLLBACK_SP){conn.rollback(sps.last)}
-          end
+        if in_savepoint?(conn)
+          log_connection_yield('Transaction.rollback_savepoint', conn){conn.rollback(savepoint_obj(conn))}
         else
-          log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+          log_connection_yield('Transaction.rollback', conn){conn.rollback}
         end
       end
     end

data/lib/sequel/adapters/mock.rb

@@ -1,6 +1,9 @@
+# frozen-string-literal: true
+
+require_relative 'utils/unmodified_identifiers'
+
 module Sequel
   module Mock
-    # Connection class for Sequel's mock adapter.
     class Connection
       # Sequel::Mock::Database object that created this connection
       attr_reader :db
@@ -26,66 +29,9 @@ module Sequel
       end
     end
 
-    # Database class for Sequel's mock adapter.
     class Database < Sequel::Database
       set_adapter_scheme :mock
 
-      # Map of database type names to module names, used for handling
-      # mock adapters for specific database types.
-      SHARED_ADAPTERS = {
-        'access'=>'Access',
-        'cubrid'=>'Cubrid',
-        'db2'=>'DB2',
-        'firebird'=>'Firebird',
-        'informix'=>'Informix',
-        'mssql'=>'MSSQL',
-        'mysql'=>'MySQL',
-        'oracle'=>'Oracle',
-        'postgres'=>'Postgres',
-        'sqlanywhere'=>'SqlAnywhere',
-        'sqlite'=>'SQLite'
-      }
-
-      # Procs to run for specific database types to get the mock adapter
-      # to work with the shared adapter
-      SHARED_ADAPTER_SETUP = {
-        'postgres' => lambda do |db|
-          db.instance_eval do
-            @server_version = 90400
-            initialize_postgres_adapter
-          end
-          db.extend(Module.new do
-            def bound_variable_arg(arg, conn)
-              arg
-            end
-
-            def primary_key(table)
-              :id
-            end
-          end)
-        end,
-        'oracle' => lambda do |db|
-          db.instance_eval do
-            @primary_key_sequences = {}
-          end
-        end,
-        'mysql' => lambda do |db|
-          db.instance_eval do
-            @server_version = 50617
-          end
-        end,
-        'mssql' => lambda do |db|
-          db.instance_eval do
-            @server_version = 11000000
-          end
-        end,
-        'sqlite' => lambda do |db|
-          db.instance_eval do
-            @sqlite_version = 30804
-          end
-        end
-      }
-
       # Set the autogenerated primary key integer
       # to be returned when running an insert query.
       # Argument types supported:
@@ -100,14 +46,22 @@ module Sequel
       #         the value returned
       # Class :: Should be an Exception subclass, will create a new
       #          instance an raise it wrapped in a DatabaseError.
-      attr_writer :autoid
+      def autoid=(v)
+        @autoid = case v
+        when Integer
+          i = v - 1
+          proc{@mutex.synchronize{i+=1}}
+        else
+          v
+        end
+      end
 
       # Set the columns to set in the dataset when the dataset fetches
       # rows.  Argument types supported:
       # nil :: Set no columns
-      # Array of Symbols: Used for all datasets
-      # Array (otherwise): First retrieval gets the first value in the
-      #                    array, second gets the second value, etc.
+      # Array of Symbols :: Used for all datasets
+      # Array (otherwise) :: First retrieval gets the first value in the
+      #                      array, second gets the second value, etc.
       # Proc :: Called with the select SQL query, uses the value
       #         returned, which should be an array of symbols
       attr_writer :columns
@@ -172,9 +126,11 @@ module Sequel
       # Return all stored SQL queries, and clear the cache
       # of SQL queries.
       def sqls
-        s = @sqls.dup
-        @sqls.clear
-        s
+        @mutex.synchronize do
+          s = @sqls.dup
+          @sqls.clear
+          s
+        end
       end
 
       # Enable use of savepoints.
@@ -184,26 +140,12 @@ module Sequel
 
       private
 
-      def _autoid(sql, v, ds=nil)
-        case v
-        when Integer
-          if ds
-            ds.autoid += 1 if ds.autoid.is_a?(Integer)
-          else
-            @autoid += 1
-          end
-          v
-        else
-          _nextres(v, sql, nil)
-        end
-      end
-
       def _execute(c, sql, opts=OPTS, &block)
         sql += " -- args: #{opts[:arguments].inspect}" if opts[:arguments]
         sql += " -- #{@opts[:append]}" if @opts[:append]
         sql += " -- #{c.server.is_a?(Symbol) ? c.server : c.server.inspect}" if c.server != :default
-        log_info(sql) unless opts[:log] == false
-        @sqls << sql 
+        log_connection_yield(sql, c){} unless opts[:log] == false
+        @mutex.synchronize{@sqls << sql}
 
         ds = opts[:dataset]
         begin
@@ -214,8 +156,15 @@ module Sequel
             if meth == :numrows
               _numrows(sql, (ds.numrows if ds) || @numrows)
             else
-              v = ds.autoid if ds
-              _autoid(sql, v || @autoid, (ds if v))
+              if ds
+                @mutex.synchronize do
+                  v = ds.autoid
+                  if v.is_a?(Integer)
+                    ds.send(:cache_set, :_autoid, v + 1)
+                  end
+                  v
+                end
+              end || _nextres(@autoid, sql, nil)
             end
           end
         rescue => e
@@ -231,7 +180,7 @@ module Sequel
           if f.all?{|h| h.is_a?(Hash)}
             f.each{|h| yield h.dup}
           else
-            _fetch(sql, f.shift, &block)
+            _fetch(sql, @mutex.synchronize{f.shift}, &block)
           end
         when Proc
           h = f.call(sql)
@@ -244,7 +193,7 @@ module Sequel
           if f < Exception
             raise f
           else
-            raise Error, "Invalid @autoid/@numrows attribute: #{v.inspect}"
+            raise Error, "Invalid @fetch attribute: #{v.inspect}"
           end
         when nil
           # nothing
@@ -258,7 +207,7 @@ module Sequel
         when Integer
           v
         when Array
-          v.empty? ? default : _nextres(v.shift, sql, default)
+          v.empty? ? default : _nextres(@mutex.synchronize{v.shift}, sql, default)
         when Proc
           v.call(sql)
         when Class
@@ -288,18 +237,37 @@ module Sequel
       # :sqls :: The array to store the SQL queries in.
       def adapter_initialize
         opts = @opts
+        @mutex = Mutex.new
         @sqls = opts[:sqls] || []
-        if mod_name = SHARED_ADAPTERS[opts[:host]]
-          @shared_adapter = true
-          require "sequel/adapters/shared/#{opts[:host]}"
-          extend Sequel.const_get(mod_name)::DatabaseMethods
-          extend_datasets Sequel.const_get(mod_name)::DatasetMethods
-          if pr = SHARED_ADAPTER_SETUP[opts[:host]]
-            pr.call(self)
+        @shared_adapter = false
+
+        case db_type = opts[:host] 
+        when String, Symbol
+          db_type = db_type.to_sym
+          unless mod = Sequel.synchronize{SHARED_ADAPTER_MAP[db_type]}
+            begin
+              require "sequel/adapters/shared/#{db_type}"
+            rescue LoadError
+            else
+              mod = Sequel.synchronize{SHARED_ADAPTER_MAP[db_type]}
+            end
           end
-        else
-          @shared_adapter = false
+
+          if mod
+            @shared_adapter = true
+            extend(mod::DatabaseMethods)
+            extend_datasets(mod::DatasetMethods)
+            if mod.respond_to?(:mock_adapter_setup)
+              mod.mock_adapter_setup(self)
+            end
+          end
+        end
+
+        unless @shared_adapter
+          extend UnmodifiedIdentifiers::DatabaseMethods
+          extend_datasets UnmodifiedIdentifiers::DatasetMethods
         end
+
         self.autoid = opts[:autoid]
         self.columns = opts[:columns]
         self.fetch = opts[:fetch]
@@ -315,7 +283,7 @@ module Sequel
             if cs.all?{|c| c.is_a?(Symbol)}
               ds.columns(*cs)
             else
-              columns(ds, sql, cs.shift)
+              columns(ds, sql, @mutex.synchronize{cs.shift})
             end
           end
         when Proc
@@ -327,16 +295,12 @@ module Sequel
         end
       end
 
-      def quote_identifiers_default
-        shared_adapter? ? super : false
+      def dataset_class_default
+        Dataset
       end
 
-      def identifier_input_method_default
-        shared_adapter? ? super : nil
-      end
-
-      def identifier_output_method_default
-        shared_adapter? ? super : nil
+      def quote_identifiers_default
+        shared_adapter? ? super : false
       end
 
       def shared_adapter?
@@ -345,16 +309,20 @@ module Sequel
     end
 
     class Dataset < Sequel::Dataset
-      Database::DatasetClass = self
-
-      # Override the databases's autoid setting for this dataset
-      attr_accessor :autoid
+      # The autoid setting for this dataset, if it has been overridden
+      def autoid
+        cache_get(:_autoid) || @opts[:autoid]
+      end
 
-      # Override the databases's fetch setting for this dataset
-      attr_accessor :_fetch
+      # The fetch setting for this dataset, if it has been overridden
+      def _fetch
+        cache_get(:_fetch) || @opts[:fetch]
+      end
 
-      # Override the databases's numrows setting for this dataset
-      attr_accessor :numrows
+      # The numrows setting for this dataset, if it has been overridden
+      def numrows
+        cache_get(:_numrows) || @opts[:numrows]
+      end
 
       # If arguments are provided, use them to set the columns
       # for this dataset and return self.  Otherwise, use the
@@ -363,7 +331,7 @@ module Sequel
         if cs.empty?
           super
         else
-          @columns = cs
+          self.columns = cs
           self
         end
       end
@@ -372,6 +340,25 @@ module Sequel
         execute(sql, &block)
       end
 
+      def quote_identifiers?
+        @opts.fetch(:quote_identifiers, db.send(:quote_identifiers_default))
+      end
+
+      # Return cloned dataset with the autoid setting modified
+      def with_autoid(autoid)
+        clone(:autoid=>autoid)
+      end
+
+      # Return cloned dataset with the fetch setting modified
+      def with_fetch(fetch)
+        clone(:fetch=>fetch)
+      end
+
+      # Return cloned dataset with the numrows setting modified
+      def with_numrows(numrows)
+        clone(:numrows=>numrows)
+      end
+
       private
 
       def execute(sql, opts=OPTS, &block)
@@ -385,6 +372,10 @@ module Sequel
       def execute_insert(sql, opts=OPTS, &block)
         super(sql, opts.merge(:dataset=>self), &block)
       end
+
+      def non_sql_option?(key)
+        super || key == :fetch || key == :numrows || key == :autoid
+      end
     end
   end
 end