sequel 4.36.0 → 5.61.0

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

@@ -1,15 +1,19 @@
 # frozen-string-literal: true
 
-Sequel.require 'adapters/utils/emulate_offset_with_row_number'
+require_relative '../utils/emulate_offset_with_row_number'
 
 module Sequel
   module Oracle
-    module DatabaseMethods
-      extend Sequel::Database::ResetIdentifierMangling
-
-      TEMPORARY = 'GLOBAL TEMPORARY '.freeze
-      AUTOINCREMENT = ''.freeze
+    Sequel::Database.set_shared_adapter_scheme(:oracle, self)
+    
+    def self.mock_adapter_setup(db)
+      db.instance_exec do
+        @server_version = 11000000
+        @primary_key_sequences = {}
+      end
+    end
 
+    module DatabaseMethods
       attr_accessor :autosequence
 
       def create_sequence(name, opts=OPTS)
@@ -28,7 +32,6 @@ module Sequel
         self << drop_sequence_sql(name)
       end
 
-      # Oracle uses the :oracle database type
       def database_type
         :oracle
       end
@@ -38,11 +41,22 @@ module Sequel
         im = input_identifier_meth
         schema, table = schema_and_table(table)
         ds = metadata_dataset.
-          from(:all_cons_columns___pc, :all_constraints___p, :all_cons_columns___fc, :all_constraints___f).
-          where(:f__table_name=>im.call(table), :f__constraint_type=>'R', :p__owner=>:f__r_owner, :p__constraint_name=>:f__r_constraint_name, :pc__owner=>:p__owner, :pc__constraint_name=>:p__constraint_name, :pc__table_name=>:p__table_name, :fc__owner=>:f__owner, :fc__constraint_name=>:f__constraint_name, :fc__table_name=>:f__table_name, :fc__position=>:pc__position).
-          select(:p__table_name___table, :pc__column_name___key, :fc__column_name___column, :f__constraint_name___name).
-          order(:table, :fc__position)
-        ds = ds.where(:f__schema_name=>im.call(schema)) if schema
+          from{[all_cons_columns.as(:pc), all_constraints.as(:p), all_cons_columns.as(:fc), all_constraints.as(:f)]}.
+          where{{
+            f[:table_name]=>im.call(table),
+            f[:constraint_type]=>'R',
+            p[:owner]=>f[:r_owner],
+            p[:constraint_name]=>f[:r_constraint_name],
+            pc[:owner]=>p[:owner],
+            pc[:constraint_name]=>p[:constraint_name],
+            pc[:table_name]=>p[:table_name],
+            fc[:owner]=>f[:owner],
+            fc[:constraint_name]=>f[:constraint_name],
+            fc[:table_name]=>f[:table_name],
+            fc[:position]=>pc[:position]}}.
+          select{[p[:table_name].as(:table), pc[:column_name].as(:key), fc[:column_name].as(:column), f[:constraint_name].as(:name)]}.
+          order{[:table, fc[:position]]}
+        ds = ds.where{{f[:schema_name]=>im.call(schema)}} if schema
 
         fks = {}
         ds.each do |r|
@@ -56,12 +70,19 @@ module Sequel
         fks.values
       end
 
+      def freeze
+        current_user
+        server_version
+        @conversion_procs.freeze
+        super
+      end
+
       # Oracle namespaces indexes per table.
       def global_index_namespace?
         false
       end
 
-      IGNORE_OWNERS = %w'APEX_040000 CTXSYS EXFSYS MDSYS OLAPSYS ORDDATA ORDSYS SYS SYSTEM XDB XDBMETADATA XDBPM XFILES WMSYS'
+      IGNORE_OWNERS = %w'APEX_040000 CTXSYS EXFSYS MDSYS OLAPSYS ORDDATA ORDSYS SYS SYSTEM XDB XDBMETADATA XDBPM XFILES WMSYS'.freeze
 
       def tables(opts=OPTS)
         m = output_identifier_meth
@@ -82,14 +103,37 @@ module Sequel
           map{|r| m.call(r[:view_name])}
       end 
  
