activerecord 1.13.2 → 1.14.0

data/lib/active_record/connection_adapters/openbase_adapter.rb

@@ -0,0 +1,349 @@
+require 'active_record/connection_adapters/abstract_adapter'
+
+module ActiveRecord
+  class Base
+    # Establishes a connection to the database that's used by all Active Record objects
+    def self.openbase_connection(config) # :nodoc:
+      require_library_or_gem 'openbase' unless self.class.const_defined?(:OpenBase)
+
+      config = config.symbolize_keys
+      host     = config[:host]
+      username = config[:username].to_s
+      password = config[:password].to_s
+      
+
+      if config.has_key?(:database)
+        database = config[:database]
+      else
+        raise ArgumentError, "No database specified. Missing argument: database."
+      end
+
+      oba = ConnectionAdapters::OpenBaseAdapter.new(
+        OpenBase.new(database, host, username, password), logger
+      )
+      
+      oba
+    end
+    
+  end
+
+  module ConnectionAdapters
+    class OpenBaseColumn < Column #:nodoc:
+      private
+        def simplified_type(field_type)
+          return :integer if field_type.downcase =~ /long/
+          return :float   if field_type.downcase == "money"
+          return :binary  if field_type.downcase == "object"
+          super
+        end
+    end
+    # The OpenBase adapter works with the Ruby/Openbase driver by Tetsuya Suzuki.
+    # http://www.spice-of-life.net/ruby-openbase/ (needs version 0.7.3+)
+    #
+    # Options:
+    #
+    # * <tt>:host</tt> -- Defaults to localhost
+    # * <tt>:username</tt> -- Defaults to nothing
+    # * <tt>:password</tt> -- Defaults to nothing
+    # * <tt>:database</tt> -- The name of the database. No default, must be provided.
+    #
+    # The OpenBase adapter will make use of OpenBase's ability to generate unique ids
+    # for any column with an unique index applied.  Thus, if the value of a primary
+    # key is not specified at the time an INSERT is performed, the adapter will prefetch
+    # a unique id for the primary key.  This prefetching is also necessary in order 
+    # to return the id after an insert.
+    #
+    # Caveat: Operations involving LIMIT and OFFSET do not yet work!
+    #
+    # Maintainer: derrickspell@cdmplus.com
+    class OpenBaseAdapter < AbstractAdapter
+      def adapter_name
+        'OpenBase'
+      end
+      
+      def native_database_types
+        {
+          :primary_key => "integer UNIQUE INDEX DEFAULT _rowid",
+          :string      => { :name => "char", :limit => 4096 },
+          :text        => { :name => "text" },
+          :integer     => { :name => "integer" },
+          :float       => { :name => "float" },
+          :datetime    => { :name => "datetime" },
+          :timestamp   => { :name => "timestamp" },
+          :time        => { :name => "time" },
+          :date        => { :name => "date" },
+          :binary      => { :name => "object" },
+          :boolean     => { :name => "boolean" }
+        }
+      end
+      
+      def supports_migrations?
+        false
+      end      
+      
+      def prefetch_primary_key?(table_name = nil)
+        true
+      end
+      
+      def default_sequence_name(table_name, primary_key) # :nodoc:
+        "#{table_name} #{primary_key}"
+      end
+      
+      def next_sequence_value(sequence_name)
+        ary = sequence_name.split(' ')
+        if (!ary[1]) then
+          ary[0] =~ /(\w+)_nonstd_seq/
+          ary[0] = $1
+        end
+        @connection.unique_row_id(ary[0], ary[1])
+      end
+
+      
+      # QUOTING ==================================================
+      
+      def quote(value, column = nil)
+        if value.kind_of?(String) && column && column.type == :binary
+          "'#{@connection.insert_binary(value)}'"
+        else
+          super
+        end
+      end
+      
+      def quoted_true
+        "1"
+      end
+      
+      def quoted_false
+        "0"
+      end
+      
+
+
+      # DATABASE STATEMENTS ======================================
+
+      def add_limit_offset!(sql, options) #:nodoc
+        if limit = options[:limit]
+          unless offset = options[:offset]
+            sql << " RETURN RESULTS #{limit}"
+          else
+            limit = limit + offset
+            sql << " RETURN RESULTS #{offset} TO #{limit}"
+          end
+        end
+      end
+      
+      def select_all(sql, name = nil) #:nodoc:
+        select(sql, name)
+      end
+
+      def select_one(sql, name = nil) #:nodoc:
+        add_limit_offset!(sql,{:limit => 1})
+        results = select(sql, name)
+        results.first if results
+      end
+
+      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
+        execute(sql, name)
+        update_nulls_after_insert(sql, name, pk, id_value, sequence_name)
+        id_value
+      end
+      
+      def execute(sql, name = nil) #:nodoc:
+        log(sql, name) { @connection.execute(sql) }
+      end
+
+      def update(sql, name = nil) #:nodoc:
+        execute(sql, name).rows_affected
+      end
+
+      alias_method :delete, :update #:nodoc:
+#=begin
+      def begin_db_transaction #:nodoc:
+        execute "START TRANSACTION"
+      rescue Exception
+        # Transactions aren't supported
+      end
+
+      def commit_db_transaction #:nodoc:
+        execute "COMMIT"
+      rescue Exception
+        # Transactions aren't supported
+      end
+
+      def rollback_db_transaction #:nodoc:
+        execute "ROLLBACK"
+      rescue Exception
+        # Transactions aren't supported
+      end
+#=end      
+
+      # SCHEMA STATEMENTS ========================================
+
+      # Return the list of all tables in the schema search path.
+      def tables(name = nil) #:nodoc:
+        tables = @connection.tables
+        tables.reject! { |t| /\A_SYS_/ === t }
+        tables
+      end
+
+      def columns(table_name, name = nil) #:nodoc:
+        sql = "SELECT * FROM _sys_tables "
+        sql << "WHERE tablename='#{table_name}' AND INDEXOF(fieldname,'_')<>0 "
+        sql << "ORDER BY columnNumber"
+        columns = []
+        select_all(sql, name).each do |row|
+          columns << OpenBaseColumn.new(row["fieldname"],
+                                default_value(row["defaultvalue"]),
+                                sql_type_name(row["typename"],row["length"]),
+                                row["notnull"]
+                                )
+    #      breakpoint() if row["fieldname"] == "content"
+        end
+        columns
+      end
+
+      def indexes(table_name, name = nil)#:nodoc:
+        sql = "SELECT fieldname, notnull, searchindex, uniqueindex, clusteredindex FROM _sys_tables "
+        sql << "WHERE tablename='#{table_name}' AND INDEXOF(fieldname,'_')<>0 "
+        sql << "AND primarykey=0 "
+        sql << "AND (searchindex=1 OR uniqueindex=1 OR clusteredindex=1) "
+        sql << "ORDER BY columnNumber"
+        indexes = []
+        execute(sql, name).each do |row|
+          indexes << IndexDefinition.new(table_name,index_name(row),row[3]==1,[row[0]])
+        end
+        indexes
+      end
+
+
+      private
+        def select(sql, name = nil)
+          sql = translate_sql(sql)
+          results = execute(sql, name)
+
+          date_cols = []
+          col_names = []
+          results.column_infos.each do |info|
+            col_names << info.name
+            date_cols << info.name if info.type == "date"
+          end
+          
+          rows = []
+          if ( results.rows_affected )
+            results.each do |row|  # loop through result rows
+              hashed_row = {}
+              row.each_index do |index| 
+                hashed_row["#{col_names[index]}"] = row[index] unless col_names[index] == "_rowid"
+              end
+              date_cols.each do |name|
+                unless hashed_row["#{name}"].nil? or hashed_row["#{name}"].empty?
+                  hashed_row["#{name}"] = Date.parse(hashed_row["#{name}"],false).to_s
+                end
+              end
+              rows << hashed_row
+            end
+          end
+          rows
+        end
+        
+        def default_value(value)
+          # Boolean type values
+          return true if value =~ /true/
+          return false if value =~ /false/
+ 
+          # Date / Time magic values
+          return Time.now.to_s if value =~ /^now\(\)/i
+ 
+          # Empty strings should be set to null
+          return nil if value.empty?
+          
+          # Otherwise return what we got from OpenBase
+          # and hope for the best...
+          return value
+        end 
+        
+        def sql_type_name(type_name, length)
+          return "#{type_name}(#{length})" if ( type_name =~ /char/ )
+          type_name
+        end
+                
+        def index_name(row = [])
+          name = ""
+          name << "UNIQUE " if row[3]
+          name << "CLUSTERED " if row[4]
+          name << "INDEX"
+          name
+        end
+        
+        def translate_sql(sql)
+          
+          # Change table.* to list of columns in table
+          while (sql =~ /SELECT.*\s(\w+)\.\*/)
+            table = $1
+            cols = columns(table)
+            if ( cols.size == 0 ) then
+              # Maybe this is a table alias
+              sql =~ /FROM(.+?)(?:LEFT|OUTER|JOIN|WHERE|GROUP|HAVING|ORDER|RETURN|$)/  
+              $1 =~ /[\s|,](\w+)\s+#{table}[\s|,]/ # get the tablename for this alias
+              cols = columns($1)
+            end
+            select_columns = []
+            cols.each do |col|
+              select_columns << table + '.' + col.name
+            end
+            sql.gsub!(table + '.*',select_columns.join(", ")) if select_columns
+          end
+   
+          # Change JOIN clause to table list and WHERE condition
+          while (sql =~ /JOIN/)
+            sql =~ /((LEFT )?(OUTER )?JOIN (\w+) ON )(.+?)(?:LEFT|OUTER|JOIN|WHERE|GROUP|HAVING|ORDER|RETURN|$)/
+            join_clause = $1 + $5
+            is_outer_join = $3
+            join_table = $4
+            join_condition = $5
+            join_condition.gsub!(/=/,"*") if is_outer_join
+            if (sql =~ /WHERE/)
+              sql.gsub!(/WHERE/,"WHERE (#{join_condition}) AND")
+            else
+              sql.gsub!(join_clause,"#{join_clause} WHERE #{join_condition}")
+            end
+            sql =~ /(FROM .+?)(?:LEFT|OUTER|JOIN|WHERE|$)/
+            from_clause = $1
+            sql.gsub!(from_clause,"#{from_clause}, #{join_table} ")
+            sql.gsub!(join_clause,"")
+          end
+    
+          # ORDER BY _rowid if no explicit ORDER BY
+          # This will ensure that find(:first) returns the first inserted row
+          if (sql !~ /(ORDER BY)|(GROUP BY)/)
+            if (sql =~ /RETURN RESULTS/)
+              sql.sub!(/RETURN RESULTS/,"ORDER BY _rowid RETURN RESULTS")
+            else
+              sql << " ORDER BY _rowid"
+            end
+          end
+          
+          sql
+        end
+        
+        def update_nulls_after_insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+          sql =~ /INSERT INTO (\w+) \((.*)\) VALUES\s*\((.*)\)/m
+          table = $1
+          cols = $2
+          values = $3
+          cols = cols.split(',')
+          values.gsub!(/'[^']*'/,"''")
+          values.gsub!(/"[^"]*"/,"\"\"")
+          values = values.split(',')
+          update_cols = []
+          values.each_index { |index| update_cols << cols[index] if values[index] =~ /\s*NULL\s*/ }
+          update_sql = "UPDATE #{table} SET"
+          update_cols.each { |col| update_sql << " #{col}=NULL," unless col.empty? }
+          update_sql.chop!()
+          update_sql << " WHERE #{pk}=#{quote(id_value)}"
+          execute(update_sql, name + " NULL Correction") if update_cols.size > 0
+        end
+        
+      end
+  end
+end

