activerecord 1.13.0 → 1.13.1

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -5,24 +5,19 @@ module ActiveRecord
     # Establishes a connection to the database that's used by all Active Record objects.
     def self.mysql_connection(config) # :nodoc:
       # Only include the MySQL driver if one hasn't already been loaded
-      unless self.class.const_defined?(:Mysql)
+      unless defined? Mysql
         begin
           require_library_or_gem 'mysql'
-          # The C version of mysql returns null fields in each_hash if Mysql::VERSION is defined
-          ConnectionAdapters::MysqlAdapter.null_values_in_each_hash = Mysql.const_defined?(:VERSION)
         rescue LoadError => cannot_require_mysql
           # Only use the supplied backup Ruby/MySQL driver if no driver is already in place
           begin
             require 'active_record/vendor/mysql'
-            require 'active_record/vendor/mysql411'
-            # The ruby version of mysql returns null fields in each_hash
-            ConnectionAdapters::MysqlAdapter.null_values_in_each_hash = true
           rescue LoadError
             raise cannot_require_mysql
           end
         end
       end
-      
+
 
       config = config.symbolize_keys
       host     = config[:host]
@@ -39,7 +34,17 @@ module ActiveRecord
 
       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])
+      if config[:encoding]
+        begin
+          mysql.options(Mysql::SET_CHARSET_NAME, config[:encoding])
+        rescue
+          raise ActiveRecord::ConnectionFailed, 'The :encoding option is only available for MySQL 4.1 and later with the mysql-ruby driver.  Again, this does not work with the ruby-mysql driver or MySQL < 4.1.'
+        end
+      end
+
+      conn = mysql.real_connect(host, username, password, database, port, socket)
+      conn.query("SET NAMES '#{config[:encoding]}'") if config[:encoding]
+      ConnectionAdapters::MysqlAdapter.new(conn, logger, [host, username, password, database, port, socket], mysql)
     end
   end
 
@@ -78,9 +83,6 @@ module ActiveRecord
       @@emulate_booleans = true
       cattr_accessor :emulate_booleans
 
-      cattr_accessor :null_values_in_each_hash
-      @@null_values_in_each_hash = false
-
       LOST_CONNECTION_ERROR_MESSAGES = [
         "Server shutdown in progress",
         "Broken pipe",
@@ -88,9 +90,11 @@ module ActiveRecord
         "MySQL server has gone away"
       ]
 
-      def initialize(connection, logger, connection_options=nil)
+      def initialize(connection, logger, connection_options=nil, mysql=Mysql)
         super(connection, logger)
         @connection_options = connection_options
+        @null_values_in_each_hash = Mysql.const_defined?(:VERSION)
+        @mysql = mysql
       end
 
       def adapter_name #:nodoc:
@@ -120,12 +124,21 @@ module ActiveRecord
 
       # QUOTING ==================================================
 
+      def quote(value, column = nil)
+        if value.kind_of?(String) && column && column.type == :binary
+          s = column.class.string_to_binary(value).unpack("H*")[0]
+          "x'#{s}'"
+        else
+          super
+        end
+      end
+
       def quote_column_name(name) #:nodoc:
         "`#{name}`"
       end
 
       def quote_string(string) #:nodoc:
-        Mysql::quote(string)
+        @mysql.quote(string)
       end
 
       def quoted_true
@@ -137,6 +150,31 @@ module ActiveRecord
       end
 
 
+      # CONNECTION MANAGEMENT ====================================
+
+      def active?
+        if @connection.respond_to?(:stat)
+          @connection.stat
+        else
+          @connection.query 'select 1'
+        end
+
+        # mysql-ruby doesn't raise an exception when stat fails.
+        if @connection.respond_to?(:errno)
+          @connection.errno.zero?
+        else
+          true
+        end
+      rescue Mysql::Error
+        false
+      end
+
+      def reconnect!
+        @connection.close rescue nil
+        connect
+      end
+
+
       # DATABASE STATEMENTS ======================================
 
       def select_all(sql, name = nil) #:nodoc:
@@ -149,22 +187,10 @@ module ActiveRecord
       end
 
       def execute(sql, name = nil, retries = 2) #:nodoc:
-        unless @logger
-          @connection.query(sql)
-        else
-          log(sql, name) { @connection.query(sql) }
-        end
+        log(sql, name) { @connection.query(sql) }
       rescue ActiveRecord::StatementInvalid => exception