-      def view_exists?(name) 
-        m = input_identifier_meth
-        metadata_dataset.from(:all_views).
-          exclude(:owner=>IGNORE_OWNERS).
-          where(:view_name=>m.call(name)).
-          count > 0
+      # Whether a view with a given name exists.  By default, looks in all schemas other than system
+      # schemas.  If the :current_schema option is given, looks in the schema for the current user.
+      def view_exists?(name, opts=OPTS) 
+        ds = metadata_dataset.from(:all_views).where(:view_name=>input_identifier_meth.call(name))
+        
+        if opts[:current_schema]
+          ds = ds.where(:owner=>Sequel.function(:SYS_CONTEXT, 'userenv', 'current_schema'))
+        else
+          ds = ds.exclude(:owner=>IGNORE_OWNERS)
+        end
+
+        ds.count > 0
       end 
 
+      # The version of the Oracle server, used for determining capability.
+      def server_version(server=nil)
+        return @server_version if @server_version
+        @server_version = synchronize(server) do |conn|
+          (conn.server_version rescue nil) if conn.respond_to?(:server_version)
+        end
+        unless @server_version
+          @server_version = if m = /(\d+)\.(\d+)\.?(\d+)?\.?(\d+)?/.match(fetch("select version from PRODUCT_COMPONENT_VERSION where lower(product) like 'oracle%'").single_value)
+            (m[1].to_i*1000000) + (m[2].to_i*10000) + (m[3].to_i*100) + m[4].to_i
+          else
+            0
+          end
+        end
+        @server_version
+      end
+
+
       # Oracle supports deferrable constraints.
       def supports_deferrable_constraints?
         true
@@ -102,7 +146,6 @@ module Sequel
 
       private
 
-      # Handle Oracle specific ALTER TABLE SQL
       def alter_table_sql(table, op)
         case op[:op]
         when :add_column
@@ -132,7 +175,7 @@ module Sequel
       end
 
       def auto_increment_sql
-        AUTOINCREMENT
+        ''
       end
 
       def create_sequence_sql(name, opts=OPTS)
@@ -141,7 +184,7 @@ module Sequel
 
       def create_table_from_generator(name, generator, options)
         drop_statement, create_statements = create_table_sql_list(name, generator, options)
-        (execute_ddl(drop_statement) rescue nil) if drop_statement
+        swallow_database_error{execute_ddl(drop_statement)} if drop_statement
         create_statements.each{|sql| execute_ddl(sql)}
       end
 
@@ -188,6 +231,7 @@ module Sequel
         /check constraint .+ violated/ => CheckConstraintViolation,
         /cannot insert NULL into|cannot update .+ to NULL/ => NotNullConstraintViolation,
         /can't serialize access for this transaction/ => SerializationFailure,
+        /resource busy and acquire with NOWAIT specified or timeout/ => DatabaseLockTimeout,
       }.freeze
       def database_error_regexps
         DATABASE_ERROR_REGEXPS
@@ -202,14 +246,14 @@ module Sequel
       end
 
       def remove_cached_schema(table)
-        @primary_key_sequences.delete(table)
+        Sequel.synchronize{@primary_key_sequences.delete(table)}
         super
       end
       
       TRANSACTION_ISOLATION_LEVELS = {:uncommitted=>'READ COMMITTED'.freeze,
         :committed=>'READ COMMITTED'.freeze,
         :repeatable=>'SERIALIZABLE'.freeze,
-        :serializable=>'SERIALIZABLE'.freeze}
+        :serializable=>'SERIALIZABLE'.freeze}.freeze
       # Oracle doesn't support READ UNCOMMITTED OR REPEATABLE READ transaction
       # isolation levels, so upgrade to the next highest level in those cases.
       def set_transaction_isolation_sql(level)
@@ -218,19 +262,20 @@ module Sequel
     
       def sequence_for_table(table)
         return nil unless autosequence
-        @primary_key_sequences.fetch(table) do |key|
-          begin
-            sch = schema(table)
-          rescue Sequel::Error
-            return nil
-          end
+        Sequel.synchronize{return @primary_key_sequences[table] if @primary_key_sequences.has_key?(table)}
 
-          pk = sch.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
+        begin
+          sch = schema(table)
+        rescue Sequel::Error
+          return nil
+        end
+
+        pk = sch.select{|k, v| v[:primary_key]}
+        pks = if pk.length == 1
+          seq = "seq_#{table}_#{pk.first.first}"
+          seq.to_sym unless from(:user_sequences).where(:sequence_name=>input_identifier_meth.call(seq)).empty?
         end
