sequel 4.46.0 → 4.49.0

data/lib/sequel/adapters/postgres.rb

@@ -5,89 +5,20 @@ Sequel.require 'adapters/shared/postgres'
 begin 
   require 'pg' 
 
+  Sequel::Postgres::PGError = PG::Error if defined?(PG::Error)
+  Sequel::Postgres::PGconn = PG::Connection if defined?(PG::Connection)
+  Sequel::Postgres::PGresult = PG::Result if defined?(PG::Result)
+
   # Work around postgres-pr 0.7.0+ which ships with a pg.rb file
-  raise LoadError unless defined?(PGconn::CONNECTION_OK)
+  unless defined?(PG::Connection)
+    raise LoadError unless defined?(PGconn::CONNECTION_OK)
+  end
 
   Sequel::Postgres::USES_PG = true
 rescue LoadError => e 
-  Sequel::Postgres::USES_PG = false
   begin
-    require 'postgres'
-    # Attempt to get uniform behavior for the PGconn object no matter
-    # if pg, postgres, or postgres-pr is used.
-    class PGconn
-      unless method_defined?(:escape_string)
-        if self.respond_to?(:escape)
-          # If there is no escape_string instance method, but there is an
-          # escape class method, use that instead.
-          def escape_string(str)
-            Sequel::Postgres.force_standard_strings ? str.gsub("'", "''") : self.class.escape(str)
-          end
-        else
-          # Raise an error if no valid string escaping method can be found.
-          def escape_string(obj)
-            if Sequel::Postgres.force_standard_strings
-              str.gsub("'", "''")
-            else
-              raise Sequel::Error, "string escaping not supported with this postgres driver.  Try using ruby-pg, ruby-postgres, or postgres-pr."
-            end
-          end
-        end
-      end
-      unless method_defined?(:escape_bytea)
-        if self.respond_to?(:escape_bytea)
-          # If there is no escape_bytea instance method, but there is an
-          # escape_bytea class method, use that instead.
-          def escape_bytea(obj)
-            self.class.escape_bytea(obj)
-          end
-        else
-          begin
-            require 'postgres-pr/typeconv/conv'
-            require 'postgres-pr/typeconv/bytea'
-            extend Postgres::Conversion
-            # If we are using postgres-pr, use the encode_bytea method from
-            # that.
-            def escape_bytea(obj)
-              self.class.encode_bytea(obj)
-            end
-            instance_eval{alias unescape_bytea decode_bytea}
-          rescue
-            # If no valid bytea escaping method can be found, create one that
-            # raises an error
-            def escape_bytea(obj)
-              raise Sequel::Error, "bytea escaping not supported with this postgres driver.  Try using ruby-pg, ruby-postgres, or postgres-pr."
-            end
-            # If no valid bytea unescaping method can be found, create one that
-            # raises an error
-            def self.unescape_bytea(obj)
-              raise Sequel::Error, "bytea unescaping not supported with this postgres driver.  Try using ruby-pg, ruby-postgres, or postgres-pr."
-            end
-          end
-        end
-      end
-      alias_method :finish, :close unless method_defined?(:finish)
-      alias_method :async_exec, :exec unless method_defined?(:async_exec)
-      unless method_defined?(:block)
-        def block(timeout=nil)
-        end
-      end
-      unless defined?(CONNECTION_OK)
-        CONNECTION_OK = -1
-      end
-      unless method_defined?(:status)
-        def status
-          CONNECTION_OK
-        end
-      end
-    end
-    class PGresult 
-      alias_method :nfields, :num_fields unless method_defined?(:nfields) 
-      alias_method :ntuples, :num_tuples unless method_defined?(:ntuples) 
-      alias_method :ftype, :type unless method_defined?(:ftype) 
-      alias_method :fname, :fieldname unless method_defined?(:fname) 
-      alias_method :cmd_tuples, :cmdtuples unless method_defined?(:cmd_tuples) 
-    end 
+    require 'postgres-pr/postgres-compat'
+    Sequel::Postgres::USES_PG = false
   rescue LoadError 
     raise e 
   end 