-        if LOST_CONNECTION_ERROR_MESSAGES.any? { |msg| exception.message.split(":").first =~ /^#{msg}/ }
-          @connection.real_connect(*@connection_options)
-          unless @logger
-            @connection.query(sql)
-          else
-            @logger.info "Retrying invalid statement with reopened connection"
-            log(sql, name) { @connection.query(sql) }
-          end
-        elsif exception.message.split(":").first =~ /Packets out of order/
-          raise ActiveRecord::StatementInvalid, "'Packets out of order' error was received from the database. Please update your mysql bindings (gem update mysql) and read http://dev.mysql.com/doc/mysql/en/password-hashing.html for more information."
+        if exception.message.split(":").first =~ /Packets out of order/
+          raise ActiveRecord::StatementInvalid, "'Packets out of order' error was received from the database. Please update your mysql bindings (gem install mysql) and read http://dev.mysql.com/doc/mysql/en/password-hashing.html for more information.  If you're on Windows, use the Instant Rails installer to get the updated mysql bindings."
         else
           raise
         end
@@ -292,11 +318,24 @@ module ActiveRecord
 
 
       private
+        def connect
+          encoding = @config[:encoding]
+          if encoding
+            begin
+              @connection.options(Mysql::SET_CHARSET_NAME, encoding)
+            rescue
+              raise ActiveRecord::ConnectionFailed, 'The :encoding option is only available for MySQL 4.1 and later with the mysql-ruby driver.  Again, this does not work with the ruby-mysql driver or MySQL < 4.1.'
+            end
+          end
+          @connection.real_connect(*@connection_options)
+          execute("SET NAMES '#{encoding}'") if encoding
+        end
+
         def select(sql, name = nil)
           @connection.query_with_result = true
           result = execute(sql, name)
           rows = []
-          if @@null_values_in_each_hash
+          if @null_values_in_each_hash
             result.each_hash { |row| rows << row }
           else
             all_fields = result.fetch_fields.inject({}) { |fields, f| fields[f.name] = nil; fields }

data/lib/active_record/connection_adapters/oci_adapter.rb

@@ -23,6 +23,7 @@
 # portions Copyright 2005 Graham Jenkins
 
 require 'active_record/connection_adapters/abstract_adapter'
+require 'delegate'
 
 begin
   require_library_or_gem 'oci8' unless self.class.const_defined? :OCI8
@@ -30,11 +31,8 @@ begin
   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
+        # Use OCI8AutoRecover instead of normal OCI8 driver.
+        ConnectionAdapters::OCIAdapter.new OCI8AutoRecover.new(config), logger
       end
 
       # Enable the id column to be bound into the sql later, by the adapter's insert method.
@@ -110,6 +108,7 @@ begin
 
         def cast_to_date_or_time(value)
           return value if value.is_a? Date
+          return nil if value.blank?
           guess_date_or_time (value.is_a? Time) ? value : cast_to_time(value)
         end
 
@@ -117,7 +116,7 @@ begin
           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
+          Time.send(Base.default_timezone, *time_array) rescue nil
         end
 
         def guess_date_or_time(value)
@@ -212,6 +211,27 @@ begin
         end
 
 
+        # CONNECTION MANAGEMENT ====================================#
+
+        # Returns true if the connection is active.
+        def active?
+          # Pings the connection to check if it's still good. Note that an
+          # #active? method is also available, but that simply returns the 
+          # last known state, which isn't good enough if the connection has
+          # gone stale since the last use.
+          @connection.ping
+        rescue OCIError
+          false
+        end
+
+        # Reconnects to the database.
+        def reconnect!
+          @connection.reset!
+        rescue OCIError => e
+          @logger.warn "#{adapter_name} automatic reconnection failed: #{e.message}"
+        end
+
+
         # DATABASE STATEMENTS ======================================
         #
         # see: abstract/database_statements.rb
@@ -312,20 +332,31 @@ begin
         end
 
         def columns(table_name, name = nil) #:nodoc:
-          select_all(%Q{
-              select column_name, data_type, data_default, nullable,
-                     case when data_type = 'NUMBER' then data_precision
-                          when data_type = 'VARCHAR2' then data_length 
-                          else null end as length,
-                     case when data_type = 'NUMBER' then data_scale
-                          else null end as scale
-              from user_catalog cat, user_synonyms syn, all_tab_columns col
-              where cat.table_name = '#{table_name.to_s.upcase}'
-              and syn.synonym_name (+)= cat.table_name
-              and col.owner = nvl(syn.table_owner, user)
-              and col.table_name = nvl(syn.table_name, cat.table_name)}
-          ).map do |row|
-            row['data_default'].gsub!(/^'(.*)'$/, '\1') if row['data_default']
+          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_cols = %Q{
+            select column_name, data_type, data_default, nullable,
+                   decode(data_type, 'NUMBER', data_precision,
+                                     '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
+
+          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']), 
               row['data_default'],
@@ -472,10 +503,99 @@ begin
         when 187  : @stmt.defineByPos(i, OraDate) # Read TIMESTAMP values
         else define_a_column_pre_ar i
         end
-    	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
+      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
+      conn
+    end
+  end
+
+
+  # The OCI8AutoRecover class enhances the OCI8 driver with auto-recover and
+  # reset functionality. If a call to #exec fails, and autocommit is turned on
+  # (ie., we're not in the middle of a longer transaction), it will 
+  # automatically reconnect and try again. If autocommit is turned off,
+  # this would be dangerous (as the earlier part of the implied transaction
+  # may have failed silently if the connection died) -- so instead the 
+  # connection is marked as dead, to be reconnected on it's next use.
+  class OCI8AutoRecover < DelegateClass(OCI8) #:nodoc:
+    attr_accessor :active
+    alias :active? :active
+
+    cattr_accessor :auto_retry
+    class << self
+      alias :auto_retry? :auto_retry
+    end
+    @@auto_retry = false
+
+    def initialize(config, factory = OCIConnectionFactory.new)
+      @active = true
+      @username, @password, @host = config[:username], config[:password], config[:host]
+      @factory = factory
+      @connection  = @factory.new_connection @username, @password, @host
+      super @connection
+    end
+
+    # Checks connection, returns true if active. Note that ping actively
+    # checks the connection, while #active? simply returns the last
+    # known state.
+    def ping
+      @connection.commit
+      @active = true
+    rescue
+      @active = false
+      raise
+    end
+
+    # Resets connection, by logging off and creating a new connection.
+    def reset!
+      logoff rescue nil
+      begin
+        @connection = @factory.new_connection @username, @password, @host
+        __setobj__ @connection
+        @active = true
+      rescue
+        @active = false
+        raise
+      end
+    end
+
+    # ORA-00028: your session has been killed
+    # ORA-01012: not logged on 
+    # ORA-03113: end-of-file on communication channel
+    # ORA-03114: not connected to ORACLE
+    LOST_CONNECTION_ERROR_CODES = [ 28, 1012, 3113, 3114 ]
+
+    # Adds auto-recovery functionality.
+    #
+    # See: http://www.jiubao.org/ruby-oci8/api.en.html#label-11
+    def exec(sql, *bindvars)
+      should_retry = self.class.auto_retry? && autocommit?
+
+      begin
+        @connection.exec(sql, *bindvars)
+      rescue OCIError => e
+        raise unless LOST_CONNECTION_ERROR_CODES.include?(e.code)
+        @active = false
+        raise unless should_retry
+        should_retry = false
+        reset! rescue nil
+        retry
+      end
+    end
+
+  end
+
 rescue LoadError
   # OCI8 driver is unavailable.
 end

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -12,7 +12,6 @@ module ActiveRecord
       username = config[:username].to_s
       password = config[:password].to_s
 
-      encoding = config[:encoding]
       min_messages = config[:min_messages]
 
       if config.has_key?(:database)
@@ -22,12 +21,10 @@ module ActiveRecord
       end
 
       pga = ConnectionAdapters::PostgreSQLAdapter.new(
-        PGconn.connect(host, port, "", "", database, username, password), logger
+        PGconn.connect(host, port, "", "", database, username, password), logger, config
       )
 
       pga.schema_search_path = config[:schema_search_path] || config[:schema_order]
-      pga.execute("SET client_encoding TO '#{encoding}'") if encoding
-      pga.execute("SET client_min_messages TO '#{min_messages}'") if min_messages
 
       pga
     end
@@ -52,6 +49,33 @@ module ActiveRecord
         'PostgreSQL'
       end
 
+      def initialize(connection, logger, config = {})
+        super(connection, logger)
+        @config = config
+        configure_connection
+      end
+
+      # Is this connection alive and ready for queries?
+      def active?
+        if @connection.respond_to?(:status)
+          @connection.status == PGconn::CONNECTION_OK
+        else
+          @connection.query 'SELECT 1'
+          true
+        end
+      rescue PGError
+        false
+      end
+
+      # Close then reopen the connection.
+      def reconnect!
+        # TODO: postgres-pr doesn't have PGconn#reset.
+        if @connection.respond_to?(:reset)
+          @connection.reset
+          configure_connection
+        end
+      end
+
       def native_database_types
         {
           :primary_key => "serial primary key",
@@ -102,7 +126,7 @@ module ActiveRecord
       def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
         execute(sql, name)
         table = sql.split(" ", 4)[2]
-        id_value || last_insert_id(table, sequence_name)
+        id_value || last_insert_id(table, sequence_name || default_sequence_name(table, pk))
       end
 
       def query(sql, name = nil) #:nodoc:
@@ -199,24 +223,35 @@ module ActiveRecord
         @schema_search_path ||= query('SHOW search_path')[0][0]
       end
 
-      def default_sequence_name(table_name, pk = 'id')
-        "#{table_name}_#{pk}_seq"
+      def default_sequence_name(table_name, pk = nil)
+        default_pk, default_seq = pk_and_sequence_for(table_name)
+        default_seq || "#{table_name}_#{pk || default_pk || 'id'}_seq"
       end
 
-      # Set the sequence to the max value of the table's pk.
-      def reset_pk_sequence!(table)
-        pk, sequence = pk_and_sequence_for(table)
-        if pk and sequence
-          select_value <<-end_sql, 'Reset sequence'
-            SELECT setval('#{sequence}', (SELECT COALESCE(MAX(#{pk})+(SELECT increment_by FROM #{sequence}), (SELECT min_value FROM #{sequence})) FROM #{table}), false)
-          end_sql
+      # Resets sequence to the max value of the table's pk if present.
+      def reset_pk_sequence!(table, pk = nil, sequence = nil)
+        unless pk and sequence
+          default_pk, default_sequence = pk_and_sequence_for(table)
+          pk ||= default_pk
+          sequence ||= default_sequence
+        end
+        if pk
+          if sequence
+            select_value <<-end_sql, 'Reset sequence'
+              SELECT setval('#{sequence}', (SELECT COALESCE(MAX(#{pk})+(SELECT increment_by FROM #{sequence}), (SELECT min_value FROM #{sequence})) FROM #{table}), false)
+            end_sql
+          else
+            @logger.warn "#{table} has primary key #{pk} with no default sequence" if @logger
+          end
         end
       end
 
       # Find a table's primary key and sequence.
       def pk_and_sequence_for(table)
-        execute(<<-end_sql, 'Find pk sequence')[0]
-          SELECT attr.attname, (name.nspname || '.' || seq.relname)
+        # First try looking for a sequence with a dependency on the
+        # given table's primary key.
+        result = execute(<<-end_sql, 'PK and serial sequence')[0]
+          SELECT attr.attname, name.nspname, seq.relname
           FROM pg_class      seq,
                pg_attribute  attr,
                pg_depend     dep,
@@ -232,11 +267,30 @@ module ActiveRecord
             AND cons.contype      = 'p'
             AND dep.refobjid      = '#{table}'::regclass
         end_sql
+
+        if result.nil? or result.empty?
+          # If that fails, try parsing the primary key's default value.
+          # Support the 7.x and 8.0 nextval('foo'::text) as well as
+          # the 8.1+ nextval('foo'::regclass).
+          # TODO: assumes sequence is in same schema as table.
+          result = execute(<<-end_sql, 'PK and custom sequence')[0]
+            SELECT attr.attname, name.nspname, split_part(def.adsrc, '\\\'', 2)
+            FROM pg_class       t
+            JOIN pg_namespace   name ON (t.relnamespace = name.oid)
+            JOIN pg_attribute   attr ON (t.oid = attrelid)
+            JOIN pg_attrdef     def  ON (adrelid = attrelid AND adnum = attnum)
+            JOIN pg_constraint  cons ON (conrelid = adrelid AND adnum = conkey[1])
+            WHERE t.oid = '#{table}'::regclass
+              AND cons.contype = 'p'
+              AND def.adsrc ~* 'nextval'
+          end_sql
+        end
+        # check for existence of . in sequence name as in public.foo_sequence.  if it does not exist, join the current namespace
+        result.last['.'] ? [result.first, result.last] : [result.first, "#{result[1]}.#{result[2]}"]
       rescue
         nil
       end
 
-      
       def rename_table(name, new_name)
         execute "ALTER TABLE #{name} RENAME TO #{new_name}"
       end
@@ -276,16 +330,23 @@ module ActiveRecord
         execute "DROP INDEX #{index_name}"
       end      
 
-      
+
       private
         BYTEA_COLUMN_TYPE_OID = 17
 
-        def last_insert_id(table, sequence_name)
-          if sequence_name
-            @connection.exec("SELECT currval('#{sequence_name}')")[0][0].to_i
+        def configure_connection
+          if @config[:encoding]
+            execute("SET client_encoding TO '#{@config[:encoding]}'")
+          end
+          if @config[:min_messages]
+            execute("SET client_min_messages TO '#{@config[:min_messages]}'")
           end
         end
 
+        def last_insert_id(table, sequence_name)
+          Integer(select_value("SELECT currval('#{sequence_name}')"))
+        end
+
         def select(sql, name = nil)
           res = execute(sql, name)
           results = res.result