activerecord-oracle_enhanced-adapter 1.7.11 → 1.8.2

data/lib/active_record/connection_adapters/oracle_enhanced/context_index.rb

@@ -74,9 +74,9 @@ module ActiveRecord
         def add_context_index(table_name, column_name, options = {})
           self.all_schema_indexes = nil
           column_names = Array(column_name)
-          index_name = options[:name] || index_name(table_name, :column => options[:index_column] || column_names,
+          index_name = options[:name] || index_name(table_name, column: options[:index_column] || column_names,
             # CONEXT index name max length is 25
-            :identifier_max_length => 25)
+            identifier_max_length: 25)
 
           quoted_column_name = quote_column_name(options[:index_column] || column_names.first)
           if options[:index_column_trigger_on]
@@ -129,10 +129,10 @@ module ActiveRecord
         def remove_context_index(table_name, options = {})
           self.all_schema_indexes = nil
           unless Hash === options # if column names passed as argument
-            options = {:column => Array(options)}
+            options = { column: Array(options) }
           end
           index_name = options[:name] || index_name(table_name,
-            :column => options[:index_column] || options[:column], :identifier_max_length => 25)
+            column: options[:index_column] || options[:column], identifier_max_length: 25)
           execute "DROP INDEX #{index_name}"
           drop_ctx_preference(default_datastore_name(index_name))
           drop_ctx_preference(default_storage_name(index_name))
@@ -143,17 +143,17 @@ module ActiveRecord
 
         private
 
-        def create_datastore_procedure(table_name, procedure_name, column_names, options)
-          quoted_table_name = quote_table_name(table_name)
-          select_queries, column_names = column_names.partition { |c| c.to_s =~ /^\s*SELECT\s+/i }
-          select_queries = select_queries.map { |s| s.strip.gsub(/\s+/, ' ') }
-          keys, selected_columns = parse_select_queries(select_queries)
-          quoted_column_names = (column_names+keys).map{|col| quote_column_name(col)}
-          execute compress_lines(<<-SQL)
+          def create_datastore_procedure(table_name, procedure_name, column_names, options)
+            quoted_table_name = quote_table_name(table_name)
+            select_queries, column_names = column_names.partition { |c| c.to_s =~ /^\s*SELECT\s+/i }
+            select_queries = select_queries.map { |s| s.strip.gsub(/\s+/, " ") }
+            keys, selected_columns = parse_select_queries(select_queries)
+            quoted_column_names = (column_names + keys).map { |col| quote_column_name(col) }
+            execute compress_lines(<<-SQL)
             CREATE OR REPLACE PROCEDURE #{quote_table_name(procedure_name)}
               (p_rowid IN	      ROWID,
               p_clob	IN OUT NOCOPY CLOB) IS
-              -- add_context_index_parameters #{(column_names+select_queries).inspect}#{!options.empty? ? ', ' << options.inspect[1..-2] : ''}
+              -- add_context_index_parameters #{(column_names + select_queries).inspect}#{!options.empty? ? ', ' << options.inspect[1..-2] : ''}
               #{
               selected_columns.map do |cols|
                 cols.map do |col|
