activerecord 1.6.0 → 1.7.0

data/lib/active_record/callbacks.rb

@@ -22,7 +22,7 @@ module ActiveRecord
   # * (9) after_save
   #
   # That's a total of nine callbacks, which gives you immense power to react and prepare for each state in the
-  # Active Record lifecyle.
+  # Active Record lifecycle.
   #
   # Examples:
   #   class CreditCard < ActiveRecord::Base
@@ -125,7 +125,7 @@ module ActiveRecord
   #       end
   #
   #       def decrypt(value)
-  #         # Secrecy is unvieled
+  #         # Secrecy is unveiled
   #       end
   #   end
   #

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -63,18 +63,6 @@ module ActiveRecord
     #
     # The exceptions AdapterNotSpecified, AdapterNotFound and ArgumentError
     # may be returned on an error.
-    #
-    # == Connecting to another database for a single model
-    #
-    # To support different connections for different classes, you can
-    # simply call establish_connection with the classes you wish to have
-    # different connections for:
-    #
-    #   class Courses < ActiveRecord::Base
-    #    ...
-    #   end
-    #
-    #   Courses.establish_connection( ... )
     def self.establish_connection(spec = nil)
       case spec
         when nil
@@ -151,7 +139,7 @@ module ActiveRecord
     end
 
     # Converts all strings in a hash to symbols.
-    def self.symbolize_strings_in_hash(hash)
+    def self.symbolize_strings_in_hash(hash) #:nodoc:
       hash.symbolize_keys
     end
   end
@@ -326,7 +314,7 @@ module ActiveRecord
       # Commits the transaction (and turns on auto-committing). 
       def commit_db_transaction()   end
 
-      # Rollsback the transaction (and turns on auto-committing). Must be done if the transaction block
+      # Rolls back the transaction (and turns on auto-committing). Must be done if the transaction block
       # raises an exception or returns false.
       def rollback_db_transaction() end
 
@@ -356,6 +344,11 @@ module ActiveRecord
         name
       end
 
+      # Returns the human-readable name of the adapter.  Use mixed case - one can always use downcase if needed.
+      def adapter_name()
+        'Abstract'
+      end
+
       # Returns a string of the CREATE TABLE SQL statements for recreating the entire structure of the database.
       def structure_dump() end
 

data/lib/active_record/connection_adapters/db2_adapter.rb

@@ -1,5 +1,4 @@
-# db2_adapter.rb
-# author: Maik Schmidt <contact@maik-schmidt.de>
+# Author: Maik Schmidt <contact@maik-schmidt.de>
 
 require 'active_record/connection_adapters/abstract_adapter'
 
@@ -29,7 +28,14 @@ begin
     end
 
     module ConnectionAdapters
-      class DB2Adapter < AbstractAdapter # :nodoc:
+      # The DB2 adapter works with the C-based CLI driver (http://raa.ruby-lang.org/project/ruby-db2/).
+      #
+      # Options:
+      #
+      # * <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.
+      class DB2Adapter < AbstractAdapter
         def select_all(sql, name = nil)
           select(sql, name)
         end
@@ -75,6 +81,10 @@ begin
 
         def quote_column_name(name) name; end
 