+        Sequel.synchronize{@primary_key_sequences[table] = pks}
       end
 
       # Oracle supports CREATE OR REPLACE VIEW.
@@ -247,7 +292,7 @@ module Sequel
 
       # Oracle doesn't have a time type, so use timestamp for all
       # time columns.
-      def type_literal_generic_time(column)
+      def type_literal_generic_only_time(column)
         :timestamp
       end
 
@@ -259,7 +304,7 @@ module Sequel
 
       # SQL fragment for showing a table is temporary
       def temporary_table_sql
-        TEMPORARY
+        'GLOBAL TEMPORARY '
       end
 
       # Oracle uses clob for text types.
@@ -275,22 +320,10 @@ module Sequel
 
     module DatasetMethods
       ROW_NUMBER_EXPRESSION = LiteralString.new('ROWNUM').freeze
-      SPACE = Dataset::SPACE
-      APOS = Dataset::APOS
-      APOS_RE = Dataset::APOS_RE
-      DOUBLE_APOS = Dataset::DOUBLE_APOS
-      FROM = Dataset::FROM
-      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 = ' FROM DUAL'.freeze
       BITAND_PROC = lambda{|a, b| Sequel.lit(["CAST(BITAND(", ", ", ") AS INTEGER)"], a, b)}
-      SKIP_LOCKED = " SKIP LOCKED".freeze
 
       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)
@@ -305,6 +338,19 @@ module Sequel
             s2 = complex_expression_arg_pairs(x, &BITAND_PROC)
             Sequel.lit(["(", " - ", ")"], s1, s2)
           end
+        when :~, :'!~', :'~*', :'!~*'
+          raise InvalidOperation, "Pattern matching via regular expressions is not supported in this Oracle version" unless supports_regexp?
+          if op == :'!~' || op == :'!~*'
+            sql << 'NOT '
+          end
+          sql << 'REGEXP_LIKE('
+          literal_append(sql, args[0])
+          sql << ','
+          literal_append(sql, args[1])
+          if op == :'~*' || op == :'!~*'
+            sql << ", 'i'"
+          end
+          sql << ')'
         when :%, :<<, :>>, :'B~'
           complex_expression_emulate_append(sql, op, args)
         else
@@ -347,10 +393,14 @@ module Sequel
         clone(:sequence=>s)
       end
 
-      # Handle LIMIT by using a unlimited subselect filtered with ROWNUM.
+      # Handle LIMIT by using a unlimited subselect filtered with ROWNUM,
+      # unless Oracle 12 is used.
       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
@@ -366,7 +416,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]
@@ -392,6 +442,12 @@ module Sequel
         false
       end
 
+      # Oracle supports FETCH NEXT ROWS since 12c, but it doesn't work when
+      # locking or when skipping locked rows.
+      def supports_fetch_next_rows?
+        server_version >= 12000000 && !(@opts[:lock] || @opts[:skip_locked])
+      end
+
       # Oracle supports GROUP BY CUBE
       def supports_group_cube?
         true
@@ -422,6 +478,16 @@ module Sequel
         false
       end
     
+      # Oracle supports MERGE
+      def supports_merge?
+        true
+      end
+
+      # Oracle supports NOWAIT.
+      def supports_nowait?
+        true
+      end
+
       # Oracle does not support offsets in correlated subqueries.
       def supports_offsets_in_correlated_subqueries?
         false
@@ -452,8 +518,82 @@ module Sequel
         true
       end
 
+      # The version of the database server
+      def server_version
+        db.server_version(@opts[:server])
+      end
+
+      # Oracle 10+ supports pattern matching via regular expressions
+      def supports_regexp?
+        server_version >= 10010002
+      end
+
       private
 