@@ -170,171 +170,171 @@ module ActiveRecord
                 #{
                 (column_names.map do |col|
                   col = col.to_s
-                  "DBMS_LOB.WRITEAPPEND(p_clob, #{col.length+2}, '<#{col}>');\n" <<
+                  "DBMS_LOB.WRITEAPPEND(p_clob, #{col.length + 2}, '<#{col}>');\n" <<
                   "IF LENGTH(r1.#{col}) > 0 THEN\n" <<
                   "DBMS_LOB.WRITEAPPEND(p_clob, LENGTH(r1.#{col}), r1.#{col});\n" <<
                   "END IF;\n" <<
-                  "DBMS_LOB.WRITEAPPEND(p_clob, #{col.length+3}, '</#{col}>');\n"
+                  "DBMS_LOB.WRITEAPPEND(p_clob, #{col.length + 3}, '</#{col}>');\n"
                 end.join) <<
                 (selected_columns.zip(select_queries).map do |cols, query|
                   (cols.map do |col|
                     "l_#{col} := '';\n"
                   end.join) <<
                   "FOR r2 IN (\n" <<
-                  query.gsub(/:(\w+)/,"r1.\\1") << "\n) LOOP\n" <<
+                  query.gsub(/:(\w+)/, "r1.\\1") << "\n) LOOP\n" <<
                   (cols.map do |col|
                     "l_#{col} := l_#{col} || r2.#{col} || CHR(10);\n"
                   end.join) <<
                   "END LOOP;\n" <<
                   (cols.map do |col|
                     col = col.to_s
-                    "DBMS_LOB.WRITEAPPEND(p_clob, #{col.length+2}, '<#{col}>');\n" <<
+                    "DBMS_LOB.WRITEAPPEND(p_clob, #{col.length + 2}, '<#{col}>');\n" <<
                     "IF LENGTH(l_#{col}) > 0 THEN\n" <<
                     "DBMS_LOB.WRITEAPPEND(p_clob, LENGTH(l_#{col}), l_#{col});\n" <<
                     "END IF;\n" <<
-                    "DBMS_LOB.WRITEAPPEND(p_clob, #{col.length+3}, '</#{col}>');\n"
+                    "DBMS_LOB.WRITEAPPEND(p_clob, #{col.length + 3}, '</#{col}>');\n"
                   end.join)
                 end.join)
                 }
               END LOOP;
             END;
           SQL
-        end
+          end
 
-        def parse_select_queries(select_queries)
-          keys = []
-          selected_columns = []
-          select_queries.each do |query|
-            # get primary or foreign keys like :id or :something_id
-            keys << (query.scan(/:\w+/).map{|k| k[1..-1].downcase.to_sym})
-            select_part = query.scan(/^select\s.*\sfrom/i).first
-            selected_columns << select_part.scan(/\sas\s+(\w+)/i).map{|c| c.first}
+          def parse_select_queries(select_queries)
+            keys = []
+            selected_columns = []
+            select_queries.each do |query|
+              # get primary or foreign keys like :id or :something_id
+              keys << (query.scan(/:\w+/).map { |k| k[1..-1].downcase.to_sym })
+              select_part = query.scan(/^select\s.*\sfrom/i).first
+              selected_columns << select_part.scan(/\sas\s+(\w+)/i).map { |c| c.first }
+            end
+            [keys.flatten.uniq, selected_columns]
           end
-          [keys.flatten.uniq, selected_columns]
-        end
 
-        def create_datastore_preference(datastore_name, procedure_name)
-          drop_ctx_preference(datastore_name)
-          execute <<-SQL
+          def create_datastore_preference(datastore_name, procedure_name)
+            drop_ctx_preference(datastore_name)
+            execute <<-SQL
             BEGIN
               CTX_DDL.CREATE_PREFERENCE('#{datastore_name}', 'USER_DATASTORE');
               CTX_DDL.SET_ATTRIBUTE('#{datastore_name}', 'PROCEDURE', '#{procedure_name}');
             END;
           SQL
-        end
+          end
 