data/lib/active_record/connection_adapters/{oci_adapter.rb → oracle_adapter.rb}

@@ -1,4 +1,4 @@
-# oci_adapter.rb -- ActiveRecord adapter for Oracle 8i, 9i, 10g
+# oracle_adapter.rb -- ActiveRecord adapter for Oracle 8i, 9i, 10g
 #
 # Original author: Graham Jenkins
 #
@@ -30,18 +30,28 @@ begin
 
   module ActiveRecord
     class Base
-      def self.oci_connection(config) #:nodoc:
+      def self.oracle_connection(config) #:nodoc:
         # Use OCI8AutoRecover instead of normal OCI8 driver.
-        ConnectionAdapters::OCIAdapter.new OCI8AutoRecover.new(config), logger
+        ConnectionAdapters::OracleAdapter.new OCI8AutoRecover.new(config), logger
+      end
+
+      # for backwards-compatibility
+      def self.oci_connection(config) #:nodoc:
+        config[:database] = config[:host]
+        self.oracle_connection(config)
       end
 
       # Enable the id column to be bound into the sql later, by the adapter's insert method.
       # This is preferable to inserting the hard-coded value here, because the insert method
       # needs to know the id value explicitly.
-      alias :attributes_with_quotes_pre_oci :attributes_with_quotes #:nodoc:
+      def attributes_with_quotes_pre_oracle #:nodoc:
+        attributes_with_quotes
+      end
+        
+
       def attributes_with_quotes(creating = true) #:nodoc:
-        aq = attributes_with_quotes_pre_oci creating
-        if connection.class == ConnectionAdapters::OCIAdapter
+        aq = attributes_with_quotes_pre_oracle creating
+        if connection.class == ConnectionAdapters::OracleAdapter
           aq[self.class.primary_key] = ":id" if creating && aq[self.class.primary_key].nil?
         end
         aq
@@ -51,12 +61,12 @@ begin
       # and write back the data.
       after_save :write_lobs 
       def write_lobs() #:nodoc:
-        if connection.is_a?(ConnectionAdapters::OCIAdapter)
+        if connection.is_a?(ConnectionAdapters::OracleAdapter)
           self.class.columns.select { |c| c.type == :binary }.each { |c|
             value = self[c.name]
             next if value.nil?  || (value == '')
             lob = connection.select_one(
-              "select #{ c.name} from #{ self.class.table_name } WHERE #{ self.class.primary_key} = #{quote(id)}",
+              "SELECT #{ c.name} FROM #{ self.class.table_name } WHERE #{ self.class.primary_key} = #{quote(id)}",
               'Writable Large Object')[c.name]
             lob.write value
           }
@@ -68,7 +78,7 @@ begin
 
 
     module ConnectionAdapters #:nodoc:
-      class OCIColumn < Column #:nodoc:
+      class OracleColumn < Column #:nodoc:
         attr_reader :sql_type
 
         # overridden to add the concept of scale, required to differentiate
