activerecord-oracle_enhanced-adapter 1.3.0 → 1.3.1

data/lib/active_record/connection_adapters/oracle_enhanced_base_ext.rb

@@ -0,0 +1,79 @@
+module ActiveRecord
+  class Base
+    # Establishes a connection to the database that's used by all Active Record objects.
+    def self.oracle_enhanced_connection(config) #:nodoc:
+      if config[:emulate_oracle_adapter] == true
+        # allows the enhanced adapter to look like the OracleAdapter. Useful to pick up
+        # conditionals in the rails activerecord test suite
+        require 'active_record/connection_adapters/emulation/oracle_adapter'
+        ConnectionAdapters::OracleAdapter.new(
+          ConnectionAdapters::OracleEnhancedConnection.create(config), logger)
+      else
+        ConnectionAdapters::OracleEnhancedAdapter.new(
+          ConnectionAdapters::OracleEnhancedConnection.create(config), logger)
+      end
+    end
+
+    # Specify table columns which should be ignored by ActiveRecord, e.g.:
+    # 
+    #   ignore_table_columns :attribute1, :attribute2
+    def self.ignore_table_columns(*args)
+      connection.ignore_table_columns(table_name,*args)
+    end
+
+    # Specify which table columns should be typecasted to Date (without time), e.g.:
+    # 
+    #   set_date_columns :created_on, :updated_on
+    def self.set_date_columns(*args)
+      connection.set_type_for_columns(table_name,:date,*args)
+    end
+
+    # Specify which table columns should be typecasted to Time (or DateTime), e.g.:
+    # 
+    #   set_datetime_columns :created_date, :updated_date
+    def self.set_datetime_columns(*args)
+      connection.set_type_for_columns(table_name,:datetime,*args)
+    end
+
+    # Specify which table columns should be typecasted to boolean values +true+ or +false+, e.g.:
+    # 
+    #   set_boolean_columns :is_valid, :is_completed
+    def self.set_boolean_columns(*args)
+      connection.set_type_for_columns(table_name,:boolean,*args)
+    end
+
+    # Specify which table columns should be typecasted to integer values.
+    # Might be useful to force NUMBER(1) column to be integer and not boolean, or force NUMBER column without
+    # scale to be retrieved as integer and not decimal. Example:
+    # 
+    #   set_integer_columns :version_number, :object_identifier
+    def self.set_integer_columns(*args)
+      connection.set_type_for_columns(table_name,:integer,*args)
+    end
+
+    # Specify which table columns should be typecasted to string values.
+    # Might be useful to specify that columns should be string even if its name matches boolean column criteria.
+    # 
+    #   set_string_columns :active_flag
+    def self.set_string_columns(*args)
+      connection.set_type_for_columns(table_name,:string,*args)
+    end
+
+    # After setting large objects to empty, select the OCI8::LOB
+    # and write back the data.
+    after_save :enhanced_write_lobs
+    def enhanced_write_lobs #:nodoc:
+      if connection.is_a?(ConnectionAdapters::OracleEnhancedAdapter) &&
+          !(self.class.custom_create_method || self.class.custom_update_method)
+        connection.write_lobs(self.class.table_name, self.class, attributes)
+      end
+    end
+    private :enhanced_write_lobs
+
+    # Get table comment from schema definition.
+    def self.table_comment
+      connection.table_comment(self.table_name)
+    end
+  end
+
+end

data/lib/active_record/connection_adapters/oracle_enhanced_column.rb