-        def create_storage_preference(storage_name, tablespace)
-          drop_ctx_preference(storage_name)
-          sql = "BEGIN\nCTX_DDL.CREATE_PREFERENCE('#{storage_name}', 'BASIC_STORAGE');\n"
-          ['I_TABLE_CLAUSE', 'K_TABLE_CLAUSE', 'R_TABLE_CLAUSE',
-          'N_TABLE_CLAUSE', 'I_INDEX_CLAUSE', 'P_TABLE_CLAUSE'].each do |clause|
-            default_clause = case clause
-            when 'R_TABLE_CLAUSE'; 'LOB(DATA) STORE AS (CACHE) '
-            when 'I_INDEX_CLAUSE'; 'COMPRESS 2 '
-            else ''
+          def create_storage_preference(storage_name, tablespace)
+            drop_ctx_preference(storage_name)
+            sql = "BEGIN\nCTX_DDL.CREATE_PREFERENCE('#{storage_name}', 'BASIC_STORAGE');\n"
+            ["I_TABLE_CLAUSE", "K_TABLE_CLAUSE", "R_TABLE_CLAUSE",
+            "N_TABLE_CLAUSE", "I_INDEX_CLAUSE", "P_TABLE_CLAUSE"].each do |clause|
+              default_clause = case clause
+                               when "R_TABLE_CLAUSE"; "LOB(DATA) STORE AS (CACHE) "
+                               when "I_INDEX_CLAUSE"; "COMPRESS 2 "
+              else ""
+              end
+              sql << "CTX_DDL.SET_ATTRIBUTE('#{storage_name}', '#{clause}', '#{default_clause}TABLESPACE #{tablespace}');\n"
             end
-            sql << "CTX_DDL.SET_ATTRIBUTE('#{storage_name}', '#{clause}', '#{default_clause}TABLESPACE #{tablespace}');\n"
+            sql << "END;\n"
+            execute sql
           end
-          sql << "END;\n"
-          execute sql
-        end
 
-        def create_lexer_preference(lexer_name, lexer_type, options)
-          drop_ctx_preference(lexer_name)
-          sql = "BEGIN\nCTX_DDL.CREATE_PREFERENCE('#{lexer_name}', '#{lexer_type}');\n"
-          options.each do |key, value|
-            plsql_value = case value
-            when String; "'#{value}'"
-            when true; "'YES'"
-            when false; "'NO'"
-            when nil; 'NULL'
-            else value
+          def create_lexer_preference(lexer_name, lexer_type, options)
+            drop_ctx_preference(lexer_name)
+            sql = "BEGIN\nCTX_DDL.CREATE_PREFERENCE('#{lexer_name}', '#{lexer_type}');\n"
+            options.each do |key, value|
+              plsql_value = case value
+                            when String; "'#{value}'"
+                            when true; "'YES'"
+                            when false; "'NO'"
+                            when nil; "NULL"
+              else value
+              end
+              sql << "CTX_DDL.SET_ATTRIBUTE('#{lexer_name}', '#{key}', #{plsql_value});\n"
             end
-            sql << "CTX_DDL.SET_ATTRIBUTE('#{lexer_name}', '#{key}', #{plsql_value});\n"
+            sql << "END;\n"
+            execute sql
           end
-          sql << "END;\n"
-          execute sql
-        end
 
-        def create_wordlist_preference(wordlist_name, wordlist_type, options)
-          drop_ctx_preference(wordlist_name)
-          sql = "BEGIN\nCTX_DDL.CREATE_PREFERENCE('#{wordlist_name}', '#{wordlist_type}');\n"
-          options.each do |key, value|
-            plsql_value = case value
-            when String; "'#{value}'"
-            when true; "'YES'"
-            when false; "'NO'"
-            when nil; 'NULL'
-            else value
+          def create_wordlist_preference(wordlist_name, wordlist_type, options)
+            drop_ctx_preference(wordlist_name)
+            sql = "BEGIN\nCTX_DDL.CREATE_PREFERENCE('#{wordlist_name}', '#{wordlist_type}');\n"
+            options.each do |key, value|
+              plsql_value = case value
+                            when String; "'#{value}'"
+                            when true; "'YES'"
+                            when false; "'NO'"
+                            when nil; "NULL"
+              else value
+              end
+              sql << "CTX_DDL.SET_ATTRIBUTE('#{wordlist_name}', '#{key}', #{plsql_value});\n"
             end
-            sql << "CTX_DDL.SET_ATTRIBUTE('#{wordlist_name}', '#{key}', #{plsql_value});\n"
+            sql << "END;\n"
+            execute sql
           end
-          sql << "END;\n"
-          execute sql
-        end
 