@@ -102,7 +112,8 @@ begin
           when /char/i                          : :string
           when /num|float|double|dec|real|int/i : @scale == 0 ? :integer : :float
           when /date|time/i                     : @name =~ /_at$/ ? :time : :datetime
-          when /lob/i                           : :binary
+          when /clob/i                           : :text
+          when /blob/i                           : :binary
           end
         end
 
@@ -149,16 +160,19 @@ begin
       # * Default values that are functions (such as "SYSDATE") are not
       #   supported. This is a restriction of the way ActiveRecord supports
       #   default values.
+      # * Support for Oracle8 is limited by Rails' use of ANSI join syntax, which
+      #   is supported in Oracle9i and later. You will need to use #finder_sql for
+      #   has_and_belongs_to_many associations to run against Oracle8.
       #
-      # Options:
+      # Required parameters:
       #
-      # * <tt>:username</tt> -- Defaults to root
-      # * <tt>:password</tt> -- Defaults to nothing
-      # * <tt>:host</tt> -- Defaults to localhost
-      class OCIAdapter < AbstractAdapter
+      # * <tt>:username</tt>
+      # * <tt>:password</tt>
+      # * <tt>:database</tt>
+      class OracleAdapter < AbstractAdapter
 
         def adapter_name #:nodoc:
-          'OCI'
+          'Oracle'
         end
 
         def supports_migrations? #:nodoc:
@@ -167,9 +181,9 @@ begin
         
         def native_database_types #:nodoc
           {
-            :primary_key => "NUMBER(38) NOT NULL",
+            :primary_key => "NUMBER(38) NOT NULL PRIMARY KEY",
             :string      => { :name => "VARCHAR2", :limit => 255 },
-            :text        => { :name => "LONG" },
+            :text        => { :name => "CLOB" },
             :integer     => { :name => "NUMBER", :limit => 38 },
             :float       => { :name => "NUMBER" },
             :datetime    => { :name => "DATE" },
@@ -181,6 +195,9 @@ begin
           }
         end
 
+        def table_alias_length
+          30
+        end
 
         # QUOTING ==================================================
         #
@@ -197,7 +214,7 @@ begin
         end
 
         def quote(value, column = nil) #:nodoc:
