sequel 3.28.0 → 3.29.0

data/lib/sequel/adapters/postgres.rb

@@ -110,7 +110,6 @@ module Sequel
       [700, 701] => tt.method(:float),
       [790, 1700] => ::BigDecimal.method(:new),
       [1083, 1266] => ::Sequel.method(:string_to_time),
-      [1114, 1184] => ::Sequel.method(:database_to_application_timestamp)
     }.each do |k,v|
       k.each{|n| PG_TYPES[n] = v}
     end
@@ -240,9 +239,29 @@ module Sequel
         conn
       end
       
+      # Execute the given SQL with the given args on an available connection.
+      def execute(sql, opts={}, &block)
+        check_database_errors do
+          return execute_prepared_statement(sql, opts, &block) if Symbol === sql
+          synchronize(opts[:server]){|conn| conn.execute(sql, opts[:arguments], &block)}
+        end
+      end
+      
+      # Insert the values into the table and return the primary key (if
+      # automatically generated).
+      def execute_insert(sql, opts={})
+        return execute(sql, opts) if Symbol === sql
+        check_database_errors do
+          synchronize(opts[:server]) do |conn|
+            conn.execute(sql, opts[:arguments])
+            insert_result(conn, opts[:table], opts[:values])
+          end
+        end
+      end
+      
       if SEQUEL_POSTGRES_USES_PG
         # +copy_table+ uses PostgreSQL's +COPY+ SQL statement to return formatted
-        # results directly to the caller.  This method is only support if pg is the
+        # results directly to the caller.  This method is only supported if pg is the
         # underlying ruby driver.  This method should only be called if you want
         # results returned to the client.  If you are using +COPY FROM+ or +COPY TO+
         # with a filename, you should just use +run+ instead of this method.  This
@@ -302,33 +321,57 @@ module Sequel
             end
           end 
         end
-      end
-        
-      # Return instance of Sequel::Postgres::Dataset with the given options.
-      def dataset(opts = nil)
-        Postgres::Dataset.new(self, opts)
-      end
-      
-      # Execute the given SQL with the given args on an available connection.
-      def execute(sql, opts={}, &block)
-        check_database_errors do
-          return execute_prepared_statement(sql, opts, &block) if Symbol === sql
-          synchronize(opts[:server]){|conn| conn.execute(sql, opts[:arguments], &block)}
-        end
-      end
-      
-      # Insert the values into the table and return the primary key (if
-      # automatically generated).
-      def execute_insert(sql, opts={})
-        return execute(sql, opts) if Symbol === sql
-        check_database_errors do
-          synchronize(opts[:server]) do |conn|
-            conn.execute(sql, opts[:arguments])
-            insert_result(conn, opts[:table], opts[:values])
+
+        # Listens on the given channel (or multiple channels if channel is an array), waiting for notifications.
+        # After a notification is received, or the timeout has passed, stops listening to the channel. Options:
+        #
+        # :after_listen :: An object that responds to +call+ that is called with the underlying connection after the LISTEN
+        #                  statement is sent, but before the connection starts waiting for notifications.
+        # :loop :: Whether to continually wait for notifications, instead of just waiting for a single
+        #          notification. If this option is given, a block must be provided.  If this object responds to call, it is
+        #          called with the underlying connection after each notification is received (after the block is called).
+        #          If a :timeout option is used, and a callable object is given, the object will also be called if the
+        #          timeout expires.  If :loop is used and you want to stop listening, you can either break from inside the
+        #          block given to #listen, or you can throw :stop from inside the :loop object's call method or the block.
+        # :server :: The server on which to listen, if the sharding support is being used.
+        # :timeout :: How long to wait for a notification, in seconds (can provide a float value for
+        #             fractional seconds).  If not given or nil, waits indefinitely.
+        #
+        # This method is only supported if pg is used as the underlying ruby driver.  It returns the
+        # channel the notification was sent to (as a string), unless :loop was used, in which case it returns nil.
+        # If a block is given, it is yielded 3 arguments:
+        # * the channel the notification was sent to (as a string)
+        # * the backend pid of the notifier (as an integer),
+        # * and the payload of the notification (as a string or nil).
+        def listen(channels, opts={}, &block)
+          check_database_errors do
+            synchronize(opts[:server]) do |conn|
+              begin
+                channels = Array(channels)
+                channels.each{|channel| conn.execute("LISTEN #{channel}")}
+                opts[:after_listen].call(conn) if opts[:after_listen]
+                timeout = opts[:timeout] ? [opts[:timeout]] : []
+                if l = opts[:loop]
+                  raise Error, 'calling #listen with :loop requires a block' unless block
+                  loop_call = l.respond_to?(:call)
+                  catch(:stop) do
+                    loop do
+                      conn.wait_for_notify(*timeout, &block)
+                      l.call(conn) if loop_call
+                    end
+                  end
+                  nil
+                else
+                  conn.wait_for_notify(*timeout, &block)
+                end
+              ensure
+                conn.execute("UNLISTEN *")
+              end
+            end
           end
         end
       end