-        def drop_ctx_preference(preference_name)
-          execute "BEGIN CTX_DDL.DROP_PREFERENCE('#{preference_name}'); END;" rescue nil
-        end
+          def drop_ctx_preference(preference_name)
+            execute "BEGIN CTX_DDL.DROP_PREFERENCE('#{preference_name}'); END;" rescue nil
+          end
 
-        def create_index_column_trigger(table_name, index_name, index_column, index_column_source)
-          trigger_name = default_index_column_trigger_name(index_name)
-          columns = Array(index_column_source)
-          quoted_column_names = columns.map{|col| quote_column_name(col)}.join(', ')
-          execute compress_lines(<<-SQL)
+          def create_index_column_trigger(table_name, index_name, index_column, index_column_source)
+            trigger_name = default_index_column_trigger_name(index_name)
+            columns = Array(index_column_source)
+            quoted_column_names = columns.map { |col| quote_column_name(col) }.join(", ")
+            execute compress_lines(<<-SQL)
             CREATE OR REPLACE TRIGGER #{quote_table_name(trigger_name)}
             BEFORE UPDATE OF #{quoted_column_names} ON #{quote_table_name(table_name)} FOR EACH ROW
             BEGIN
               :new.#{quote_column_name(index_column)} := '1';
             END;
           SQL
-        end
+          end
 
-        def drop_index_column_trigger(index_name)
-          trigger_name = default_index_column_trigger_name(index_name)
-          execute "DROP TRIGGER #{quote_table_name(trigger_name)}" rescue nil
-        end
+          def drop_index_column_trigger(index_name)
+            trigger_name = default_index_column_trigger_name(index_name)
+            execute "DROP TRIGGER #{quote_table_name(trigger_name)}" rescue nil
+          end
 
-        def default_datastore_procedure(index_name)
-          "#{index_name}_prc"
-        end
+          def default_datastore_procedure(index_name)
+            "#{index_name}_prc"
+          end
 
-        def default_datastore_name(index_name)
-          "#{index_name}_dst"
-        end
+          def default_datastore_name(index_name)
+            "#{index_name}_dst"
+          end
 
-        def default_storage_name(index_name)
-          "#{index_name}_sto"
-        end
+          def default_storage_name(index_name)
+            "#{index_name}_sto"
+          end
 
-        def default_index_column_trigger_name(index_name)
-          "#{index_name}_trg"
-        end
+          def default_index_column_trigger_name(index_name)
+            "#{index_name}_trg"
+          end
 
-        def default_lexer_name(index_name)
-          "#{index_name}_lex"
-        end
+          def default_lexer_name(index_name)
+            "#{index_name}_lex"
+          end
 
-        def default_wordlist_name(index_name)
-          "#{index_name}_wl"
-        end
+          def default_wordlist_name(index_name)
+            "#{index_name}_wl"
+          end
 
-        module BaseClassMethods
-          # Declare that model table has context index defined.
-          # As a result <tt>contains</tt> class scope method is defined.
-          def has_context_index
-            extend ContextIndexClassMethods
+          module BaseClassMethods
+            # Declare that model table has context index defined.
+            # As a result <tt>contains</tt> class scope method is defined.
+            def has_context_index
+              extend ContextIndexClassMethods
+            end
           end
-        end
 
-        module ContextIndexClassMethods
-          # Add context index condition.
-          def contains(column, query, options ={})
-            score_label = options[:label].to_i || 1
-            where("CONTAINS(#{connection.quote_table_name(column)}, ?, #{score_label}) > 0", query).
-              order("SCORE(#{score_label}) DESC")
+          module ContextIndexClassMethods
+            # Add context index condition.
+            def contains(column, query, options = {})
+              score_label = options[:label].to_i || 1
+              where("CONTAINS(#{connection.quote_table_name(column)}, ?, #{score_label}) > 0", query).
+                order("SCORE(#{score_label}) DESC")
+            end
           end
-        end
       end
     end
   end

data/lib/active_record/connection_adapters/oracle_enhanced/database_statements.rb

@@ -16,10 +16,10 @@ module ActiveRecord
           reload_type_map
         end
 
