activerecord-oracle_enhanced-adapter 1.7.11 → 1.8.0.beta1

data/lib/active_record/connection_adapters/emulation/oracle_adapter.rb

@@ -1,5 +1,5 @@
 class ActiveRecord::ConnectionAdapters::OracleAdapter < ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter #:nodoc:
   def adapter_name
-    'Oracle'
+    "Oracle"
   end
 end

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

@@ -4,7 +4,6 @@ module ActiveRecord
       attr_reader :table_name, :nchar, :virtual_column_data_default, :returning_id #:nodoc:
 
       def initialize(name, default, sql_type_metadata = nil, null = true, table_name = nil, virtual = false, returning_id = nil, comment = nil) #:nodoc:
-
         @virtual = virtual
         @virtual_column_data_default = default.inspect if virtual
         @returning_id = returning_id
@@ -17,7 +16,7 @@ module ActiveRecord
         # Is column NCHAR or NVARCHAR2 (will need to use N'...' value quoting for these data types)?
         # Define only when needed as adapter "quote" method will check at first if instance variable is defined.
         if sql_type_metadata
-          @object_type = sql_type_metadata.sql_type.include? '.'
+          @object_type = sql_type_metadata.sql_type.include? "."
         end
         # TODO: Need to investigate when `sql_type` becomes nil
       end
@@ -62,72 +61,21 @@ module ActiveRecord
         super
       end
 
-      # Get column comment from schema definition.
-      # Will work only if using default ActiveRecord connection.
-#      def comment
-#        #TODO: may be deprecated due to conflict with variable
-#        ActiveRecord::Base.connection.column_comment(@table_name, name)
-#      end
-
       private
 
-      def self.extract_value_from_default(default)
-        case default
+        def self.extract_value_from_default(default)
+          case default
           when String
             default.gsub(/''/, "'")
-          else
+            else
             default
-        end
-      end
-
-      def guess_date_or_time(value)
-        value.respond_to?(:hour) && (value.hour == 0 and value.min == 0 and value.sec == 0) ?
-          Date.new(value.year, value.month, value.day) : value
-      end
-
-      class << self
-        protected
-
-        def fallback_string_to_date(string) #:nodoc:
-          if OracleEnhancedAdapter.string_to_date_format || OracleEnhancedAdapter.string_to_time_format
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              `fallback_string_to_date` has been deprecated.
-              It will be removed from next version of Oracle enhanced adapter.
-              Users are unlikely to see this message since this method has gone
-              from ActiveRecord::ConnectionAdapters::Column in Rails 4.2.
-            MSG
-            return (string_to_date_or_time_using_format(string).to_date rescue super)
-          end
-          super
-        end
-
-        def fallback_string_to_time(string) #:nodoc:
-          if OracleEnhancedAdapter.string_to_time_format || OracleEnhancedAdapter.string_to_date_format
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              `fallback_string_to_time` has been deprecated.
-              It will be removed from next version of Oracle enhanced adapter.
-              Users are unlikely to see this message since this method has gone
-              from ActiveRecord::ConnectionAdapters::Column in Rails 4.2.
-            MSG
-            return (string_to_date_or_time_using_format(string).to_time rescue super)
           end
-          super
         end
 
-        def string_to_date_or_time_using_format(string) #:nodoc:
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            `string_to_date_or_time_using_format` has been deprecated.
-            It will be removed from next version of Oracle enhanced adapter.
-            Users are unlikely to see this message since `fallback_string_to_date`
-            and `fallback_string_to_time` have gone
-            from ActiveRecord::ConnectionAdapters::Column in Rails 4.2.
-          MSG
-          if OracleEnhancedAdapter.string_to_time_format && dt=Date._strptime(string, OracleEnhancedAdapter.string_to_time_format)
-            return Time.parse("#{dt[:year]}-#{dt[:mon]}-#{dt[:mday]} #{dt[:hour]}:#{dt[:min]}:#{dt[:sec]}#{dt[:zone]}")
-          end
-          DateTime.strptime(string, OracleEnhancedAdapter.string_to_date_format).to_date
+        def guess_date_or_time(value)
+          value.respond_to?(:hour) && ((value.hour == 0) && (value.min == 0) && (value.sec == 0)) ?
+            Date.new(value.year, value.month, value.day) : value
         end
-      end
     end
   end
 end

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

@@ -2,66 +2,22 @@ module ActiveRecord #:nodoc:
   module ConnectionAdapters #:nodoc:
     module OracleEnhanced #:nodoc:
       module ColumnDumper #:nodoc:
-        def column_spec(column)
-          spec = Hash[prepare_column_options(column).map { |k, v| [k, "#{k}: #{v}"] }]
-          spec[:name] = column.name.inspect
-          if column.virtual?
-            spec[:type] = "virtual"
-          else
-            spec[:type] = schema_type(column).to_s
-          end
-          spec
-        end
-
         def prepare_column_options(column)
-          spec = {}
-
-          if limit = schema_limit(column)
-            spec[:limit] = limit
-          end
-
-          if precision = schema_precision(column)
-            spec[:precision] = precision
-          end
-
-          if scale = schema_scale(column)
-            spec[:scale] = scale
-          end
+          spec = super
 
-          if virtual_as = schema_virtual_as(column)
-            spec[:as] = virtual_as
+          if supports_virtual_columns? && column.virtual?
+            spec[:as] = column.virtual_column_data_default
+            spec = { type: schema_type(column).inspect }.merge!(spec) unless column.type == :decimal
           end
 
-          if virtual_type = schema_virtual_type(column)
-            spec[:virtual_type] = virtual_type
-          end
-
-          default = schema_default(column) if column.has_default?
-          spec[:default]   = default unless default.nil?
-
-          spec[:null] = 'false' unless column.null
-
-          spec[:comment] = column.comment.inspect if column.comment.present?
-
           spec
         end
 
-        def migration_keys
-          # TODO `& column_specs.map(&:keys).flatten` should be exetuted here
-          [:name, :limit, :precision, :scale, :default, :null, :as, :virtual_type, :comment]
-        end
-
         private
 
-        def schema_virtual_as(column)
-          column.virtual_column_data_default if column.virtual?
-        end
-
-        def schema_virtual_type(column)
-          unless column.type == :decimal
-            column.type.inspect if column.virtual?
+          def default_primary_key?(column)
+            schema_type(column) == :integer
           end
-        end
       end
     end
   end

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

@@ -29,8 +29,8 @@ module ActiveRecord
       # Used always by JDBC connection as well by OCI connection when describing tables over database link
       def describe(name)
         name = name.to_s
-        if name.include?('@')
-          name, db_link = name.split('@')
+        if name.include?("@")
+          name, db_link = name.split("@")
           default_owner = select_value("SELECT username FROM all_db_links WHERE db_link = '#{db_link.upcase}'")
           db_link = "@#{db_link}"
         else
@@ -38,8 +38,8 @@ module ActiveRecord
           default_owner = @owner
         end
         real_name = ActiveRecord::ConnectionAdapters::OracleEnhanced::Quoting.valid_table_name?(name) ? name.upcase : name
-        if real_name.include?('.')
-          table_owner, table_name = real_name.split('.')
+        if real_name.include?(".")
+          table_owner, table_name = real_name.split(".")
         else
           table_owner, table_name = default_owner, real_name
         end
@@ -65,11 +65,11 @@ module ActiveRecord
             AND synonym_name = '#{real_name}'
         SQL
         if result = select_one(sql)
-          case result['name_type']
-          when 'SYNONYM'
+          case result["name_type"]
+          when "SYNONYM"
             describe("#{result['owner'] && "#{result['owner']}."}#{result['table_name']}#{db_link}")
           else
-            db_link ? [result['owner'], result['table_name'], db_link] : [result['owner'], result['table_name']]
+            db_link ? [result["owner"], result["table_name"], db_link] : [result["owner"], result["table_name"]]
           end
         else
           raise OracleEnhancedConnectionException, %Q{"DESC #{name}" failed; does it exist?}
@@ -109,13 +109,13 @@ module ActiveRecord
 end
 
 # if MRI or YARV
-if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby'
+if !defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby"
   ORACLE_ENHANCED_CONNECTION = :oci
-  require 'active_record/connection_adapters/oracle_enhanced/oci_connection'
+  require "active_record/connection_adapters/oracle_enhanced/oci_connection"
 # if JRuby
-elsif RUBY_ENGINE == 'jruby'
+elsif RUBY_ENGINE == "jruby"
   ORACLE_ENHANCED_CONNECTION = :jdbc
-  require 'active_record/connection_adapters/oracle_enhanced/jdbc_connection'
+  require "active_record/connection_adapters/oracle_enhanced/jdbc_connection"
 else
   raise "Unsupported Ruby engine #{RUBY_ENGINE}"
 end

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