+      # Handle nil, false, and true MERGE WHEN conditions to avoid non-boolean
+      # type error.
+      def _normalize_merge_when_conditions(conditions)
+        case conditions
+        when nil, false
+          {1=>0}
+        when true
+          {1=>1}
+        when Sequel::SQL::DelayedEvaluation
+          Sequel.delay{_normalize_merge_when_conditions(conditions.call(self))}
+        else
+          conditions
+        end
+      end
+
+      # Handle Oracle's non standard MERGE syntax
+      def _merge_when_sql(sql)
+        raise Error, "no WHEN [NOT] MATCHED clauses provided for MERGE" unless merge_when = @opts[:merge_when]
+        insert = update = delete = nil
+        types = merge_when.map{|d| d[:type]}
+        raise Error, "Oracle does not support multiple INSERT, UPDATE, or DELETE clauses in MERGE" if types != types.uniq
+
+        merge_when.each do |data|
+          case data[:type]
+          when :insert
+            insert = data
+          when :update
+            update = data
+          else # when :delete
+            delete = data
+          end
+        end
+
+        if delete
+          raise Error, "Oracle does not support DELETE without UPDATE clause in MERGE" unless update
+          raise Error, "Oracle does not support DELETE without conditions clause in MERGE" unless delete.has_key?(:conditions)
+        end
+
+        if update
+          sql << " WHEN MATCHED"
+          _merge_update_sql(sql, update)
+          _merge_when_conditions_sql(sql, update)
+
+          if delete
+            sql << " DELETE"
+            _merge_when_conditions_sql(sql, delete)
+          end
+        end
+
+        if insert
+          sql << " WHEN NOT MATCHED"
+          _merge_insert_sql(sql, insert)
+          _merge_when_conditions_sql(sql, insert)
+        end
+      end
+
+      # Handle Oracle's non-standard MERGE WHEN condition syntax.
+      def _merge_when_conditions_sql(sql, data)
+        if data.has_key?(:conditions)
+          sql << " WHERE "
+          literal_append(sql, _normalize_merge_when_conditions(data[:conditions]))
+        end
+      end
+
       # Allow preparing prepared statements, since determining the prepared sql to use for
       # a prepared statement requires calling prepare on that statement.
       def allow_preparing_prepared_statements?
@@ -461,23 +601,24 @@ module Sequel
       end
 
       # 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.
+      # the use of AS anywhere, so this disables it in all cases.  Oracle also does not support
+      # derived column lists in aliases.
       def as_sql_append(sql, aliaz, column_aliases=nil)
         raise Error, "oracle does not support derived column lists" if column_aliases
-        sql << SPACE
+        sql << ' '
         quote_identifier_append(sql, aliaz)
       end
 
       # The strftime format to use when literalizing the time.
       def default_timestamp_format
-        TIMESTAMP_FORMAT
+        "TIMESTAMP '%Y-%m-%d %H:%M:%S%N %z'"
       end
 
       def empty_from_sql
-        DUAL
+        ' FROM DUAL'
       end
 
-      # There is no function on Microsoft SQL Server that does character length
+      # There is no function on Oracle that does character length
       # and respects trailing spaces (datalength respects trailing spaces, but
       # counts bytes instead of characters).  Use a hack to work around the
       # trailing spaces issue.
@@ -509,7 +650,7 @@ module Sequel
 
       # Use a colon for the timestamp offset, since Oracle appears to require it.
       def format_timestamp_offset(hour, minute)
-        sprintf(TIMESTAMP_OFFSET_FORMAT, hour, minute)
+        sprintf("%+03i:%02i", hour, minute)
       end
 
       # Oracle doesn't support empty values when inserting.
@@ -519,22 +660,22 @@ module Sequel
 
       # Use string in hex format for blob data.
       def literal_blob_append(sql, v)
-        sql << APOS << v.unpack(HSTAR).first << APOS
+        sql << "'" << v.unpack("H*").first << "'"
       end
 
       # Oracle uses 'N' for false values.
       def literal_false
-        BOOL_FALSE
+        "'N'"
       end
 
       # Oracle uses the SQL standard of only doubling ' inside strings.
       def literal_string_append(sql, v)
-        sql << APOS << v.gsub(APOS_RE, DOUBLE_APOS) << APOS
+        sql << "'" << v.gsub("'", "''") << "'"
       end
 
       # Oracle uses 'Y' for true values.
       def literal_true
-        BOOL_TRUE
+        "'Y'"
       end
 
       # Oracle can insert multiple rows using a UNION
@@ -542,12 +683,32 @@ module Sequel
         :union
       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
+
       # Use SKIP LOCKED if skipping locked rows.
       def select_lock_sql(sql)
         super
 
-        if @opts[:skip_locked]
-          sql << SKIP_LOCKED
+        if @opts[:lock]
+          if @opts[:skip_locked]
+            sql << " SKIP LOCKED"
+          elsif @opts[:nowait]
+            sql << " NOWAIT"
+          end
         end
       end