-        def exec_query(sql, name = 'SQL', binds = [], prepare: false)
-          type_casted_binds = binds.map { |attr| type_cast(attr.value_for_database) }
+        def exec_query(sql, name = "SQL", binds = [], prepare: false)
+          type_casted_binds = type_casted_binds(binds)
 
-          log(sql, name, binds) do
+          log(sql, name, binds, type_casted_binds) do
             cursor = nil
             cached = false
             if without_prepared_statement?(binds)
@@ -38,14 +38,14 @@ module ActiveRecord
 
             cursor.exec
 
-            if name == 'EXPLAIN' and sql =~ /^EXPLAIN/
+            if (name == "EXPLAIN") && sql =~ /^EXPLAIN/
               res = true
             else
               columns = cursor.get_col_names.map do |col_name|
                 @connection.oracle_downcase(col_name)
               end
               rows = []
-              fetch_options = {:get_lob_value => (name != 'Writable Large Object')}
+              fetch_options = { get_lob_value: (name != "Writable Large Object") }
               while row = cursor.fetch(fetch_options)
                 rows << row
               end
@@ -69,34 +69,35 @@ module ActiveRecord
           sql = "EXPLAIN PLAN FOR #{to_sql(arel, binds)}"
           return if sql =~ /FROM all_/
           if ORACLE_ENHANCED_CONNECTION == :jdbc
-            exec_query(sql, 'EXPLAIN', binds)
+            exec_query(sql, "EXPLAIN", binds)
           else
-            exec_query(sql, 'EXPLAIN')
+            exec_query(sql, "EXPLAIN")
           end
-          select_values("SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY)", 'EXPLAIN').join("\n")
-        end
-
-        # Returns an array of arrays containing the field values.
-        # Order is the same as that returned by #columns.
-        def select_rows(sql, name = nil, binds = [])
-          exec_query(sql, name, binds).rows
+          select_values("SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY)", "EXPLAIN").join("\n")
         end
 
         # New method in ActiveRecord 3.1
         # Will add RETURNING clause in case of trigger generated primary keys
         def sql_for_insert(sql, pk, id_value, sequence_name, binds)
-          unless id_value || pk == false || pk.nil? || (defined?(CompositePrimaryKeys) && pk.kind_of?(CompositePrimaryKeys::CompositeKeys))
+          unless id_value || pk == false || pk.nil? ||  pk.is_a?(Array)
             sql = "#{sql} RETURNING #{quote_column_name(pk)} INTO :returning_id"
             (binds = binds.dup) << ActiveRecord::Relation::QueryAttribute.new("returning_id", nil, ActiveRecord::OracleEnhanced::Type::Integer.new)
           end
           super
         end
 
+        def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
+          pk = nil if id_value
+          super
+        end
+
         # New method in ActiveRecord 3.1
-        def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
-          type_casted_binds = binds.map { |attr| type_cast(attr.value_for_database) }
+        def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
+          sql, binds = sql_for_insert(sql, pk, nil, sequence_name, binds)
+          type_casted_binds = type_casted_binds(binds)
 
-          log(sql, name, binds) do
+          log(sql, name, binds, type_casted_binds) do
+            cached = false
             returning_id_col = returning_id_index = nil
             if without_prepared_statement?(binds)
               cursor = @connection.prepare(sql)
@@ -115,6 +116,7 @@ module ActiveRecord
                 cursor.bind_returning_param(returning_id_index, Integer) if ORACLE_ENHANCED_CONNECTION == :jdbc
               end
 
+              cached = true
             end
 
             cursor.exec_update
@@ -124,24 +126,25 @@ module ActiveRecord
               returning_id = cursor.get_returning_param(returning_id_index, Integer).to_i
               rows << [returning_id]
             end
+            cursor.close unless cached
             ActiveRecord::Result.new(returning_id_col || [], rows)
           end
         end
 
         # New method in ActiveRecord 3.1