-      
+        
       private
       
       # Convert exceptions raised from the block into DatabaseErrors.
@@ -385,9 +428,11 @@ module Sequel
       # Return the conversion procs hash to use for this database
       def get_conversion_procs(conn)
         procs = PG_TYPES.dup
+        procs[1114] = method(:to_application_timestamp)
+        procs[1184] = method(:to_application_timestamp)
         conn.execute("SELECT oid, typname FROM pg_type where typtype = 'b'") do |res|
           res.ntuples.times do |recnum|
-            if pr = PG_NAMED_TYPES[res.getvalue(recnum, 1).to_sym]
+            if pr = PG_NAMED_TYPES[res.getvalue(recnum, 1).untaint.to_sym]
               procs[res.getvalue(recnum, 0).to_i] ||= pr
             end
           end
@@ -400,6 +445,8 @@ module Sequel
     # postgres-pr driver.
     class Dataset < Sequel::Dataset
       include Sequel::Postgres::DatasetMethods
+
+      Database::DatasetClass = self
       
       # Yield all rows returned by executing the given SQL and converting
       # the types.
@@ -495,6 +542,12 @@ module Sequel
         # pg driver.
         module PreparedStatementMethods
           include BindArgumentMethods
+
+          # Raise a more obvious error if you attempt to call a unnamed prepared statement.
+          def call(*)
+            raise Error, "Cannot call prepared statement without a name" if prepared_statement_name.nil?
+            super
+          end
           
           private
           

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

@@ -6,12 +6,6 @@ module Sequel
         :access
       end
 
-      def dataset(opts = nil)
-        ds = super
-        ds.extend(DatasetMethods)
-        ds
-      end
-
       # Doesn't work, due to security restrictions on MSysObjects
       def tables
         from(:MSysObjects).filter(:Type=>1, :Flags=>0).select_map(:Name).map{|x| x.to_sym}

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

@@ -29,8 +29,8 @@ module Sequel
 
       # Use SYSIBM.SYSCOLUMNS to get the information on the tables.
       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])
         metadata_dataset.with_sql("SELECT * FROM SYSIBM.SYSCOLUMNS WHERE TBNAME = #{literal(im.call(table))} ORDER BY COLNO").
           collect do |column| 
             column[:db_type]     = column.delete(:typename)
@@ -192,13 +192,16 @@ module Sequel
           super(:LIKE, [SQL::Function.new(:upper, args.at(0)), SQL::Function.new(:upper, args.at(1)) ])
         when :"NOT ILIKE"
           super(:"NOT LIKE", [SQL::Function.new(:upper, args.at(0)), SQL::Function.new(:upper, args.at(1)) ])
-        when :&, :|, :^, :'B~'
+        when :&, :|, :^
           # works with db2 v9.5 and after
-          literal(SQL::Function.new(BITWISE_METHOD_MAP[op], *args))
+          op = BITWISE_METHOD_MAP[op]
+          complex_expression_arg_pairs(args){|a, b| literal(SQL::Function.new(op, a, b))}
         when :<<