@@ -95,14 +26,11 @@ end
 
 module Sequel
   module Postgres
-    CONVERTED_EXCEPTIONS << PGError
-
+    # SEQUEL5: Remove
     TYPE_CONVERTOR = Class.new do
       def bytea(s) ::Sequel::SQL::Blob.new(Adapter.unescape_bytea(s)) end
     end.new
-
-    # SEQUEL5: Remove
-    PG_TYPES[17] = TYPE_CONVERTOR.method(:bytea)
+    Sequel::Deprecation.deprecate_constant(self, :TYPE_CONVERTOR)
 
     if Sequel::Postgres::USES_PG
       # Whether the given sequel_pg version integer is supported.
@@ -111,18 +39,22 @@ module Sequel
       end
     end
 
+    # SEQUEL5: Remove
     @use_iso_date_format = true
-
     class << self
-      # As an optimization, Sequel sets the date style to ISO, so that PostgreSQL provides
-      # the date in a known format that Sequel can parse faster.  This can be turned off
-      # if you require a date style other than ISO.
-      attr_accessor :use_iso_date_format
+      def use_iso_date_format
+        Sequel::Deprecation.deprecate("Sequel::Postgres.use_iso_date_format", "Use the :use_iso_date_format Database option instead")
+        @use_iso_date_format
+      end
+      def use_iso_date_format=(v)
+        Sequel::Deprecation.deprecate("Sequel::Postgres.use_iso_date_format=", "Use the :use_iso_date_format Database option instead")
+        @use_iso_date_format = v
+      end
     end
 
     # PGconn subclass for connection specific methods used with the
-    # pg, postgres, or postgres-pr driver.
-    class Adapter < ::PGconn
+    # pg or postgres-pr driver.
+    class Adapter < PGconn
       # The underlying exception classes to reraise as disconnect errors
       # instead of regular database errors.
       DISCONNECT_ERROR_CLASSES = [IOError, Errno::EPIPE, Errno::ECONNRESET]
@@ -145,10 +77,49 @@ module Sequel
       # errors.
       DISCONNECT_ERROR_RE = /\A#{Regexp.union(disconnect_errors)}/
       
-      # Hash of prepared statements for this connection.  Keys are
-      # string names of the server side prepared statement, and values
-      # are SQL strings.
-      attr_reader(:prepared_statements) if USES_PG
+      if USES_PG
+        # Hash of prepared statements for this connection.  Keys are
+        # string names of the server side prepared statement, and values
+        # are SQL strings.
+        attr_reader :prepared_statements
+      else
+        # Make postgres-pr look like pg
+        CONNECTION_OK = -1
+
+        # Escape bytea values.  Uses historical format instead of hex
+        # format for maximum compatibility.
+        def escape_bytea(str)
+          # each_byte used instead of [] for 1.9 compatibility
+          str.gsub(/[\000-\037\047\134\177-\377]/n){|b| "\\#{sprintf('%o', b.each_byte{|x| break x}).rjust(3, '0')}"}
+        end
+        
+        # Escape strings by doubling apostrophes.  This only works if standard
+        # conforming strings are used.
+        def escape_string(str)
+          str.gsub("'", "''")
+        end
+
+        alias finish close
+
+        def async_exec(sql)
+          PGresult.new(@conn.query(sql))
+        end
+
+        def block(timeout=nil)
+        end
+
+        def status
+          CONNECTION_OK
+        end
+
+        class PGresult < ::PGresult
+          alias nfields num_fields
+          alias ntuples num_tuples
+          alias ftype type
+          alias fname fieldname
+          alias cmd_tuples cmdtuples
+        end 
+      end
       
       # Raise a Sequel::DatabaseDisconnectError if a one of the disconnect
       # error classes is raised, or a PGError is raised and the connection
@@ -247,7 +218,8 @@ module Sequel
             :user => opts[:user],
             :password => opts[:password],
             :connect_timeout => opts[:connect_timeout] || 20,