-          if column and column.type == :binary then %Q{empty_#{ column.sql_type }()}
+          if column && column.type == :binary then %Q{empty_#{ column.sql_type }()}
           else case value
             when String       then %Q{'#{quote_string(value)}'}
             when NilClass     then 'null'
@@ -211,7 +228,8 @@ begin
         end
 
 
-        # CONNECTION MANAGEMENT ====================================#
+        # CONNECTION MANAGEMENT ====================================
+        #
 
         # Returns true if the connection is active.
         def active?
@@ -220,17 +238,23 @@ begin
           # last known state, which isn't good enough if the connection has
           # gone stale since the last use.
           @connection.ping
-        rescue OCIError
+        rescue OCIException
           false
         end
 
         # Reconnects to the database.
         def reconnect!
           @connection.reset!
-        rescue OCIError => e
+        rescue OCIException => e
           @logger.warn "#{adapter_name} automatic reconnection failed: #{e.message}"
         end
 
+        # Disconnects from the database.
+        def disconnect!
+          @connection.logoff rescue nil
+          @connection.active = false
+        end
+
 
         # DATABASE STATEMENTS ======================================
         #
@@ -300,6 +324,10 @@ begin
         #
         # see: abstract/schema_statements.rb
 
+        def current_database #:nodoc:
+          select_one("select sys_context('userenv','db_name') db from dual")["db"]
+        end
+
         def tables(name = nil) #:nodoc:
           select_all("select lower(table_name) from user_tables").inject([]) do | tabs, t |
             tabs << t.to_a.first.last
@@ -332,10 +360,7 @@ begin
         end
 
         def columns(table_name, name = nil) #:nodoc:
-          table_name = table_name.to_s.upcase
-          owner = table_name.include?('.') ? "'#{table_name.split('.').first}'" : "user"
-          table = "'#{table_name.split('.').last}'"
-          scope = (owner == "user" ? "user" : "all")
+          table_info = @connection.object_info(table_name)
 
           table_cols = %Q{
             select column_name, data_type, data_default, nullable,
@@ -343,26 +368,20 @@ begin
                                      'VARCHAR2', data_length,
                                       null) as length,
                    decode(data_type, 'NUMBER', data_scale, null) as scale
-              from #{scope}_catalog cat, #{scope}_synonyms syn, all_tab_columns col
-             where cat.table_name = #{table}
-               and syn.synonym_name (+)= cat.table_name
-               and col.table_name = nvl(syn.table_name, cat.table_name)
-               and col.owner = nvl(syn.table_owner, #{(scope == "all" ? "cat.owner" : "user")}) }
-
-          if scope == "all"
-            table_cols << %Q{
-               and cat.owner = #{owner}
-               and syn.owner (+)= cat.owner }
-          end
+              from all_tab_columns
+             where owner      = '#{table_info.schema}'
+               and table_name = '#{table_info.name}'
+             order by column_id
+          }
 
           select_all(table_cols, name).map do |row|
             row['data_default'].sub!(/^'(.*)'\s*$/, '\1') if row['data_default']
-            OCIColumn.new(
-              oci_downcase(row['column_name']), 
+            OracleColumn.new(
+              oracle_downcase(row['column_name']),
               row['data_default'],
-              row['data_type'], 
-              row['length'], 
-              row['scale'],
+              row['data_type'],
+              (l = row['length']).nil? ? nil : l.to_i,
+              (s = row['scale']).nil? ? nil : s.to_i,
               row['nullable'] == 'Y'
             )
           end
@@ -370,17 +389,17 @@ begin
 
         def create_table(name, options = {}) #:nodoc:
           super(name, options)
-          execute "CREATE SEQUENCE #{name}_seq"
+          execute "CREATE SEQUENCE #{name}_seq" unless options[:id] == false
         end
 
         def rename_table(name, new_name) #:nodoc:
           execute "RENAME #{name} TO #{new_name}"
-          execute "RENAME #{name}_seq TO #{new_name}_seq"
+          execute "RENAME #{name}_seq TO #{new_name}_seq" rescue nil
         end  
 
         def drop_table(name) #:nodoc:
           super(name)
-          execute "DROP SEQUENCE #{name}_seq"
+          execute "DROP SEQUENCE #{name}_seq" rescue nil
         end
 
         def remove_index(table_name, options = {}) #:nodoc:
@@ -451,7 +470,7 @@ begin
 
         def select(sql, name = nil)
           cursor = log(sql, name) { @connection.exec sql }
-          cols = cursor.get_col_names.map { |x| oci_downcase(x) }
+          cols = cursor.get_col_names.map { |x| oracle_downcase(x) }
           rows = []
 
           while row = cursor.fetch
@@ -483,7 +502,7 @@ begin
         # I don't know anybody who does this, but we'll handle the theoretical case of a
         # camelCase column name. I imagine other dbs handle this different, since there's a
         # unit test that's currently failing test_oci.
-        def oci_downcase(column_name)
+        def oracle_downcase(column_name)
           column_name =~ /[a-z]/ ? column_name : column_name.downcase
         end
 
@@ -492,27 +511,62 @@ begin
   end
 
 
-  # This OCI8 patch may not longer be required with the upcoming
-  # release of version 0.2.
   class OCI8 #:nodoc:
+
+    # This OCI8 patch may not longer be required with the upcoming
+    # release of version 0.2.
     class Cursor #:nodoc:
       alias :define_a_column_pre_ar :define_a_column
       def define_a_column(i)
         case do_ocicall(@ctx) { @parms[i - 1].attrGet(OCI_ATTR_DATA_TYPE) }
         when 8    : @stmt.defineByPos(i, String, 65535) # Read LONG values
         when 187  : @stmt.defineByPos(i, OraDate) # Read TIMESTAMP values
+        when 108
+          if @parms[i - 1].attrGet(OCI_ATTR_TYPE_NAME) == 'XMLTYPE'
+            @stmt.defineByPos(i, String, 65535)
+          else
+            raise 'unsupported datatype'
+          end
         else define_a_column_pre_ar i
         end
       end
     end
+
+    # missing constant from oci8 < 0.1.14
+    OCI_PTYPE_UNK = 0 unless defined?(OCI_PTYPE_UNK)
+
+    def object_info(name)
+      OraObject.new describe(name.to_s, OCI_PTYPE_UNK)
+    end
+
+    def describe(name, type)
+      @desc ||= @@env.alloc(OCIDescribe)
+      @desc.attrSet(OCI_ATTR_DESC_PUBLIC, -1) if VERSION >= '0.1.14'
+      @desc.describeAny(@svc, name, type)
+      @desc.attrGet(OCI_ATTR_PARAM)
+    end
+
+    class OraObject #:nodoc:
+      attr_reader :schema, :name
+      def initialize(info)
+        case info.attrGet(OCI_ATTR_PTYPE)
+        when OCI_PTYPE_TABLE, OCI_PTYPE_VIEW
+          @schema = info.attrGet(OCI_ATTR_OBJ_SCHEMA)
+          @name   = info.attrGet(OCI_ATTR_OBJ_NAME)
+        when OCI_PTYPE_SYN
+          @schema = info.attrGet(OCI_ATTR_SCHEMA_NAME)
+          @name   = info.attrGet(OCI_ATTR_NAME)
+        end
+      end
+    end
   end
 
 
-  # The OCIConnectionFactory factors out the code necessary to connect and
-  # configure an OCI connection.
-  class OCIConnectionFactory #:nodoc:
-    def new_connection(username, password, host)
-      conn = OCI8.new username, password, host
+  # The OracleConnectionFactory factors out the code necessary to connect and
+  # configure an Oracle/OCI connection.
+  class OracleConnectionFactory #:nodoc:
+    def new_connection(username, password, database)
+      conn = OCI8.new username, password, database
       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'} rescue nil
       conn.autocommit = true
@@ -538,11 +592,11 @@ begin
     end
     @@auto_retry = false
 
-    def initialize(config, factory = OCIConnectionFactory.new)
+    def initialize(config, factory = OracleConnectionFactory.new)
       @active = true
-      @username, @password, @host = config[:username], config[:password], config[:host]
+      @username, @password, @database = config[:username], config[:password], config[:database]
       @factory = factory
-      @connection  = @factory.new_connection @username, @password, @host
+      @connection  = @factory.new_connection @username, @password, @database
       super @connection
     end
 
@@ -561,7 +615,7 @@ begin
     def reset!
       logoff rescue nil
       begin
-        @connection = @factory.new_connection @username, @password, @host
+        @connection = @factory.new_connection @username, @password, @database
         __setobj__ @connection
         @active = true
       rescue
@@ -584,7 +638,7 @@ begin
 
       begin
         @connection.exec(sql, *bindvars)
-      rescue OCIError => e
+      rescue OCIException => e
         raise unless LOST_CONNECTION_ERROR_CODES.include?(e.code)
         @active = false
         raise unless should_retry
@@ -598,4 +652,16 @@ begin
 
 rescue LoadError
   # OCI8 driver is unavailable.
+  module ActiveRecord # :nodoc:
+    class Base
+      def self.oracle_connection(config) # :nodoc:
+        # Set up a reasonable error message
+        raise LoadError, "Oracle/OCI libraries could not be loaded."
+      end
+      def self.oci_connection(config) # :nodoc:
+        # Set up a reasonable error message
+        raise LoadError, "Oracle/OCI libraries could not be loaded."
+      end
+    end
+  end
 end