sequel 3.21.0 → 3.32.0

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 ||= metadata_dataset.get{sys_context('USERENV', 'CURRENT_USER')}
+      end
+
       def drop_sequence(name)
         self << drop_sequence_sql(name)
       end
@@ -22,32 +30,53 @@ module Sequel
       end
 
       def tables(opts={})
-        ds = from(:tab).server(opts[:server]).select(:tname).filter(:tabtype => 'TABLE')
-        ds.map{|r| ds.send(:output_identifier, r[:tname])}
-      end
-
-      def table_exists?(name)
-        from(:tab).filter(:tname =>dataset.send(:input_identifier, name), :tabtype => 'TABLE').count > 0
+        m = output_identifier_meth
+        metadata_dataset.from(:tab).server(opts[:server]).select(:tname).filter(:tabtype => 'TABLE').map{|r| m.call(r[:tname])}
       end
 
       def views(opts={}) 
-        ds = from(:tab).server(opts[:server]).select(:tname).filter(:tabtype => 'VIEW') 
-        ds.map{|r| ds.send(:output_identifier, r[:tname])} 
+        m = output_identifier_meth
+        metadata_dataset.from(:tab).server(opts[:server]).select(:tname).filter(:tabtype => 'VIEW').map{|r| m.call(r[:tname])}
       end 
  
       def view_exists?(name) 
-        from(:tab).filter(:tname =>dataset.send(:input_identifier, name), :tabtype => 'VIEW').count > 0 
+        m = input_identifier_meth
+        metadata_dataset.from(:tab).filter(:tname =>m.call(name), :tabtype => 'VIEW').count > 0 
       end 
 
       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={})
@@ -65,7 +94,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)
@@ -97,13 +126,120 @@ 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 select distinct columns from join where group having compounds order lock')
+      ROW_NUMBER_EXPRESSION = 'ROWNUM'.lit.freeze
+      SPACE = Dataset::SPACE
+      APOS = Dataset::APOS
+      APOS_RE = Dataset::APOS_RE
+      DOUBLE_APOS = Dataset::DOUBLE_APOS
+      FROM = Dataset::FROM
+      BITCOMP_OPEN = "((0 - ".freeze
+      BITCOMP_CLOSE = ") - 1)".freeze
+      ILIKE_0 = "(UPPER(".freeze
+      ILIKE_1 = ") ".freeze
+      ILIKE_2 = ' UPPER('.freeze
+      ILIKE_3 = "))".freeze
+      LIKE = 'LIKE'.freeze
+      NOT_LIKE = 'NOT LIKE'.freeze
+      TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S%N %z'".freeze
+      TIMESTAMP_OFFSET_FORMAT = "%+03i:%02i".freeze
+      BOOL_FALSE = "'N'".freeze
+      BOOL_TRUE = "'Y'".freeze
+      HSTAR = "H*".freeze
+      DUAL = ['DUAL'.freeze].freeze
+
+      # Oracle needs to emulate bitwise operators and ILIKE/NOT ILIKE operators.
+      def complex_expression_sql_append(sql, op, args)
+        case op
+        when :&
+          sql << complex_expression_arg_pairs(args){|a, b| "CAST(BITAND(#{literal(a)}, #{literal(b)}) AS INTEGER)"}
+        when :|
+          sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} - #{complex_expression_sql(:&, [a, b])} + #{literal(b)})"}
+        when :^
+          sql << complex_expression_arg_pairs(args){|*x| "(#{complex_expression_sql(:|, x)} - #{complex_expression_sql(:&, x)})"}
+        when :'B~'
+          sql << BITCOMP_OPEN
+          literal_append(sql, args.at(0))
+          sql << BITCOMP_CLOSE
+        when :<<
+          sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} * power(2, #{literal b}))"}
+        when :>>
+          sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} / power(2, #{literal b}))"}
+        when :ILIKE, :'NOT ILIKE'
+          sql << ILIKE_0
+          literal_append(sql, args.at(0))
+          sql << ILIKE_1
+          sql << (op == :ILIKE ? LIKE : NOT_LIKE)
+          sql<< ILIKE_2
+          literal_append(sql, args.at(1))
+          sql << ILIKE_3
+        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_append(sql, c)
+        if c == :CURRENT_TIME
+          super(sql, :CURRENT_TIMESTAMP)
+        else
+          super
+        end
+      end
 
       # Oracle uses MINUS instead of EXCEPT, and doesn't support EXCEPT ALL
       def except(dataset, opts={})
@@ -112,19 +248,10 @@ module Sequel
         compound_clone(:minus, dataset, opts)
       end
 
+      # Use a custom expression with EXISTS to determine whether a dataset
+      # is empty.
       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(@opts[:offset] ? exists : unordered.exists).get(1) == nil
       end
 
       # Oracle requires SQL standard datetimes
@@ -139,16 +266,61 @@ 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]
+          sql = @opts[:append_sql] || ''
+          subselect_sql_append(sql, ds.where(SQL::ComplexExpression.new(:<=, ROW_NUMBER_EXPRESSION, limit)))
+          sql
+        else
+          super
+        end
+      end
+
+      # Oracle requires recursive CTEs to have column aliases.
+      def recursive_cte_requires_column_aliases?
+        true
+      end
+
+      # Oracle supports GROUP BY CUBE
+      def supports_group_cube?
+        true
+      end
+
+      # Oracle supports GROUP BY ROLLUP
+      def supports_group_rollup?
+        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
@@ -158,25 +330,54 @@ module Sequel
 
       # Oracle doesn't support the use of AS when aliasing a dataset.  It doesn't require
       # the use of AS anywhere, so this disables it in all cases.
-      def as_sql(expression, aliaz)
-        "#{expression} #{quote_identifier(aliaz)}"
+      def as_sql_append(sql, aliaz)
+        sql << SPACE
+        quote_identifier_append(sql, aliaz)
       end
 
       # The strftime format to use when literalizing the time.
       def default_timestamp_format
-        "TIMESTAMP '%Y-%m-%d %H:%M:%S%N %z'".freeze
+        TIMESTAMP_FORMAT
+      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)
+        sprintf(TIMESTAMP_OFFSET_FORMAT, 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_append(sql, v)
+        sql << APOS << v.unpack(HSTAR).first << APOS
+      end
+
+      # Oracle uses 'N' for false values.
+      def literal_false
+        BOOL_FALSE
       end
 
       # Oracle uses the SQL standard of only doubling ' inside strings.
-      def literal_string(v)
-        "'#{v.gsub("'", "''")}'"
+      def literal_string_append(sql, v)
+        sql << APOS << v.gsub(APOS_RE, DOUBLE_APOS) << APOS
+      end
+
+      # Oracle uses 'Y' for true values.
+      def literal_true
+        BOOL_TRUE
       end
 
+      # Use the Oracle-specific SQL clauses (no limit, since it is emulated).
       def select_clause_methods
         SELECT_CLAUSE_METHODS
       end
@@ -186,18 +387,8 @@ module Sequel
       # so add the dummy DUAL table if the dataset doesn't select
       # from a table.
       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
+        sql << FROM
+        source_list_append(sql, @opts[:from] || DUAL)
       end
     end
   end