@@ -0,0 +1,106 @@
+module ActiveRecord
+  module ConnectionAdapters #:nodoc:
+    class OracleEnhancedColumn < Column
+
+      attr_reader :table_name, :forced_column_type #:nodoc:
+      
+      def initialize(name, default, sql_type = nil, null = true, table_name = nil, forced_column_type = nil) #:nodoc:
+        @table_name = table_name
+        @forced_column_type = forced_column_type
+        super(name, default, sql_type, null)
+      end
+
+      def type_cast(value) #:nodoc:
+        return guess_date_or_time(value) if type == :datetime && OracleEnhancedAdapter.emulate_dates
+        super
+      end
+
+      # convert something to a boolean
+      # added y as boolean value
+      def self.value_to_boolean(value) #:nodoc:
+        if value == true || value == false
+          value
+        elsif value.is_a?(String) && value.blank?
+          nil
+        else
+          %w(true t 1 y +).include?(value.to_s.downcase)
+        end
+      end
+
+      # convert Time or DateTime value to Date for :date columns
+      def self.string_to_date(string) #:nodoc:
+        return string.to_date if string.is_a?(Time) || string.is_a?(DateTime)
+        super
+      end
+
+      # convert Date value to Time for :datetime columns
+      def self.string_to_time(string) #:nodoc:
+        return string.to_time if string.is_a?(Date) && !OracleEnhancedAdapter.emulate_dates
+        super
+      end
+
+      # Get column comment from schema definition.
+      # Will work only if using default ActiveRecord connection.
+      def comment
+        ActiveRecord::Base.connection.column_comment(@table_name, name)
+      end
+      
+      private
+      def simplified_type(field_type)
+        forced_column_type ||
+        case field_type
+          when /decimal|numeric|number/i
+            return :boolean if OracleEnhancedAdapter.emulate_booleans && field_type == 'NUMBER(1)'
+            return :integer if extract_scale(field_type) == 0
+            # if column name is ID or ends with _ID
+            return :integer if OracleEnhancedAdapter.emulate_integers_by_column_name && OracleEnhancedAdapter.is_integer_column?(name, table_name)
+            :decimal
+          when /char/i
+            return :boolean if OracleEnhancedAdapter.emulate_booleans_from_strings &&
+                               OracleEnhancedAdapter.is_boolean_column?(name, field_type, table_name)
+            :string
+          when /date/i
+            forced_column_type ||
+            (:date if OracleEnhancedAdapter.emulate_dates_by_column_name && OracleEnhancedAdapter.is_date_column?(name, table_name)) ||
+            :datetime
+          when /timestamp/i then :timestamp
+          when /time/i then :datetime
+          else super
+        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
+            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
+            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:
+          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
+        end
+        
+      end
+    end
+
+  end
+
+end

data/lib/active_record/connection_adapters/oracle_enhanced_context_index.rb

@@ -37,8 +37,6 @@ module ActiveRecord
       #  Post.contains(:all_text, 'word')
       #
       # ====== Creating index on multiple tables
-      #  add_context_index :posts, [:title, :body], :index_column => :all_text, :sync => 'ON COMMIT',
-      #                     :index_column_trigger_on => [:created_at, :updated_at]
       #  add_context_index :posts,
       #   [:title, :body,
       #   # specify aliases always with AS keyword
@@ -53,6 +51,9 @@ module ActiveRecord
       #  Post.contains(:all_text, "aaa within title")
       #  Post.contains(:all_text, "bbb within comment_author")
       #
+      # ====== Creating index using lexer
+      #  add_context_index :posts, :title, :lexer => { :type => 'BASIC_LEXER', :base_letter => true, ... }
+      #
       def add_context_index(table_name, column_name, options = {})
         self.all_schema_indexes = nil
         column_names = Array(column_name)
@@ -86,6 +87,12 @@ module ActiveRecord
         if options[:sync]
           parameters << "SYNC(#{options[:sync]})"
         end
+        if options[:lexer] && (lexer_type = options[:lexer][:type])
+          lexer_name = default_lexer_name(index_name)
+          (lexer_options = options[:lexer].dup).delete(:type)
+          create_lexer_preference(lexer_name, lexer_type, lexer_options)
+          parameters << "LEXER #{lexer_name}"
+        end
         unless parameters.empty?
           sql << " PARAMETERS ('#{parameters.join(' ')}')"
         end