-        def exec_update(sql, name, binds)
-          type_casted_binds = binds.map { |attr| type_cast(attr.value_for_database) }
+        def exec_update(sql, name = nil, binds = [])
+          type_casted_binds = type_casted_binds(binds)
 
-          log(sql, name, binds) do
+          log(sql, name, binds, type_casted_binds) do
             cached = false
             if without_prepared_statement?(binds)
               cursor = @connection.prepare(sql)
             else
-              cursor = if @statements.key?(sql)
-                         @statements[sql]
-                       else
-                         @statements[sql] = @connection.prepare(sql)
-                       end
+              if @statements.key?(sql)
+                cursor = @statements[sql]
+              else
+                cursor = @statements[sql] = @connection.prepare(sql)
+              end
 
               cursor.bind_params(type_casted_binds)
 
@@ -202,7 +205,7 @@ module ActiveRecord
         # Returns default sequence name for table.
         # Will take all or first 26 characters of table name and append _seq suffix
         def default_sequence_name(table_name, primary_key = nil)
-          table_name.to_s.gsub((/(^|\.)([\w$-]{1,#{sequence_name_length-4}})([\w$-]*)$/), '\1\2_seq')
+          table_name.to_s.gsub((/(^|\.)([\w$-]{1,#{sequence_name_length - 4}})([\w$-]*)$/), '\1\2_seq')
         end
 
         # Inserts the given fixture into the table. Overridden to properly handle lobs.
@@ -220,6 +223,13 @@ module ActiveRecord
             write_lobs(table_name, klass, fixture, klass.lob_columns)
           end
         end
+
+        # Oracle Database does not support this feature
+        # Refer https://community.oracle.com/ideas/13845 and consider to vote
+        # if you need this feature.
+        def empty_insert_statement_value
+          raise NotImplementedError
+        end
       end
     end
   end

data/lib/active_record/connection_adapters/oracle_enhanced/database_tasks.rb

@@ -1,21 +1,21 @@
-require 'active_record/base'
+require "active_record/base"
 
 module ActiveRecord
   module ConnectionAdapters
     class OracleEnhancedAdapter
       class DatabaseTasks
-        delegate :connection, :establish_connection, :to => ActiveRecord::Base
+        delegate :connection, :establish_connection, to: ActiveRecord::Base
 
         def initialize(config)
           @config = config
         end
 
         def create
-          system_password = ENV.fetch('ORACLE_SYSTEM_PASSWORD') {
+          system_password = ENV.fetch("ORACLE_SYSTEM_PASSWORD") {
             print "Please provide the SYSTEM password for your Oracle installation (set ORACLE_SYSTEM_PASSWORD to avoid this prompt)\n>"
             $stdin.gets.strip
           }
-          establish_connection(@config.merge('username' => 'SYSTEM', 'password' => system_password))
+          establish_connection(@config.merge("username" => "SYSTEM", "password" => system_password))
           begin
             connection.execute "CREATE USER #{@config['username']} IDENTIFIED BY #{@config['password']}"
           rescue => e
@@ -39,18 +39,18 @@ module ActiveRecord
 
         def purge
           drop
-          connection.execute('PURGE RECYCLEBIN') rescue nil
+          connection.execute("PURGE RECYCLEBIN") rescue nil
         end
 
-        def structure_dump(filename)
+        def structure_dump(filename, extra_flags)
           establish_connection(@config)
-          File.open(filename, 'w:utf-8') { |f| f << connection.structure_dump }
-          if @config['structure_dump'] == 'db_stored_code'
-             File.open(filename, 'a') { |f| f << connection.structure_dump_db_stored_code }
+          File.open(filename, "w:utf-8") { |f| f << connection.structure_dump }
+          if @config["structure_dump"] == "db_stored_code"
+            File.open(filename, "a") { |f| f << connection.structure_dump_db_stored_code }
           end
         end
 
-        def structure_load(filename)
+        def structure_load(filename, extra_flags)
           establish_connection(@config)
           connection.execute_structure_dump(File.read(filename))
         end