-          "(#{literal(args[0])} * POWER(2, #{literal(args[1])}))"
+          complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} * POWER(2, #{literal(b)}))"}
         when :>>
-          "(#{literal(args[0])} / POWER(2, #{literal(args[1])}))"
+          complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} / POWER(2, #{literal(b)}))"}
+        when :'B~'
+          literal(SQL::Function.new(:BITNOT, *args))
         when :extract
           "#{args.at(0)}(#{literal(args.at(1))})"
         else
@@ -206,12 +209,6 @@ module Sequel
         end
       end
 
-      # Delete the row_number_column if offsets are being emulated with
-      # ROW_NUMBER.
-      def fetch_rows(sql, &block)
-        @opts[:offset] ? super(sql){|r| r.delete(row_number_column); yield r} : super(sql, &block)
-      end
-
       # DB2 does not support IS TRUE.
       def supports_is_true?
         false
@@ -244,9 +241,10 @@ module Sequel
 
       private
 
-      # DB2 uses "INSERT INTO "ITEMS" VALUES DEFAULT" for a record with default values to be inserted
-      def insert_values_sql(sql)
-        opts[:values].empty? ? sql << " VALUES DEFAULT" : super
+      # DB2 needs the standard workaround to insert all default values into
+      # a table with more than one column.
+      def insert_supports_empty_values?
+        false
       end
 
       # Use 0 for false on DB2

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

@@ -20,11 +20,6 @@ module Sequel
         self << drop_sequence_sql(name)
       end
 
-      def drop_table(*names)
-        clear_primary_key(*names)
-        super
-      end
-
       # Return primary key for the given table.
       def primary_key(table)
         t = dataset.send(:input_identifier, table)
@@ -131,6 +126,11 @@ module Sequel
         "DROP SEQUENCE #{quote_identifier(name)}"
       end
 
+      def remove_cached_schema(table)
+        clear_primary_key(table)
+        super
+      end
+
       def restart_sequence_sql(name, opts={})
         seq_name = quote_identifier(name)
         "ALTER SEQUENCE #{seq_name} RESTART WITH #{opts[:restart_position]}"
@@ -158,7 +158,7 @@ module Sequel
       def insert(*values)
         if @opts[:sql] || @opts[:returning]
           super
-        elsif supports_insert_select?
+        else
           returning(insert_pk).insert(*values){|r| return r.values.first}
         end
       end

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

@@ -107,7 +107,7 @@ module Sequel
       # Commit the active transaction on the connection, does not commit/release
       # savepoints.
       def commit_transaction(conn, opts={})
-        log_connection_execute(conn, commit_transaction_sql) unless Thread.current[:sequel_transaction_depth] > 1
+        log_connection_execute(conn, commit_transaction_sql) unless @transactions[conn][:savepoint_level] > 1
       end
 
       # SQL to COMMIT a transaction.
@@ -168,20 +168,31 @@ module Sequel
         end
       end
 
-      # MSSQL uses the INFORMATION_SCHEMA to hold column information.  This method does
-      # not support the parsing of primary key information.
+      # MSSQL uses the INFORMATION_SCHEMA to hold column information, and
+      # parses primary key information from the sysindexes, sysindexkeys,
+      # and syscolumns system tables.
       def schema_parse_table(table_name, opts)
-        m = output_identifier_meth
-        m2 = input_identifier_meth
+        m = output_identifier_meth(opts[:dataset])
+        m2 = input_identifier_meth(opts[:dataset])
+        tn = m2.call(table_name.to_s)
+        table_id = get{object_id(tn)}
+        pk_index_id = metadata_dataset.from(:sysindexes).
+          where(:id=>table_id, :indid=>1..254){{(status & 2048)=>2048}}.
+          get(:indid)
+        pk_cols = metadata_dataset.from(:sysindexkeys___sik).
+          join(:syscolumns___sc, :id=>:id, :colid=>:colid).
+          where(:sik__id=>table_id, :sik__indid=>pk_index_id).
+          select_order_map(:sc__name)
         ds = metadata_dataset.from(:information_schema__tables___t).
          join(:information_schema__columns___c, :table_catalog=>:table_catalog,
               :table_schema => :table_schema, :table_name => :table_name).
          select(:column_name___column, :data_type___db_type, :character_maximum_length___max_chars, :column_default___default, :is_nullable___allow_null, :numeric_precision___column_size, :numeric_scale___scale).
-         filter(:c__table_name=>m2.call(table_name.to_s))
+         filter(:c__table_name=>tn)
         if schema = opts[:schema] || default_schema
           ds.filter!(:c__table_schema=>schema)
         end
         ds.map do |row|
+          row[:primary_key] = pk_cols.include?(row[:column])
           row[:allow_null] = row[:allow_null] == 'YES' ? true : false
           row[:default] = nil if blank_object?(row[:default])
           row[:type] = if row[:db_type] =~ DECIMAL_TYPE_RE && row[:scale] == 0
@@ -262,14 +273,14 @@ module Sequel
         case op
         when :'||'
           super(:+, args)
-        when :ILIKE
-          super(:LIKE, args)
-        when :"NOT ILIKE"
-          super(:"NOT LIKE", args)
+        when :LIKE, :"NOT LIKE"
+          super(op, args.map{|a| LiteralString.new("(#{literal(a)} COLLATE Latin1_General_CS_AS)")})
+        when :ILIKE, :"NOT ILIKE"
+          super((op == :ILIKE ? :LIKE : :"NOT LIKE"), args)
         when :<<
-          "(#{literal(args[0])} * POWER(2, #{literal(args[1])}))"
+          complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} * POWER(2, #{literal(b)}))"}
         when :>>
-          "(#{literal(args[0])} / POWER(2, #{literal(args[1])}))"
+          complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} / POWER(2, #{literal(b)}))"}
         when :extract
           part = args.at(0)
           raise(Sequel::Error, "unsupported extract argument: #{part.inspect}") unless format = EXTRACT_MAP[part]
@@ -297,12 +308,6 @@ module Sequel
         mutation_method(:disable_insert_output)
       end
 
-      # When returning all rows, if an offset is used, delete the row_number column
-      # before yielding the row.
-      def fetch_rows(sql, &block)
-        @opts[:offset] ? super(sql){|r| r.delete(row_number_column); yield r} : super(sql, &block)
-      end
-      
       # MSSQL uses the CONTAINS keyword for full text search
       def full_text_search(cols, terms, opts = {})
         filter("CONTAINS (#{literal(cols)}, #{literal(terms)})")

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

@@ -185,9 +185,9 @@ module Sequel
       # Use XA START to start a new prepared transaction if the :prepare
       # option is given.
       def begin_transaction(conn, opts={})
-        if s = opts[:prepare]
+        if (s = opts[:prepare]) && (th = @transactions[conn])[:savepoint_level] == 0
           log_connection_execute(conn, "XA START #{literal(s)}")
-          conn
+          th[:savepoint_level] += 1
         else
           super
         end
@@ -208,7 +208,7 @@ module Sequel
       # Prepare the XA transaction for a two-phase commit if the
       # :prepare option is given.
       def commit_transaction(conn, opts={})
-        if s = opts[:prepare]
+        if (s = opts[:prepare]) && @transactions[conn][:savepoint_level] <= 1
           log_connection_execute(conn, "XA END #{literal(s)}")
           log_connection_execute(conn, "XA PREPARE #{literal(s)}")
         else
@@ -262,7 +262,7 @@ module Sequel
       
       # Rollback the currently open XA transaction
       def rollback_transaction(conn, opts={})
-        if s = opts[:prepare]
+        if (s = opts[:prepare]) && @transactions[conn][:savepoint_level] <= 1
           log_connection_execute(conn, "XA END #{literal(s)}")
           log_connection_execute(conn, "XA PREPARE #{literal(s)}")
           log_connection_execute(conn, "XA ROLLBACK #{literal(s)}")
@@ -278,8 +278,8 @@ module Sequel
 
       # Use the MySQL specific DESCRIBE syntax to get a table description.
       def schema_parse_table(table_name, opts)
-        m = output_identifier_meth
-        im = input_identifier_meth
+        m = output_identifier_meth(opts[:dataset])
+        im = input_identifier_meth(opts[:dataset])
         metadata_dataset.with_sql("DESCRIBE ?", SQL::Identifier.new(im.call(table_name))).map do |row|
           row[:auto_increment] = true if row.delete(:Extra).to_s =~ /auto_increment/io
           row[:allow_null] = row.delete(:Null) == 'YES'

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

@@ -76,6 +76,12 @@ module Sequel
         module PreparedStatementMethods
           include Sequel::Dataset::UnnumberedArgumentMapper
           
+          # Raise a more obvious error if you attempt to call a unnamed prepared statement.
+          def call(*)
+            raise Error, "Cannot call prepared statement without a name" if prepared_statement_name.nil?
+            super
+          end
+          
           private
           
           # Execute the prepared statement with the bind arguments instead of

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

@@ -1,9 +1,13 @@
+Sequel.require 'adapters/utils/emulate_offset_with_row_number'
+
 module Sequel
   module Oracle
     module DatabaseMethods
       TEMPORARY = 'GLOBAL TEMPORARY '.freeze
       AUTOINCREMENT = ''.freeze
 
+      attr_accessor :autosequence
+
       def create_sequence(name, opts={})
         self << create_sequence_sql(name, opts)
       end
@@ -12,6 +16,10 @@ module Sequel
         self << create_trigger_sql(*args)
       end
 
+      def current_user
+        @current_user ||= get{sys_context('USERENV', 'CURRENT_USER')}
+      end
+
       def drop_sequence(name)
         self << drop_sequence_sql(name)
       end
@@ -37,13 +45,37 @@ module Sequel
 
       private
 
-      def auto_increment_sql
-        AUTOINCREMENT
+      # Handle Oracle specific ALTER TABLE SQL
+      def alter_table_sql(table, op)
+        case op[:op]
+        when :add_column
+          if op[:primary_key]
+            sqls = []
+            sqls << alter_table_sql(table, op.merge(:primary_key=>nil))
+            if op[:auto_increment]
+              seq_name = default_sequence_name(table, op[:name])
+              sqls << drop_sequence_sql(seq_name)
+              sqls << create_sequence_sql(seq_name, op)
+              sqls << "UPDATE #{quote_schema_table(table)} SET #{quote_identifier(op[:name])} = #{seq_name}.nextval"
+            end
+            sqls << "ALTER TABLE #{quote_schema_table(table)} ADD PRIMARY KEY (#{quote_identifier(op[:name])})"
+            sqls
+          else
+             "ALTER TABLE #{quote_schema_table(table)} ADD #{column_definition_sql(op)}"
+          end
+        when :set_column_null
+          "ALTER TABLE #{quote_schema_table(table)} MODIFY #{quote_identifier(op[:name])} #{op[:null] ? 'NULL' : 'NOT NULL'}"
+        when :set_column_type
+          "ALTER TABLE #{quote_schema_table(table)} MODIFY #{quote_identifier(op[:name])} #{type_literal(op)}"
+        when :set_column_default
+          "ALTER TABLE #{quote_schema_table(table)} MODIFY #{quote_identifier(op[:name])} DEFAULT #{literal(op[:default])}"
+        else
+          super(table, op)
+        end
       end
 
-      # SQL fragment for showing a table is temporary
-      def temporary_table_sql
-        TEMPORARY
+      def auto_increment_sql
+        AUTOINCREMENT
       end
 
       def create_sequence_sql(name, opts={})
@@ -61,7 +93,7 @@ module Sequel
         drop_seq_statement = nil
         generator.columns.each do |c|
           if c[:auto_increment]
-            c[:sequence_name] ||= "seq_#{name}_#{c[:name]}"
+            c[:sequence_name] ||= default_sequence_name(name, c[:name])
             unless c[:create_sequence] == false
               drop_seq_statement = drop_sequence_sql(c[:sequence_name])
               statements << create_sequence_sql(c[:sequence_name], c)
@@ -93,13 +125,94 @@ module Sequel
         sql
       end
 
+      def default_sequence_name(table, column)
+        "seq_#{table}_#{column}"
+      end
+
       def drop_sequence_sql(name)
         "DROP SEQUENCE #{quote_identifier(name)}"
       end
+
+      def remove_cached_schema(table)
+        @primary_key_sequences.delete(table)
+        super
+      end
+      
+      def sequence_for_table(table)
+        return nil unless autosequence
+        @primary_key_sequences.fetch(table) do |key|
+          pk = schema(table).select{|k, v| v[:primary_key]}
+          @primary_key_sequences[table] = if pk.length == 1
+            seq = "seq_#{table}_#{pk.first.first}"
+            seq.to_sym unless from(:user_sequences).filter(:sequence_name=>input_identifier_meth.call(seq)).empty?
+          end
+        end
+      end
+
+      # Oracle's integer/:number type handles larger values than
+      # most other databases's bigint types, so it should be
+      # safe to use for Bignum.
+      def type_literal_generic_bignum(column)
+        :integer
+      end
+
+      # Oracle doesn't have a time type, so use timestamp for all
+      # time columns.
+      def type_literal_generic_time(column)
+        :timestamp
+      end
+
+      # Oracle doesn't have a boolean type or even a reasonable
+      # facsimile.  Using a char(1) seems to be the recommended way.
+      def type_literal_generic_trueclass(column)
+        :'char(1)'
+      end
+
+      # SQL fragment for showing a table is temporary
+      def temporary_table_sql
+        TEMPORARY
+      end
     end
 
     module DatasetMethods
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with distinct columns from join where group having compounds order limit lock')
+      include EmulateOffsetWithRowNumber
+
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with distinct columns from join where group having compounds order lock')
+      ROW_NUMBER_EXPRESSION = 'ROWNUM'.lit.freeze
+
+      # Oracle needs to emulate bitwise operators and ILIKE/NOT ILIKE operators.
+      def complex_expression_sql(op, args)
+        case op
+        when :&
+          complex_expression_arg_pairs(args){|a, b| "CAST(BITAND(#{literal(a)}, #{literal(b)}) AS INTEGER)"}
+        when :|
+          complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} - #{complex_expression_sql(:&, [a, b])} + #{literal(b)})"}
+        when :^
+          complex_expression_arg_pairs(args){|*x| "(#{complex_expression_sql(:|, x)} - #{complex_expression_sql(:&, x)})"}
+        when :'B~'
+          "((0 - #{literal(args.at(0))}) - 1)"
+        when :<<
+          complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} * power(2, #{literal b}))"}
+        when :>>
+          complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} / power(2, #{literal b}))"}
+        when :ILIKE, :'NOT ILIKE'
+          a, b = args
+          "(UPPER(#{literal(a)}) #{op == :ILIKE ? :LIKE : :'NOT LIKE'} UPPER(#{literal(b)}))"
+        else
+          super
+        end
+      end
+
+      # Oracle doesn't support CURRENT_TIME, as it doesn't have
+      # a type for storing just time values without a date, so
+      # use CURRENT_TIMESTAMP in its place.
+      def constant_sql(c)
+        if c == :CURRENT_TIME
+          super(:CURRENT_TIMESTAMP)
+        else
+          super
+        end
+      end
 
       # Oracle uses MINUS instead of EXCEPT, and doesn't support EXCEPT ALL
       def except(dataset, opts={})
@@ -109,18 +222,7 @@ module Sequel
       end
 
       def empty?
-        db[:dual].where(exists).get(1) == nil
-      end
-
-      # If this dataset is associated with a sequence, return the most recently
-      # inserted sequence value.
-      def insert(*args)
-        r = super
-        if s = opts[:sequence]
-          with_sql("SELECT #{literal(s)}.currval FROM dual").single_value.to_i
-        else
-          r
-        end
+        db[:dual].where(unordered.exists).get(1) == nil
       end
 
       # Oracle requires SQL standard datetimes
@@ -135,16 +237,49 @@ module Sequel
         clone(:sequence=>s)
       end
 
+      # Handle LIMIT by using a unlimited subselect filtered with ROWNUM.
+      def select_sql
+        if (limit = @opts[:limit]) && !@opts[:sql]
+          ds = clone(:limit=>nil)
+          # 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]
+          subselect_sql(ds.where(SQL::ComplexExpression.new(:<=, ROW_NUMBER_EXPRESSION, limit)))
+        else
+          super
+        end
+      end
+
+      # Oracle requires recursive CTEs to have column aliases.
+      def recursive_cte_requires_column_aliases?
+        true
+      end
+
       # Oracle does not support INTERSECT ALL or EXCEPT ALL
       def supports_intersect_except_all?
         false
       end
+
+      # Oracle does not support IS TRUE.
+      def supports_is_true?
+        false
+      end
+      
+      # Oracle does not support SELECT *, column
+      def supports_select_all_and_column?
+        false
+      end
       
       # Oracle supports timezones in literal timestamps.
       def supports_timestamp_timezones?
         true
       end
       
+      # Oracle does not support WHERE 'Y' for WHERE TRUE.
+      def supports_where_true?
+        false
+      end
+
       # Oracle supports window functions
       def supports_window_functions?
         true
@@ -163,16 +298,47 @@ module Sequel
         "TIMESTAMP '%Y-%m-%d %H:%M:%S%N %z'".freeze
       end
 
+      # If this dataset is associated with a sequence, return the most recently
+      # inserted sequence value.
+      def execute_insert(sql, opts={})
+        f = @opts[:from]
+        super(sql, {:table=>(f.first if f), :sequence=>@opts[:sequence]}.merge(opts))
+      end
+
       # Use a colon for the timestamp offset, since Oracle appears to require it.
       def format_timestamp_offset(hour, minute)
         sprintf("%+03i:%02i", hour, minute)
       end
 
+      # Oracle doesn't support empty values when inserting.
+      def insert_supports_empty_values?
+        false
+      end
+
+      # Use string in hex format for blob data.
+      def literal_blob(v)
+        blob = "'"
+        v.each_byte{|x| blob << sprintf('%02x', x)}
+        blob << "'"
+        blob
+      end
+
+      # Oracle uses 'N' for false values.
+      def literal_false
+        "'N'"
+      end
+
       # Oracle uses the SQL standard of only doubling ' inside strings.
       def literal_string(v)
         "'#{v.gsub("'", "''")}'"
       end
 
+      # Oracle uses 'Y' for true values.
+      def literal_true
+        "'Y'"
+      end
+
+      # Use the Oracle-specific SQL clauses (no limit, since it is emulated).
       def select_clause_methods
         SELECT_CLAUSE_METHODS
       end
@@ -184,17 +350,6 @@ module Sequel
       def select_from_sql(sql)
         sql << " FROM #{source_list(@opts[:from] || ['DUAL'])}"
       end
-
-      # Oracle requires a subselect to do limit and offset
-      def select_limit_sql(sql)
-        if limit = @opts[:limit]
-          if (offset = @opts[:offset]) && (offset > 0)
-            sql.replace("SELECT * FROM (SELECT raw_sql_.*, ROWNUM raw_rnum_ FROM(#{sql}) raw_sql_ WHERE ROWNUM <= #{limit + offset}) WHERE raw_rnum_ > #{offset}")
-          else
-            sql.replace("SELECT * FROM (#{sql}) WHERE ROWNUM <= #{limit}")
-          end
-        end
-      end
     end
   end
 end