-            :sslmode => opts[:sslmode]
+            :sslmode => opts[:sslmode],
+            :sslrootcert => opts[:sslrootcert]
           }.delete_if { |key, value| blank_object?(value) }
           connection_params.merge!(opts[:driver_options]) if opts[:driver_options]
           conn = Adapter.connect(connection_params)
@@ -258,6 +230,10 @@ module Sequel
             conn.set_notice_receiver(&receiver)
           end
         else
+          unless typecast_value_boolean(@opts.fetch(:force_standard_strings, Postgres.instance_variable_get(:@force_standard_strings))) # , true)) # SEQUEL5
+            raise Error, "Cannot create connection using postgres-pr unless force_standard_strings is set"
+          end
+
           conn = Adapter.connect(
             (opts[:host] unless blank_object?(opts[:host])),
             opts[:port] || 5432,
@@ -311,7 +287,7 @@ module Sequel
             end
           end
         end
-        conversion_procs[1082] = pr
+        add_conversion_proc(1082, pr)
       end
 
       # Disconnect given connection
@@ -390,8 +366,12 @@ module Sequel
                 b << buf while buf = conn.get_copy_data
                 b
               end
+            rescue => e
+              raise_error(e, :disconnect=>true)
             ensure
-              raise DatabaseDisconnectError, "disconnecting as a partial COPY may leave the connection in an unusable state" if buf
+              if buf && !e
+                raise DatabaseDisconnectError, "disconnecting as a partial COPY may leave the connection in an unusable state"
+              end
             end
           end 
         end
@@ -544,10 +524,10 @@ module Sequel
       # Add the primary_keys and primary_key_sequences instance variables,
       # so we can get the correct return values for inserted rows.
       def adapter_initialize
-        @use_iso_date_format = typecast_value_boolean(@opts.fetch(:use_iso_date_format, Postgres.use_iso_date_format))
+        @use_iso_date_format = typecast_value_boolean(@opts.fetch(:use_iso_date_format, Postgres.instance_variable_get(:@use_iso_date_format))) # , true)) # SEQUEL5
         initialize_postgres_adapter
-        conversion_procs[17] = TYPE_CONVERTOR.method(:bytea)
-        conversion_procs[1082] = TYPE_TRANSLATOR.method(:date) if @use_iso_date_format
+        add_conversion_proc(17, method(:unescape_bytea)) if USES_PG
+        add_conversion_proc(1082, TYPE_TRANSLATOR.method(:date)) if @use_iso_date_format
         self.convert_infinite_timestamps = @opts[:convert_infinite_timestamps]
       end
 
@@ -556,7 +536,7 @@ module Sequel
         begin
           yield
         rescue => e
-          raise_error(e, :classes=>CONVERTED_EXCEPTIONS)
+          raise_error(e, :classes=>database_error_classes)
         end
       end
 
@@ -567,8 +547,15 @@ module Sequel
         sqls
       end
 
+      if USES_PG
+        def unescape_bytea(s)
+          ::Sequel::SQL::Blob.new(Adapter.unescape_bytea(s))
+        end
+      end
+
+      DATABASE_ERROR_CLASSES = [PGError].freeze
       def database_error_classes
-        [PGError]
+        DATABASE_ERROR_CLASSES
       end
 
       def disconnect_error?(exception, opts)
@@ -579,7 +566,7 @@ module Sequel
 
       def database_exception_sqlstate(exception, opts)
         if exception.respond_to?(:result) && (result = exception.result)
-          result.error_field(::PGresult::PG_DIAG_SQLSTATE)
+          result.error_field(PGresult::PG_DIAG_SQLSTATE)
         end
       end
 
@@ -885,3 +872,4 @@ end
 
 # SEQUEL5: Remove
 SEQUEL_POSTGRES_USES_PG = Sequel::Postgres::USES_PG
+Sequel::Deprecation.deprecate_constant(Object, :SEQUEL_POSTGRES_USES_PG)

data/lib/sequel/adapters/shared/db2.rb

@@ -6,11 +6,17 @@ module Sequel
   module DB2
     Sequel::Database.set_shared_adapter_scheme(:db2, self)
 
+    # SEQUEL5: Remove
     @use_clob_as_blob = false
-
     class << self
-      # Whether to use clob as the generic File type, true by default.
-      attr_accessor :use_clob_as_blob
+      def use_clob_as_blob
+        Sequel::Deprecation.deprecate("Sequel::DB2.use_clob_as_blob", "Call this method on the Database instance")
+        @use_clob_as_blob
+      end
+      def use_clob_as_blob=(v)
+        Sequel::Deprecation.deprecate("Sequel::DB2.use_clob_as_blob=", "Call this method on the Database instance")
+        @use_clob_as_blob = v
+      end
     end
 
     module DatabaseMethods
@@ -21,6 +27,16 @@ module Sequel
       NULL          = ''.freeze
       Sequel::Deprecation.deprecate_constant(self, :NULL)
 
+      # Whether to use clob as the generic File type, false by default.
+      #attr_accessor :use_clob_as_blob # SEQUEL5
+
+      # SEQUEL5: Remove
+      attr_writer :use_clob_as_blob
+      def use_clob_as_blob
+        v = @use_clob_as_blob
+        v.nil? ? Sequel::DB2.instance_variable_get(:@use_clob_as_blob) : v
+      end
+    
       # DB2 always uses :db2 as it's database type
       def database_type
         :db2
@@ -250,7 +266,7 @@ module Sequel
 
       # Treat clob as blob if use_clob_as_blob is true
       def schema_column_type(db_type)
-        (::Sequel::DB2::use_clob_as_blob && db_type.downcase == 'clob') ? :blob : super
+        (use_clob_as_blob && db_type.downcase == 'clob') ? :blob : super
       end
 
       # SQL to set the transaction isolation level
@@ -263,7 +279,7 @@ module Sequel
       # use this for blob value:
       #     cast(X'fffefdfcfbfa' as blob(2G))
       def type_literal_generic_file(column)
-        ::Sequel::DB2::use_clob_as_blob ? :clob : :blob
+        use_clob_as_blob ? :clob : :blob
       end
 
       # DB2 uses smallint to store booleans.
@@ -433,7 +449,7 @@ module Sequel
 
       # DB2 uses a literal hexidecimal number for blob strings
       def literal_blob_append(sql, v)
-        if ::Sequel::DB2.use_clob_as_blob
+        if db.use_clob_as_blob
           super
         else
           sql << "BLOB(X'" << v.unpack("H*").first << "')"

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

@@ -540,7 +540,6 @@ module Sequel
       CONSTANT_MAP = {:CURRENT_DATE=>'CAST(CURRENT_TIMESTAMP AS DATE)'.freeze, :CURRENT_TIME=>'CAST(CURRENT_TIMESTAMP AS TIME)'.freeze}#.freeze # SEQUEL5
       EXTRACT_MAP = {:year=>"yy", :month=>"m", :day=>"d", :hour=>"hh", :minute=>"n", :second=>"s"}#.freeze # SEQUEL5
       #EXTRACT_MAP.each_value(&:freeze) # SEQUEL5
-      NON_SQL_OPTIONS = (Dataset::NON_SQL_OPTIONS + [:disable_insert_output, :mssql_unicode_strings]).freeze
       LIMIT_ALL = Object.new.freeze
 
       BOOL_TRUE = '1'.freeze
@@ -629,6 +628,8 @@ module Sequel
       Sequel::Deprecation.deprecate_constant(self, :ROWS_ONLY)
       FETCH_NEXT = " FETCH NEXT ".freeze
       Sequel::Deprecation.deprecate_constant(self, :FETCH_NEXT)
+      NON_SQL_OPTIONS = (Dataset::NON_SQL_OPTIONS + [:disable_insert_output, :mssql_unicode_strings]).freeze
+      Sequel::Deprecation.deprecate_constant(self, :NON_SQL_OPTIONS)
 
       Dataset.def_mutation_method(:disable_insert_output, :output, :module=>self)
       Dataset.def_sql_method(self, :delete, %w'with delete limit from output from2 where')
@@ -637,6 +638,7 @@ module Sequel
 
       # Allow overriding of the mssql_unicode_strings option at the dataset level.
       def mssql_unicode_strings=(v)
+        Sequel::Deprecation.deprecate("Dataset#mssql_unicode_strings=", "Switch to using with_mssql_unicode_strings, which returns a modified copy")
         @opts[:mssql_unicode_strings] = v
       end
 
@@ -1048,9 +1050,8 @@ module Sequel
         is_2008_or_later? ? :values : :union
       end
 
-      # Dataset options that do not affect the generated SQL.
-      def non_sql_options
-        NON_SQL_OPTIONS
+      def non_sql_option?(key)
+        super || key == :disable_insert_output || key == :mssql_unicode_strings
       end
 
       def select_into_sql(sql)

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

@@ -12,32 +12,54 @@ module Sequel
       end
     end
 
+    # SEQUEL5: Remove
     @convert_tinyint_to_bool = true
-
+    @default_charset = nil
+    @default_collate = nil
+    @default_engine = nil
     class << self
-      # Sequel converts the column type tinyint(1) to a boolean by default when
-      # using the native MySQL or Mysql2 adapter.  You can turn off the conversion by setting
-      # this to false. This setting is ignored when connecting to MySQL via the do or jdbc
-      # adapters, both of which automatically do the conversion.
-      attr_accessor :convert_tinyint_to_bool
+      def convert_tinyint_to_bool
+        Sequel::Deprecation.deprecate("Sequel::MySQL.convert_tinyint_to_bool", "Call this method on the Database instance")
+        @convert_tinyint_to_bool
+      end
+      def convert_tinyint_to_bool=(v)
+        Sequel::Deprecation.deprecate("Sequel::MySQL.convert_tinyint_to_bool=", "Call this method on the Database instance")
+        @convert_tinyint_to_bool = v
+      end
 
-      # Set the default charset used for CREATE TABLE.  You can pass the
-      # :charset option to create_table to override this setting.
-      attr_accessor :default_charset
+      def default_charset
+        Sequel::Deprecation.deprecate("Sequel::MySQL.default_charset", "Call this method on the Database instance")
+        @default_charset
+      end
+      def default_charset=(v)
+        Sequel::Deprecation.deprecate("Sequel::MySQL.default_charset=", "Call this method on the Database instance")
+        @default_charset = v
+      end
 
-      # Set the default collation used for CREATE TABLE.  You can pass the
-      # :collate option to create_table to override this setting.
-      attr_accessor :default_collate
+      def default_collate
+        Sequel::Deprecation.deprecate("Sequel::MySQL.default_collate", "Call this method on the Database instance")
+        @default_collate
+      end
+      def default_collate=(v)
+        Sequel::Deprecation.deprecate("Sequel::MySQL.default_collate=", "Call this method on the Database instance")
+        @default_collate = v
+      end
 
-      # Set the default engine used for CREATE TABLE.  You can pass the
-      # :engine option to create_table to override this setting.
-      attr_accessor :default_engine
+      def default_engine
+        Sequel::Deprecation.deprecate("Sequel::MySQL.default_engine", "Call this method on the Database instance")
+        @default_engine
+      end
+      def default_engine=(v)
+        Sequel::Deprecation.deprecate("Sequel::MySQL.default_engine=", "Call this method on the Database instance")
+        @default_engine = v
+      end
     end
 
     # Methods shared by Database instances that connect to MySQL,
     # currently supported by the native and JDBC adapters.
     module DatabaseMethods
       include UnmodifiedIdentifiers::DatabaseMethods
+      include Sequel::Database::SplitAlterTable
 
       AUTO_INCREMENT = 'AUTO_INCREMENT'.freeze
       Sequel::Deprecation.deprecate_constant(self, :AUTO_INCREMENT)
@@ -49,8 +71,36 @@ module Sequel
       CAST_TYPES = {String=>:CHAR, Integer=>:SIGNED, Time=>:DATETIME, DateTime=>:DATETIME, Numeric=>:DECIMAL, BigDecimal=>:DECIMAL, File=>:BINARY}#.freeze # SEQUEL5
       COLUMN_DEFINITION_ORDER = [:collate, :null, :default, :unique, :primary_key, :auto_increment, :references]#.freeze # SEQUEL5
 
-      include Sequel::Database::SplitAlterTable
       
+      # Set the default charset used for CREATE TABLE.  You can pass the
+      # :charset option to create_table to override this setting.
+      #attr_accessor :default_charset # SEQUEL5
+
+      # Set the default collation used for CREATE TABLE.  You can pass the
+      # :collate option to create_table to override this setting.
+      #attr_accessor :default_collate # SEQUEL5
+
+      # Set the default engine used for CREATE TABLE.  You can pass the
+      # :engine option to create_table to override this setting.
+      #attr_accessor :default_engine # SEQUEL5
+
+      # SEQUEL5: Remove
+      attr_writer :default_charset
+      def default_charset
+        v = @default_charset
+        v.nil? ? Sequel::MySQL.instance_variable_get(:@default_charset) : v
+      end
+      attr_writer :default_collate
+      def default_collate
+        v = @default_collate
+        v.nil? ? Sequel::MySQL.instance_variable_get(:@default_collate) : v
+      end
+      attr_writer :default_engine
+      def default_engine
+        v = @default_engine
+        v.nil? ? Sequel::MySQL.instance_variable_get(:@default_engine) : v
+      end
+
       # MySQL's cast rules are restrictive in that you can't just cast to any possible
       # database type.
       def cast_type_literal(type)
@@ -375,9 +425,9 @@ module Sequel
 
       # Use MySQL specific syntax for engine type and character encoding
       def create_table_sql(name, generator, options = OPTS)
-        engine = options.fetch(:engine, Sequel::MySQL.default_engine)
-        charset = options.fetch(:charset, Sequel::MySQL.default_charset)
-        collate = options.fetch(:collate, Sequel::MySQL.default_collate)
+        engine = options.fetch(:engine, default_engine)
+        charset = options.fetch(:charset, default_charset)
+        collate = options.fetch(:collate, default_collate)
         generator.constraints.sort_by{|c| (c[:type] == :primary_key) ? -1 : 1}
 
         # Proc for figuring out the primary key for a given table.
@@ -669,10 +719,11 @@ module Sequel
       Sequel::Deprecation.deprecate_constant(self, :CURRENT_TIMESTAMP_56)
       ONLY_OFFSET = ",18446744073709551615".freeze
       Sequel::Deprecation.deprecate_constant(self, :ONLY_OFFSET)
+      NON_SQL_OPTIONS = (Dataset::NON_SQL_OPTIONS + [:insert_ignore, :update_ignore, :on_duplicate_key_update]).freeze
+      Sequel::Deprecation.deprecate_constant(self, :NON_SQL_OPTIONS)
 
       MATCH_AGAINST = ["MATCH ".freeze, " AGAINST (".freeze, ")".freeze].freeze
       MATCH_AGAINST_BOOLEAN = ["MATCH ".freeze, " AGAINST (".freeze, " IN BOOLEAN MODE)".freeze].freeze
-      NON_SQL_OPTIONS = (Dataset::NON_SQL_OPTIONS + [:insert_ignore, :update_ignore, :on_duplicate_key_update]).freeze
 
       Dataset.def_sql_method(self, :delete, %w'delete from where order limit')
       Dataset.def_sql_method(self, :insert, %w'insert ignore into columns values on_duplicate_key_update')
@@ -790,8 +841,11 @@ module Sequel
       # Transforms an CROSS JOIN to an INNER JOIN if the expr is not nil.
       # Raises an error on use of :full_outer type, since MySQL doesn't support it.
       def join_table(type, table, expr=nil, opts=OPTS, &block)
-        type = :inner if (type == :cross) && !expr.nil?
-        raise(Sequel::Error, "MySQL doesn't support FULL OUTER JOIN") if type == :full_outer
+        if (type == :cross) && !expr.nil?
+           Sequel::Deprecation.deprecate(":cross join type with conditions being converted to INNER JOIN on MySQL", "Use :inner join type instead")
+          type = :inner
+        end
+        raise(Sequel::Error, "MySQL doesn't support FULL OUTER JOIN or NATURAL FULL JOIN") if type == :full_outer || type == :natural_full
         super(type, table, expr, opts, &block)
       end
       
@@ -802,6 +856,7 @@ module Sequel
         when :straight
           'STRAIGHT_JOIN'
         when :natural_inner
+           Sequel::Deprecation.deprecate(":natural_inner join type being converted to NATURAL LEFT JOIN on MySQL", "Use :natural_left join type for NATURAL LEFT JOIN, or :natural join type for NATURAL JOIN")
           'NATURAL LEFT JOIN'
         else
           super
@@ -1055,9 +1110,8 @@ module Sequel
         :values
       end
 
-      # Dataset options that do not affect the generated SQL.
-      def non_sql_options
-        NON_SQL_OPTIONS
+      def non_sql_option?(key)
+        super || key == :insert_ignore || key == :update_ignore || key == :on_duplicate_key_update
       end
 
       def select_only_offset_sql(sql)

data/lib/sequel/adapters/shared/oracle.rb

@@ -348,7 +348,7 @@ module Sequel
       Sequel::Deprecation.deprecate_constant(self, :SKIP_LOCKED)
 
       include(Module.new do
-        Dataset.def_sql_method(self, :select, %w'with select distinct columns from join where group having compounds order lock')
+        Dataset.def_sql_method(self, :select, %w'with select distinct columns from join where group having compounds order limit lock')
       end)
 
       def complex_expression_sql_append(sql, op, args)
@@ -421,7 +421,10 @@ module Sequel
       # Handle LIMIT by using a unlimited subselect filtered with ROWNUM.
       def select_sql
         return super if @opts[:sql]
-        if o = @opts[:offset]
+        return super if supports_fetch_next_rows?
+
+        o = @opts[:offset]
+        if o && o != 0
           columns = clone(:append_sql=>String.new, :placeholder_literal_null=>true).columns
           dsa1 = dataset_alias(1)
           rn = row_number_column
@@ -437,7 +440,7 @@ module Sequel
           subselect_sql_append(sql, ds)
           sql
         elsif limit = @opts[:limit]
-          ds = clone(:limit=>nil)
+          ds = unlimited
           # Lock doesn't work in subselects, so don't use a subselect when locking.
           # Don't use a subselect if custom SQL is used, as it breaks somethings.
           ds = ds.from_self unless @opts[:lock]
@@ -449,6 +452,21 @@ module Sequel
         end
       end
 
+      def select_limit_sql(sql)
+        return unless supports_fetch_next_rows?
+
+        if offset = @opts[:offset]
+          sql << " OFFSET "
+          literal_append(sql, offset)
+          sql << " ROWS"
+        end
+
+        if limit = @opts[:limit]
+          sql << " FETCH NEXT "
+          literal_append(sql, limit)
+          sql << " ROWS ONLY"
+        end
+      end
       # Oracle requires recursive CTEs to have column aliases.
       def recursive_cte_requires_column_aliases?
         true
@@ -463,6 +481,11 @@ module Sequel
         false
       end
 
+      # Oracle supports FETCH NEXT ROWS since 12c
+      def supports_fetch_next_rows?
+        server_version >= 12000000 && !(@opts[:lock] || @opts[:skip_locked])
+      end
+
       # Oracle supports GROUP BY CUBE
       def supports_group_cube?
         true