@@ -138,7 +145,9 @@ module ActiveRecord
               (column_names.map do |col|
                 col = col.to_s
                 "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"
               end.join) <<
               (selected_columns.zip(select_queries).map do |cols, query|
@@ -204,6 +213,23 @@ module ActiveRecord
         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
+          end
+          sql << "CTX_DDL.SET_ATTRIBUTE('#{lexer_name}', '#{key}', #{plsql_value});\n"
+        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
@@ -242,6 +268,10 @@ module ActiveRecord
         "#{index_name}_trg"
       end
 
+      def default_lexer_name(index_name)
+        "#{index_name}_lex"
+      end
+
       module BaseClassMethods
         # Declare that model table has context index defined.
         # As a result <tt>contains</tt> class scope method is defined.

data/lib/active_record/connection_adapters/oracle_enhanced_core_ext.rb

@@ -1,5 +1,5 @@
 require "bigdecimal"
-unless BigDecimal.instance_methods.include?("to_d")
+if (BigDecimal.instance_methods & ["to_d", :to_d]).empty?
   BigDecimal.class_eval do
     def to_d #:nodoc:
       self
@@ -7,7 +7,7 @@ unless BigDecimal.instance_methods.include?("to_d")
   end
 end
 
-unless Bignum.instance_methods.include?("to_d")
+if (Bignum.instance_methods & ["to_d", :to_d]).empty?
   Bignum.class_eval do
     def to_d #:nodoc:
       BigDecimal.new(self.to_s)
@@ -15,51 +15,10 @@ unless Bignum.instance_methods.include?("to_d")
   end
 end
 
-unless Fixnum.instance_methods.include?("to_d")
+if (Fixnum.instance_methods & ["to_d", :to_d]).empty?
   Fixnum.class_eval do
     def to_d #:nodoc:
       BigDecimal.new(self.to_s)
     end
   end
 end
-
-# Add Unicode aware String#upcase and String#downcase methods when mb_chars method is called
-if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby' && RUBY_VERSION >= '1.9'
-  begin
-    require "unicode_utils/upcase"
-    require "unicode_utils/downcase"
-
-    module ActiveRecord #:nodoc:
-      module ConnectionAdapters #:nodoc:
-        module OracleEnhancedUnicodeString #:nodoc:
-          def upcase #:nodoc:
-            UnicodeUtils.upcase(self)
-          end
-
-          def downcase #:nodoc:
-            UnicodeUtils.downcase(self)
-          end
-        end
-      end
-    end
-
-    class String #:nodoc:
-      def mb_chars #:nodoc:
-        self.extend(ActiveRecord::ConnectionAdapters::OracleEnhancedUnicodeString)
-        self
-      end
-    end
-
-  rescue LoadError
-    warning_message = "WARNING: Please install unicode_utils gem to support Unicode aware upcase and downcase for String#mb_chars"
-    if defined?(Rails.logger) && Rails.logger
-      Rails.logger.warn warning_message
-    elsif defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER
-      RAILS_DEFAULT_LOGGER.warn warning_message
-    else
-      STDERR.puts warning_message
-    end
-  end
-
-  
-end

data/lib/active_record/connection_adapters/oracle_enhanced_dirty.rb

@@ -14,9 +14,9 @@ module ActiveRecord #:nodoc:
               # If an old value of 0 is set to '' we want this to get changed to nil as otherwise it'll
               # be typecast back to 0 (''.to_i => 0)
               value = nil
-            # Oracle stores empty string '' or empty text (CLOB) as NULL
+            # Oracle stores empty string '' as NULL
             # therefore need to convert empty string value to nil if old value is nil
-            elsif (column.type == :string || column.type == :text) && column.null && old.nil?
+            elsif column.type == :string && column.null && old.nil?
               value = nil if value == ''
             else
               value = column.type_cast(value)

data/lib/active_record/connection_adapters/oracle_enhanced_jdbc_connection.rb

@@ -73,8 +73,7 @@ module ActiveRecord
           config[:driver] ||= @raw_connection.meta_data.connection.java_class.name
           username = @raw_connection.meta_data.user_name
         else
-          username = config[:username].to_s
-          password, database = config[:password].to_s, config[:database].to_s
+          username, password, database = config[:username], config[:password], config[:database]
           privilege = config[:privilege] && config[:privilege].to_s
           host, port = config[:host], config[:port]
   
@@ -207,6 +206,9 @@ module ActiveRecord
         # as it does not allow creation of triggers with :NEW in their definition
         when /\A\s*(CREATE|DROP)/i
           s = @raw_connection.createStatement()
+          # this disables SQL92 syntax processing of {...} which can result in statement execution errors
+          # if sql contains {...} in strings or comments
+          s.setEscapeProcessing(false)
           s.execute(sql)
           true
         else

data/lib/active_record/connection_adapters/oracle_enhanced_oci_connection.rb

@@ -162,7 +162,7 @@ module ActiveRecord
           value == (v_to_i = value.to_i) ? v_to_i : BigDecimal.new(value.to_s)
         when OCI8::LOB
           if get_lob_value
-            data = value.read
+            data = value.read || ""     # if value.read returns nil, then we have an empty_clob() i.e. an empty string
             # In Ruby 1.9.1 always change encoding to ASCII-8BIT for binaries
             data.force_encoding('ASCII-8BIT') if data.respond_to?(:force_encoding) && value.is_a?(OCI8::BLOB)
             data
@@ -215,7 +215,8 @@ module ActiveRecord
     # configure an Oracle/OCI connection.
     class OracleEnhancedOCIFactory #:nodoc:
       def self.new_connection(config)
-        username, password, database = config[:username].to_s, config[:password].to_s, config[:database].to_s
+        username, password, database = config[:username], config[:password], config[:database]
+        host, port = config[:host], config[:port]
         privilege = config[:privilege] && config[:privilege].to_sym
         async = config[:allow_concurrency]
         prefetch_rows = config[:prefetch_rows] || 100
@@ -225,7 +226,22 @@ module ActiveRecord
         # get session time_zone from configuration or from TZ environment variable
         time_zone = config[:time_zone] || ENV['TZ']
 
-        conn = OCI8.new username, password, database, privilege
+
+        # connection using TNS alias
+        connection_string = if database && !host && ENV['TNS_ADMIN']
+          database
+        # database parameter includes host or TNS connection string
+        elsif database =~ %r{[/(]}
+          database
+        # connection using host, port and database name
+        else
+          host ||= 'localhost'
+          host = "[#{host}]" if host =~ /^[^\[].*:/  # IPv6
+          port ||= 1521
+          "//#{host}:#{port}/#{database}"
+        end
+
+        conn = OCI8.new username, password, connection_string, privilege
         conn.exec %q{alter session set nls_date_format = 'YYYY-MM-DD HH24:MI:SS'}
         conn.exec %q{alter session set nls_timestamp_format = 'YYYY-MM-DD HH24:MI:SS:FF6'} rescue nil
         conn.autocommit = true

data/lib/active_record/connection_adapters/oracle_enhanced_schema_dumper.rb

@@ -56,14 +56,22 @@ module ActiveRecord #:nodoc:
           add_foreign_key_statements = foreign_keys.map do |foreign_key|
             statement_parts = [ ('add_foreign_key ' + foreign_key.from_table.inspect) ]
             statement_parts << foreign_key.to_table.inspect
-            statement_parts << (':name => ' + foreign_key.options[:name].inspect)
             
-            if foreign_key.options[:column] != "#{foreign_key.to_table.singularize}_id"
-              statement_parts << (':column => ' + foreign_key.options[:column].inspect)
-            end
-            if foreign_key.options[:primary_key] != 'id'
-              statement_parts << (':primary_key => ' + foreign_key.options[:primary_key].inspect)
+            if foreign_key.options[:columns].size == 1
+              column = foreign_key.options[:columns].first
+              if column != "#{foreign_key.to_table.singularize}_id"
+                statement_parts << (':column => ' + column.inspect)
+              end
+              
+              if foreign_key.options[:references].first != 'id'
+                statement_parts << (':primary_key => ' + foreign_key.options[:primary_key].inspect)
+              end
+            else
+              statement_parts << (':columns => ' + foreign_key.options[:columns].inspect)
             end
+
+            statement_parts << (':name => ' + foreign_key.options[:name].inspect)
+            
             unless foreign_key.options[:dependent].blank?
               statement_parts << (':dependent => ' + foreign_key.options[:dependent].inspect)
             end

data/lib/active_record/connection_adapters/oracle_enhanced_schema_statements.rb

@@ -0,0 +1,331 @@
+require 'digest/sha1'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhancedSchemaStatements
+      # SCHEMA STATEMENTS ========================================
+      #
+      # see: abstract/schema_statements.rb
+
+      # Additional options for +create_table+ method in migration files.
+      #
+      # You can specify individual starting value in table creation migration file, e.g.:
+      #
+      #   create_table :users, :sequence_start_value => 100 do |t|
+      #     # ...
+      #   end
+      #
+      # You can also specify other sequence definition additional parameters, e.g.:
+      #
+      #   create_table :users, :sequence_start_value => “100 NOCACHE INCREMENT BY 10” do |t|
+      #     # ...
+      #   end
+      #
+      # Create primary key trigger (so that you can skip primary key value in INSERT statement).
+      # By default trigger name will be "table_name_pkt", you can override the name with 
+      # :trigger_name option (but it is not recommended to override it as then this trigger will
+      # not be detected by ActiveRecord model and it will still do prefetching of sequence value).
+      # Example:
+      # 
+      #   create_table :users, :primary_key_trigger => true do |t|
+      #     # ...
+      #   end
+      #
+      # It is possible to add table and column comments in table creation migration files:
+      #
+      #   create_table :employees, :comment => “Employees and contractors” do |t|
+      #     t.string      :first_name, :comment => “Given name”
+      #     t.string      :last_name, :comment => “Surname”
+      #   end
+      
+      def create_table(name, options = {}, &block)
+        create_sequence = options[:id] != false
+        column_comments = {}
+        
+        table_definition = TableDefinition.new(self)
+        table_definition.primary_key(options[:primary_key] || Base.get_primary_key(name.to_s.singularize)) unless options[:id] == false
+
+        # store that primary key was defined in create_table block
+        unless create_sequence
+          class << table_definition
+            attr_accessor :create_sequence
+            def primary_key(*args)
+              self.create_sequence = true
+              super(*args)
+            end
+          end
+        end
+
+        # store column comments
+        class << table_definition
+          attr_accessor :column_comments
+          def column(name, type, options = {})
+            if options[:comment]
+              self.column_comments ||= {}
+              self.column_comments[name] = options[:comment]
+            end
+            super(name, type, options)
+          end
+        end
+
+        result = block.call(table_definition) if block
+        create_sequence = create_sequence || table_definition.create_sequence
+        column_comments = table_definition.column_comments if table_definition.column_comments
+        tablespace = options[:tablespace] ? " TABLESPACE #{options[:tablespace]}" : ""
+
+        if options[:force] && table_exists?(name)
+          drop_table(name, options)
+        end
+
+        create_sql = "CREATE#{' GLOBAL TEMPORARY' if options[:temporary]} TABLE "
+        create_sql << "#{quote_table_name(name)} ("
+        create_sql << table_definition.to_sql
+        create_sql << ")#{tablespace} #{options[:options]}"
+        execute create_sql
+        
+        create_sequence_and_trigger(name, options) if create_sequence
+        
+        add_table_comment name, options[:comment]
+        column_comments.each do |column_name, comment|
+          add_comment name, column_name, comment
+        end
+        
+      end
+
+      def rename_table(name, new_name) #:nodoc:
+        execute "RENAME #{quote_table_name(name)} TO #{quote_table_name(new_name)}"
+        execute "RENAME #{quote_table_name("#{name}_seq")} TO #{quote_table_name("#{new_name}_seq")}" rescue nil
+      end
+
+      def drop_table(name, options = {}) #:nodoc:
+        super(name)
+        seq_name = options[:sequence_name] || default_sequence_name(name)
+        execute "DROP SEQUENCE #{quote_table_name(seq_name)}" rescue nil
+      ensure
+        clear_table_columns_cache(name)
+      end
+
+      # clear cached indexes when adding new index
+      def add_index(table_name, column_name, options = {}) #:nodoc:
+        column_names = Array(column_name)
+        index_name   = index_name(table_name, :column => column_names)
+
+        if Hash === options # legacy support, since this param was a string
+          index_type = options[:unique] ? "UNIQUE" : ""
+          index_name = options[:name] || index_name
+          tablespace = options[:tablespace] ? " TABLESPACE #{options[:tablespace]}" : ""
+        else
+          index_type = options
+        end
+
+        if index_name.to_s.length > index_name_length
+          @logger.warn("Index name '#{index_name}' on table '#{table_name}' is too long; the limit is #{index_name_length} characters. Skipping.") if @logger
+          return
+        end
+        if index_name_exists?(table_name, index_name, false)
+          @logger.warn("Index name '#{index_name}' on table '#{table_name}' already exists. Skipping.") if @logger
+          return
+        end
+        quoted_column_names = column_names.map { |e| quote_column_name(e) }.join(", ")
+
+        execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names})#{tablespace} #{options[:options]}"
+      ensure
+        self.all_schema_indexes = nil
+      end
+
+      # Remove the given index from the table.
+      # Gives warning if index does not exist
+      def remove_index(table_name, options = {}) #:nodoc:
+        index_name = index_name(table_name, options)
+        unless index_name_exists?(table_name, index_name, true)
+          @logger.warn("Index name '#{index_name}' on table '#{table_name}' does not exist. Skipping.") if @logger
+          return
+        end
+        remove_index!(table_name, index_name)
+      end
+
+      # clear cached indexes when removing index
+      def remove_index!(table_name, index_name) #:nodoc:
+        execute "DROP INDEX #{quote_column_name(index_name)}"
+      ensure
+        self.all_schema_indexes = nil
+      end
+
+      # returned shortened index name if default is too large
+      def index_name(table_name, options) #:nodoc:
+        default_name = super(table_name, options)
+        # sometimes options can be String or Array with column names
+        options = {} unless options.is_a?(Hash)
+        identifier_max_length = options[:identifier_max_length] || index_name_length
+        return default_name if default_name.length <= identifier_max_length
+        
+        # remove 'index', 'on' and 'and' keywords
+        shortened_name = "i_#{table_name}_#{Array(options[:column]) * '_'}"
+        
+        # leave just first three letters from each word
+        if shortened_name.length > identifier_max_length
+          shortened_name = shortened_name.split('_').map{|w| w[0,3]}.join('_')
+        end
+        # generate unique name using hash function
+        if shortened_name.length > identifier_max_length
+          shortened_name = 'i'+Digest::SHA1.hexdigest(default_name)[0,identifier_max_length-1]
+        end
+        @logger.warn "#{adapter_name} shortened default index name #{default_name} to #{shortened_name}" if @logger
+        shortened_name
+      end
+
+      # Verify the existence of an index with a given name.
+      #
+      # The default argument is returned if the underlying implementation does not define the indexes method,
+      # as there's no way to determine the correct answer in that case.
+      #
+      # Will always query database and not index cache.
+      def index_name_exists?(table_name, index_name, default)
+        (owner, table_name, db_link) = @connection.describe(table_name)
+        result = select_value(<<-SQL)
+          SELECT 1 FROM all_indexes#{db_link} i
+          WHERE i.owner = '#{owner}'
+             AND i.table_owner = '#{owner}'
+             AND i.table_name = '#{table_name}'
+             AND i.index_name = '#{index_name.to_s.upcase}'
+        SQL
+        result == 1 ? true : false
+      end
+
+      def add_column(table_name, column_name, type, options = {}) #:nodoc:
+        add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+        options[:type] = type
+        add_column_options!(add_column_sql, options)
+        execute(add_column_sql)
+      ensure
+        clear_table_columns_cache(table_name)
+      end
+
+      def change_column_default(table_name, column_name, default) #:nodoc:
+        execute "ALTER TABLE #{quote_table_name(table_name)} MODIFY #{quote_column_name(column_name)} DEFAULT #{quote(default)}"
+      ensure
+        clear_table_columns_cache(table_name)
+      end
+
+      def change_column_null(table_name, column_name, null, default = nil) #:nodoc:
+        column = column_for(table_name, column_name)
+
+        unless null || default.nil?
+          execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
+        end
+
+        change_column table_name, column_name, column.sql_type, :null => null
+      end
+
+      def change_column(table_name, column_name, type, options = {}) #:nodoc:
+        column = column_for(table_name, column_name)
+
+        # remove :null option if its value is the same as current column definition
+        # otherwise Oracle will raise error
+        if options.has_key?(:null) && options[:null] == column.null
+          options[:null] = nil
+        end
+
+        change_column_sql = "ALTER TABLE #{quote_table_name(table_name)} MODIFY #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+        options[:type] = type
+        add_column_options!(change_column_sql, options)
+        execute(change_column_sql)
+      ensure
+        clear_table_columns_cache(table_name)
+      end
+
+      def rename_column(table_name, column_name, new_column_name) #:nodoc:
+        execute "ALTER TABLE #{quote_table_name(table_name)} RENAME COLUMN #{quote_column_name(column_name)} to #{quote_column_name(new_column_name)}"
+      ensure
+        clear_table_columns_cache(table_name)
+      end
+
+      def remove_column(table_name, column_name) #:nodoc:
+        execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)}"
+      ensure
+        clear_table_columns_cache(table_name)
+      end
+
+      def add_comment(table_name, column_name, comment) #:nodoc:
+        return if comment.blank?
+        execute "COMMENT ON COLUMN #{quote_table_name(table_name)}.#{column_name} IS '#{comment}'"
+      end
+
+      def add_table_comment(table_name, comment) #:nodoc:
+        return if comment.blank?
+        execute "COMMENT ON TABLE #{quote_table_name(table_name)} IS '#{comment}'"
+      end
+
+      def table_comment(table_name) #:nodoc:
+        (owner, table_name, db_link) = @connection.describe(table_name)
+        select_value <<-SQL
+          SELECT comments FROM all_tab_comments#{db_link}
+          WHERE owner = '#{owner}'
+            AND table_name = '#{table_name}'
+        SQL
+      end
+
+      def column_comment(table_name, column_name) #:nodoc:
+        (owner, table_name, db_link) = @connection.describe(table_name)
+        select_value <<-SQL
+          SELECT comments FROM all_col_comments#{db_link}
+          WHERE owner = '#{owner}'
+            AND table_name = '#{table_name}'
+            AND column_name = '#{column_name.upcase}'
+        SQL
+      end
+
+      # Maps logical Rails types to Oracle-specific data types.
+      def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
+        # Ignore options for :text and :binary columns
+        return super(type, nil, nil, nil) if ['text', 'binary'].include?(type.to_s)
+
+        super
+      end
+
+      private
+
+      def column_for(table_name, column_name)
+        unless column = columns(table_name).find { |c| c.name == column_name.to_s }
+          raise "No such column: #{table_name}.#{column_name}"
+        end
+        column
+      end
+
+      def create_sequence_and_trigger(table_name, options)
+        seq_name = options[:sequence_name] || default_sequence_name(table_name)
+        seq_start_value = options[:sequence_start_value] || default_sequence_start_value
+        execute "CREATE SEQUENCE #{quote_table_name(seq_name)} START WITH #{seq_start_value}"
+
+        create_primary_key_trigger(table_name, options) if options[:primary_key_trigger]
+      end
+      
+      def create_primary_key_trigger(table_name, options)
+        seq_name = options[:sequence_name] || default_sequence_name(table_name)
+        trigger_name = options[:trigger_name] || default_trigger_name(table_name)
+        primary_key = options[:primary_key] || Base.get_primary_key(table_name.to_s.singularize)
+        execute compress_lines(<<-SQL)
+          CREATE OR REPLACE TRIGGER #{quote_table_name(trigger_name)}
+          BEFORE INSERT ON #{quote_table_name(table_name)} FOR EACH ROW
+          BEGIN
+            IF inserting THEN
+              IF :new.#{quote_column_name(primary_key)} IS NULL THEN
+                SELECT #{quote_table_name(seq_name)}.NEXTVAL INTO :new.#{quote_column_name(primary_key)} FROM dual;
+              END IF;
+            END IF;
+          END;
+        SQL
+      end
+
+      def default_trigger_name(table_name)
+        # truncate table name if necessary to fit in max length of identifier
+        "#{table_name.to_s[0,table_name_length-4]}_pkt"
+      end
+
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.class_eval do
+  include ActiveRecord::ConnectionAdapters::OracleEnhancedSchemaStatements
+end