+        def adapter_name()
+          'DB2'
+        end
+
         def quote_string(s)
           s.gsub(/'/, "''") # ' (for ruby-mode)
         end
@@ -100,30 +110,31 @@ begin
         end
 
         private
-          def last_insert_id
-            row = select_one(<<-GETID.strip)
-            with temp(id) as (values (identity_val_local())) select * from temp
-            GETID
-            row['id'].to_i
+
+        def last_insert_id
+          row = select_one(<<-GETID.strip)
+          with temp(id) as (values (identity_val_local())) select * from temp
+          GETID
+          row['id'].to_i
+        end
+
+        def select(sql, name = nil)
+          stmt = nil
+          log(sql, name, @connection) do |connection|
+            stmt = DB2::Statement.new(connection)
+            stmt.exec_direct(sql + " with ur")
           end
 
-          def select(sql, name = nil)
-            stmt = nil
-            log(sql, name, @connection) do |connection|
-              stmt = DB2::Statement.new(connection)
-              stmt.exec_direct(sql + " with ur")
-            end
-
-            rows = []
-            while row = stmt.fetch_as_hash
-              rows << row
-            end
-            stmt.free
-            rows
+          rows = []
+          while row = stmt.fetch_as_hash
+            rows << row
           end
+          stmt.free
+          rows
+        end
       end
     end
   end
 rescue LoadError
   # DB2 driver is unavailable.
-end
+end

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -1,9 +1,9 @@
 require 'active_record/connection_adapters/abstract_adapter'
 require 'parsedate'
-
+ 
 module ActiveRecord
   class Base
-    # Establishes a connection to the database that's used by all Active Record objects
+    # Establishes a connection to the database that's used by all Active Record objects.
     def self.mysql_connection(config) # :nodoc:
       unless self.class.const_defined?(:Mysql)
         begin
@@ -19,62 +19,98 @@ module ActiveRecord
           end
         end
       end
+ 
       symbolize_strings_in_hash(config)
+ 
       host     = config[:host]
       port     = config[:port]
       socket   = config[:socket]
       username = config[:username] ? config[:username].to_s : 'root'
       password = config[:password].to_s
-
+ 
       if config.has_key?(:database)
         database = config[:database]
       else
         raise ArgumentError, "No database specified. Missing argument: database."
       end
-
-      ConnectionAdapters::MysqlAdapter.new(
-        Mysql::real_connect(host, username, password, database, port, socket), logger
-      )
+ 
+      mysql = Mysql.init
+      mysql.ssl_set(config[:sslkey], config[:sslcert], config[:sslca], config[:sslcapath], config[:sslcipher]) if config[:sslkey]
+      ConnectionAdapters::MysqlAdapter.new(mysql.real_connect(host, username, password, database, port, socket), logger, [host, username, password, database, port, socket])
     end
   end
-
+ 
   module ConnectionAdapters
-    class MysqlAdapter < AbstractAdapter # :nodoc:
+    # The MySQL adapter will work with both Ruby/MySQL, which is a Ruby-based MySQL adapter that comes bundled with Active Record, and with
+    # the faster C-based MySQL/Ruby adapter (available both as a gem and from http://www.tmtm.org/en/mysql/ruby/).
+    #
+    # Options:
+    #
+    # * <tt>:host</tt> -- Defaults to localhost
+    # * <tt>:port</tt> -- Defaults to 3306
+    # * <tt>:socket</tt> -- Defaults to /tmp/mysql.sock
+    # * <tt>:username</tt> -- Defaults to root
+    # * <tt>:password</tt> -- Defaults to nothing
+    # * <tt>:database</tt> -- The name of the database. No default, must be provided.
+    # * <tt>:sslkey</tt> -- Necessary to use MySQL with an SSL connection
+    # * <tt>:sslcert</tt> -- Necessary to use MySQL with an SSL connection
+    # * <tt>:sslcapath</tt> -- Necessary to use MySQL with an SSL connection
+    # * <tt>:sslcipher</tt> -- Necessary to use MySQL with an SSL connection
+    class MysqlAdapter < AbstractAdapter
+      LOST_CONNECTION_ERROR_MESSAGES = [ 
+        "Server shutdown in progress",
+        "Broken pipe", 
+        "Lost connection to MySQL server during query", 
+        "MySQL server has gone away"
+      ]
+      
+      def initialize(connection, logger, connection_options=nil)
+        super(connection, logger)
+        @connection_options = connection_options
+      end
+ 
       def select_all(sql, name = nil)
         select(sql, name)
       end
-
+ 
       def select_one(sql, name = nil)
         result = select(sql, name)
         result.nil? ? nil : result.first
       end
-
+ 
       def columns(table_name, name = nil)
-        sql = "SHOW FIELDS FROM #{table_name}"
-        result = nil
-        log(sql, name, @connection) { |connection| result = connection.query(sql) }
-
+        sql = "SHOW FIELDS FROM #{table_name}" 
         columns = []
-        result.each { |field| columns << Column.new(field[0], field[4], field[1]) }
+        execute(sql, name).each { |field| columns << Column.new(field[0], field[4], field[1]) }
         columns
       end
-
+ 
       def insert(sql, name = nil, pk = nil, id_value = nil)
         execute(sql, name = nil)
         return id_value || @connection.insert_id
       end
-
+ 
       def execute(sql, name = nil)
-        log(sql, name, @connection) { |connection| connection.query(sql) }
+        begin
+          return log(sql, name, @connection) { |connection| connection.query(sql) }
+        rescue ActiveRecord::StatementInvalid => exception
+          if LOST_CONNECTION_ERROR_MESSAGES.any? { |msg| exception.message.split(":").first =~ /^#{msg}/ }
+            @connection.real_connect(*@connection_options)
+            @logger.info("Retrying invalid statement with reopened connection") if @logger
+            return log(sql, name, @connection) { |connection| connection.query(sql) }
+          else
+            raise
+          end
+        end
       end
-
+ 
       def update(sql, name = nil)
         execute(sql, name)
         @connection.affected_rows
       end
-
+ 
       alias_method :delete, :update
-      
+ 
       def begin_db_transaction
         begin
           execute "BEGIN"
@@ -82,7 +118,7 @@ module ActiveRecord
           # Transactions aren't supported
         end
       end
-      
+ 
       def commit_db_transaction
         begin
           execute "COMMIT"
@@ -90,7 +126,7 @@ module ActiveRecord
           # Transactions aren't supported
         end
       end
-      
+ 
       def rollback_db_transaction
         begin
           execute "ROLLBACK"
@@ -98,38 +134,43 @@ module ActiveRecord
           # Transactions aren't supported
         end
       end
-
+ 
       def quote_column_name(name)
         return "`#{name}`"
       end
-      
+ 
+      def adapter_name()
+        'MySQL'
+      end
+ 
       def structure_dump
         select_all("SHOW TABLES").inject("") do |structure, table|
           structure += select_one("SHOW CREATE TABLE #{table.to_a.first.last}")["Create Table"] + ";\n\n"
         end
       end
-      
+ 
       def recreate_database(name)
         drop_database(name)
         create_database(name)
       end
-      
+ 
       def drop_database(name)
         execute "DROP DATABASE IF EXISTS #{name}"
       end
-      
+ 
       def create_database(name)
         execute "CREATE DATABASE #{name}"
       end
-      
+ 
       def quote_string(s)
         Mysql::quote(s)
       end
-
+ 
       private
         def select(sql, name = nil)
           result = nil
-          log(sql, name, @connection) { |connection| connection.query_with_result = true; result = connection.query(sql) }
+          @connection.query_with_result = true
+          result = execute(sql, name)
           rows = []
           all_fields_initialized = result.fetch_fields.inject({}) { |all_fields, f| all_fields[f.name] = nil; all_fields }
           result.each_hash { |row| rows << all_fields_initialized.dup.update(row) }
@@ -137,4 +178,4 @@ module ActiveRecord
         end
     end
   end
-end
+end

data/lib/active_record/connection_adapters/oci_adapter.rb

@@ -0,0 +1,265 @@
+# Implementation notes:
+# 1.  I had to redefine a method in ActiveRecord to make it possible to implement an autonumbering
+#     solution for oracle. It's implemented in a way that is intended to not break other adapters.
+# 2.  Default value support needs a patch to the OCI8 driver, to enable it to read LONG columns.
+#     LONG is deprecated, and so may never be properly added to driver.
+#     A similar patch is needed for TIMESTAMP.
+#     This is dangerous because it may break with newer versions of the driver.
+# 3.  Large Object support works by an after_save callback added to the ActiveRecord. This is not
+#     a problem - you can add other (chained) after_save callbacks.
+# 4.  LIMIT and OFFSET work by scrolling through a cursor - no rownum select from select required.
+#     It does mean that large OFFSETs will have to scroll through the intervening records. To keep
+#     consistency with other adapters I've allowed the LIMIT and OFFSET clauses to be included in
+#     the sql string and later extracted them by parsing the string.
+#
+# Do what you want with this code, at your own peril, but if any significant portion of my code
+# remains then please acknowledge my contribution.
+# Copyright 2005 Graham Jenkins
+# $Revision: 1.2 $
+require 'active_record/connection_adapters/abstract_adapter'
+
+begin
+  require_library_or_gem 'oci8' unless self.class.const_defined? :OCI8
+
+  module ActiveRecord
+    module ConnectionAdapters #:nodoc:
+      class OCIColumn < Column #:nodoc:
+        attr_reader :sql_type
+
+        def initialize(name, default, limit, sql_type, scale)
+          @name, @limit, @sql_type, @scale, @sequence = name, limit, sql_type, scale
+          @type = simplified_type sql_type
+          @default = type_cast default
+        end
+
+        def simplified_type(field_type)
+          case field_type
+          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
+          end
+        end
+
+        def type_cast(value)
+          return nil if value.nil? || value =~ /^\s*null\s*$/i
+          case type
+          when :string   then value
+          when :integer  then value.to_i
+          when :float    then value.to_f
+          when :datetime then cast_to_date_or_time(value)
+          when :time     then cast_to_time(value)
+          else value
+          end
+        end
+
+        def cast_to_date_or_time(value)
+          return value if value.is_a? Date
+          guess_date_or_time (value.is_a? Time) ? value : cast_to_time(value)
+        end
+
+        def cast_to_time(value)
+          return value if value.is_a? Time
+          time_array = ParseDate.parsedate value
+          time_array[0] ||= 2000; time_array[1] ||= 1; time_array[2] ||= 1;
+          Time.send Base.default_timezone, *time_array
+        end
+
+        def guess_date_or_time(value)
+          (value.hour == 0 and value.min == 0 and value.sec == 0) ?
+            Date.new(value.year, value.month, value.day) : value
+        end
+      end
+
+      # This is an Oracle adapter for the ActiveRecord persistence framework. It relies upon the OCI8
+      # driver (http://rubyforge.org/projects/ruby-oci8/), which works with Oracle 8i and above. 
+      # It was developed on Windows 2000 against an 8i database, using ActiveRecord 1.6.0 and OCI8 0.1.9. 
+      # It has also been tested against a 9i database.
+      #
+      # Usage notes:
+      # * Key generation uses a sequence "rails_sequence" for all tables. (I couldn't find a simple
+      #   and safe way of passing table-specific sequence information to the adapter.)
+      # * Oracle uses DATE or TIMESTAMP datatypes for both dates and times. Consequently I have had to
+      #   resort to some hacks to get data converted to Date or Time in Ruby.
+      #   If the column_name ends in _time it's created as a Ruby Time. Else if the
+      #   hours/minutes/seconds are 0, I make it a Ruby Date. Else it's a Ruby Time.
+      #   This is nasty - but if you use Duck Typing you'll probably not care very much.
+      #   In 9i it's tempting to map DATE to Date and TIMESTAMP to Time but I don't think that is
+      #   valid - too many databases use DATE for both.
+      #   Timezones and sub-second precision on timestamps are not supported.
+      # * Default values that are functions (such as "SYSDATE") are not supported. This is a
+      #   restriction of the way active record supports default values.
+      # * Referential integrity constraints are not fully supported. Under at least
+      #   some circumstances, active record appears to delete parent and child records out of
+      #   sequence and out of transaction scope. (Or this may just be a problem of test setup.)
+      #
+      # Options:
+      #
+      # * <tt>:username</tt> -- Defaults to root
+      # * <tt>:password</tt> -- Defaults to nothing
+      # * <tt>:host</tt> -- Defaults to localhost
+      class OCIAdapter < AbstractAdapter
+        def quote_string(s)
+          s.gsub /'/, "''"
+        end
+
+        def quote(value, column = nil)
+          if column and column.type == :binary then %Q{empty_#{ column.sql_type }()}
+          else case value
+            when String     then %Q{'#{quote_string(value)}'}
+            when NilClass     then 'null'
+            when TrueClass    then '1'
+            when FalseClass   then '0'
+            when Numeric    then value.to_s
+            when Date, Time   then %Q{'#{value.strftime("%Y-%m-%d %H:%M:%S")}'}
+            else           %Q{'#{quote_string(value.to_yaml)}'}
+            end
+          end
+        end
+
+        def select_all(sql, name = nil)
+          offset = sql =~ /OFFSET (\d+)$/ ? $1.to_i : -1
+          sql, limit = $1, $2.to_i if sql =~ /(.*)(?: LIMIT[= ](\d+))(\s*OFFSET \d+)?$/
+          cursor = log(sql, name, @connection) { @connection.exec sql }
+          cols = cursor.get_col_names.map { |x| x.downcase }
+          rows = []
+          while row = cursor.fetch
+            next if cursor.row_count <= offset
+            hash = Hash.new
+            cols.each_with_index { |col, i|
+              hash[col] = case row[i]
+                when OCI8::LOB
+                  name == 'Writable Large Object' ? row[i]: row[i].read
+                when OraDate
+                  (row[i].hour == 0 and row[i].minute == 0 and row[i].second == 0) ?
+                    row[i].to_date : row[i].to_time
+                else row[i]
+                end
+            }
+            rows << hash
+            break if rows.size == limit
+          end
+          rows
+        ensure
+          cursor.close if cursor
+        end
+
+        def select_one(sql, name = nil)
+          result = select_all sql, name
+          result.size > 0 ? result.first : nil
+        end
+
+        def columns(table_name, name = nil)
+          cols = select_all(%Q{
+              select column_name, data_type, data_default, data_length, data_scale
+              from user_tab_columns where table_name = '#{table_name.upcase}'}
+          ).map { |row|
+            OCIColumn.new row['column_name'].downcase, row['data_default'],
+              row['data_length'], row['data_type'], row['data_scale']
+          }
+          cols
+        end
+
+        def insert(sql, name = nil, pk = nil, id_value = nil)
+          if pk.nil? # Who called us? What does the sql look like? No idea!
+            execute sql, name
+          elsif id_value # Pre-assigned id
+            log(sql, name, @connection) { @connection.exec sql }
+          else # Assume the sql contains a bind-variable for the id
+            id_value = select_one("select rails_sequence.nextval id from dual")['id']
+            log(sql, name, @connection) { @connection.exec sql, id_value }
+          end
+          id_value
+        end
+
+        def execute(sql, name = nil)
+          log(sql, name, @connection) { @connection.exec sql }
+        end
+
+        alias :update :execute
+        alias :delete :execute
+
+        def add_limit!(sql, limit)
+          sql << "LIMIT=" << limit.to_s
+        end
+
+        def begin_db_transaction()
+          @connection.autocommit = false
+        end
+
+        def commit_db_transaction()
+          @connection.commit
+        ensure
+          @connection.autocommit = true
+        end
+
+        def rollback_db_transaction()
+          @connection.rollback
+        ensure
+          @connection.autocommit = true
+        end
+
+        def adapter_name()
+          'OCI'
+        end
+      end
+    end
+  end
+
+  module ActiveRecord
+    class Base
+      def self.oci_connection(config) #:nodoc:
+        conn = OCI8.new config[:username], config[:password], config[:host]
+        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'}
+        conn.autocommit = true
+        ConnectionAdapters::OCIAdapter.new conn, logger
+      end
+
+      alias :attributes_with_quotes_pre_oci :attributes_with_quotes #:nodoc:
+      # 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.
+      def attributes_with_quotes(creating = true) #:nodoc:
+        aq = attributes_with_quotes_pre_oci creating
+        if connection.class == ConnectionAdapters::OCIAdapter
+          aq[self.class.primary_key] = ":id" if creating && aq[self.class.primary_key].nil?
+        end
+        aq
+      end
+
+      after_save :write_lobs
+
+      # After setting large objects to empty, select the OCI8::LOB and write back the data
+      def write_lobs() #:nodoc:
+        if connection.class == ConnectionAdapters::OCIAdapter
+          self.class.columns.select { |c| c.type == :binary }.each { |c|
+            break unless value = self[c.name]
+            lob = connection.select_one(
+              "select #{ c.name} from #{ self.class.table_name } WHERE #{ self.class.primary_key} = #{quote(id)}",
+              'Writable Large Object'
+              )[c.name]
+            lob.write value
+          }
+        end
+      end
+
+      private :write_lobs
+    end
+  end
+
+  class OCI8 #:nodoc:
+    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
+        else define_a_column_pre_ar i
+        end
+    	end
+    end
+  end
+rescue LoadError
+  # OCI8 driver is unavailable.
+end