activerecord 3.0.0.beta4 → 3.0.0.rc

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -216,7 +216,13 @@ module ActiveRecord
         super(connection, logger)
         @connection_parameters, @config = connection_parameters, config
 
+        # @local_tz is initialized as nil to avoid warnings when connect tries to use it
+        @local_tz = nil
+        @table_alias_length = nil
+        @postgresql_version = nil
+
         connect
+        @local_tz = execute('SHOW TIME ZONE').first["TimeZone"]
       end
 
       # Is this connection alive and ready for queries?
@@ -224,7 +230,7 @@ module ActiveRecord
         if @connection.respond_to?(:status)
           @connection.status == PGconn::CONNECTION_OK
         else
-          # We're asking the driver, not ActiveRecord, so use @connection.query instead of #query
+          # We're asking the driver, not Active Record, so use @connection.query instead of #query
           @connection.query 'SELECT 1'
           true
         end
@@ -258,7 +264,7 @@ module ActiveRecord
         true
       end
 
-      # Does PostgreSQL support finding primary key on non-ActiveRecord tables?
+      # Does PostgreSQL support finding primary key on non-Active Record tables?
       def supports_primary_key? #:nodoc:
         true
       end
@@ -305,14 +311,16 @@ module ActiveRecord
 
       # Quotes PostgreSQL-specific data types for SQL input.
       def quote(value, column = nil) #:nodoc:
-        if value.kind_of?(String) && column && column.type == :binary
+        return super unless column
+
+        if value.kind_of?(String) && column.type == :binary
           "'#{escape_bytea(value)}'"
-        elsif value.kind_of?(String) && column && column.sql_type == 'xml'
+        elsif value.kind_of?(String) && column.sql_type == 'xml'
           "xml '#{quote_string(value)}'"
-        elsif value.kind_of?(Numeric) && column && column.sql_type == 'money'
+        elsif value.kind_of?(Numeric) && column.sql_type == 'money'
           # Not truly string input, so doesn't require (or allow) escape string syntax.
-          "'#{value.to_s}'"
-        elsif value.kind_of?(String) && column && column.sql_type =~ /^bit/
+          "'#{value}'"
+        elsif value.kind_of?(String) && column.sql_type =~ /^bit/
           case value
             when /^[01]*$/
               "B'#{value}'" # Bit-string notation
@@ -367,12 +375,12 @@ module ActiveRecord
 
       def supports_disable_referential_integrity?() #:nodoc:
         version = query("SHOW server_version")[0][0].split('.')
-        (version[0].to_i >= 8 && version[1].to_i >= 1) ? true : false
+        version[0].to_i >= 8 && version[1].to_i >= 1
       rescue
         return false
       end
 
-      def disable_referential_integrity(&block) #:nodoc:
+      def disable_referential_integrity #:nodoc:
         if supports_disable_referential_integrity?() then
           execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} DISABLE TRIGGER ALL" }.join(";"))
         end
@@ -428,17 +436,37 @@ module ActiveRecord
       def result_as_array(res) #:nodoc:
         # check if we have any binary column and if they need escaping
         unescape_col = []
-        for j in 0...res.nfields do
-          # unescape string passed BYTEA field (OID == 17)
-          unescape_col << ( res.ftype(j)==17 )
+        res.nfields.times do |j|
+          unescape_col << res.ftype(j)
         end
 
         ary = []
-        for i in 0...res.ntuples do
+        res.ntuples.times do |i|
           ary << []
-          for j in 0...res.nfields do
+          res.nfields.times do |j|
             data = res.getvalue(i,j)
-            data = unescape_bytea(data) if unescape_col[j] and data.is_a?(String)
+            case unescape_col[j]
+
+            # unescape string passed BYTEA field (OID == 17)
+            when BYTEA_COLUMN_TYPE_OID
+              data = unescape_bytea(data) if String === data
+
+            # If this is a money type column and there are any currency symbols,
+            # then strip them off. Indeed it would be prettier to do this in
+            # PostgreSQLColumn.string_to_decimal but would break form input
+            # fields that call value_before_type_cast.
+            when MONEY_COLUMN_TYPE_OID
+              # Because money output is formatted according to the locale, there are two
+              # cases to consider (note the decimal separators):
+              #  (1) $12,345,678.12
+              #  (2) $12.345.678,12
+              case data
+              when /^-?\D+[\d,]+\.\d{2}$/  # (1)
+                data.gsub!(/[^-\d\.]/, '')
+              when /^-?\D+[\d\.]+,\d{2}$/  # (2)
+                data.gsub!(/[^-\d,]/, '').sub!(/,/, '.')
+              end
+            end
             ary[i] << data
           end
         end
@@ -606,27 +634,22 @@ module ActiveRecord
         SQL
 
 
-        indexes = []
-
-        indexes = result.map do |row|
+        result.map do |row|
           index_name = row[0]
           unique = row[1] == 't'
           indkey = row[2].split(" ")
           oid = row[3]
 
-          columns = query(<<-SQL, "Columns for index #{row[0]} on #{table_name}").inject({}) {|attlist, r| attlist[r[1]] = r[0]; attlist}
-          SELECT a.attname, a.attnum
+          columns = Hash[query(<<-SQL, "Columns for index #{row[0]} on #{table_name}")]
+          SELECT a.attnum, a.attname
           FROM pg_attribute a
           WHERE a.attrelid = #{oid}
           AND a.attnum IN (#{indkey.join(",")})
           SQL
 
-          column_names = indkey.map {|attnum| columns[attnum] }
-          IndexDefinition.new(table_name, index_name, unique, column_names)
-
-        end
-
-        indexes
+          column_names = columns.values_at(*indkey).compact
+          column_names.empty? ? nil : IndexDefinition.new(table_name, index_name, unique, column_names)
+        end.compact
       end
 
       # Returns the list of all column definitions for a table.
@@ -830,11 +853,12 @@ module ActiveRecord
       # Maps logical Rails types to PostgreSQL-specific data types.
       def type_to_sql(type, limit = nil, precision = nil, scale = nil)
         return super unless type.to_s == 'integer'
+        return 'integer' unless limit
 
         case limit
-          when 1..2;      'smallint'
-          when 3..4, nil; 'integer'
-          when 5..8;      'bigint'
+          when 1, 2; 'smallint'
+          when 3, 4; 'integer'
+          when 5..8; 'bigint'
           else raise(ActiveRecordError, "No integer type has byte size #{limit}. Use a numeric with precision 0 instead.")
         end
       end
@@ -891,6 +915,8 @@ module ActiveRecord
       private
         # The internal PostgreSQL identifier of the money data type.
         MONEY_COLUMN_TYPE_OID = 790 #:nodoc:
+        # The internal PostgreSQL identifier of the BYTEA data type.
+        BYTEA_COLUMN_TYPE_OID = 17 #:nodoc:
 
         # Connects to a PostgreSQL server and sets up the adapter depending on the
         # connected server's characteristics.
@@ -925,9 +951,13 @@ module ActiveRecord
           # Use standard-conforming strings if available so we don't have to do the E'...' dance.
           set_standard_conforming_strings
 
-          # If using ActiveRecord's time zone support configure the connection to return
+          # If using Active Record's time zone support configure the connection to return
           # TIMESTAMP WITH ZONE types in UTC.
-          execute("SET time zone 'UTC'") if ActiveRecord::Base.default_timezone == :utc
+          if ActiveRecord::Base.default_timezone == :utc
+            execute("SET time zone 'UTC'")
+          elsif @local_tz
+            execute("SET time zone '#{@local_tz}'")
+          end
         end
 
         # Returns the current ID of a table's sequence.
@@ -939,51 +969,17 @@ module ActiveRecord
         # conversions that are required to be performed here instead of in PostgreSQLColumn.
         def select(sql, name = nil)
           fields, rows = select_raw(sql, name)
-          result = []
-          for row in rows
-            row_hash = {}
-            fields.each_with_index do |f, i|
-              row_hash[f] = row[i]
-            end
-            result << row_hash
+          rows.map do |row|
+            Hash[*fields.zip(row).flatten]
           end
-          result
         end
 
         def select_raw(sql, name = nil)
           res = execute(sql, name)
           results = result_as_array(res)
-          fields = []
-          rows = []
-          if res.ntuples > 0
-            fields = res.fields
-            results.each do |row|
-              hashed_row = {}
-              row.each_index do |cell_index|
-                # If this is a money type column and there are any currency symbols,
-                # then strip them off. Indeed it would be prettier to do this in
-                # PostgreSQLColumn.string_to_decimal but would break form input
-                # fields that call value_before_type_cast.
-                if res.ftype(cell_index) == MONEY_COLUMN_TYPE_OID
-                  # Because money output is formatted according to the locale, there are two
-                  # cases to consider (note the decimal separators):
-                  #  (1) $12,345,678.12
-                  #  (2) $12.345.678,12
-                  case column = row[cell_index]
-                    when /^-?\D+[\d,]+\.\d{2}$/  # (1)
-                      row[cell_index] = column.gsub(/[^-\d\.]/, '')
-                    when /^-?\D+[\d\.]+,\d{2}$/  # (2)
-                      row[cell_index] = column.gsub(/[^-\d,]/, '').sub(/,/, '.')
-                  end
-                end
-
-                hashed_row[fields[cell_index]] = column
-              end
-              rows << row
-            end
-          end
+          fields = res.fields
           res.clear
-          return fields, rows
+          return fields, results
         end
 
         # Returns the list of a table's column names, data types, and default values.

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -4,7 +4,21 @@ module ActiveRecord
   class Base
     # sqlite3 adapter reuses sqlite_connection.
     def self.sqlite3_connection(config) # :nodoc:
-      parse_sqlite_config!(config)
+      # Require database.
+      unless config[:database]
+        raise ArgumentError, "No database file specified. Missing argument: database"
+      end
+
+      # Allow database path relative to Rails.root, but only if
+      # the database path is not the special path that tells
+      # Sqlite to build a database only in memory.
+      if defined?(Rails.root) && ':memory:' != config[:database]
+        config[:database] = File.expand_path(config[:database], Rails.root)
+      end
+
+      unless 'sqlite3' == config[:adapter]
+        raise ArgumentError, 'adapter name should be "sqlite3"'
+      end
 
       unless self.class.const_defined?(:SQLite3)
         require_library_or_gem(config[:adapter])
@@ -12,8 +26,7 @@ module ActiveRecord
 
       db = SQLite3::Database.new(
         config[:database],
-        :results_as_hash => true,
-        :type_translation => false
+        :results_as_hash => true
       )
 
       db.busy_timeout(config[:timeout]) unless config[:timeout].nil?
@@ -24,13 +37,13 @@ module ActiveRecord
 
   module ConnectionAdapters #:nodoc:
     class SQLite3Adapter < SQLiteAdapter # :nodoc:
-      
+
       # Returns the current database encoding format as a string, eg: 'UTF-8'
       def encoding
         if @connection.respond_to?(:encoding)
-          @connection.encoding[0]['encoding']
+          @connection.encoding.to_s
         else
-          encoding = @connection.send(:get_query_pragma, 'encoding')
+          encoding = @connection.execute('PRAGMA encoding')
           encoding[0]['encoding']
         end
       end

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -2,25 +2,6 @@ require 'active_record/connection_adapters/abstract_adapter'
 require 'active_support/core_ext/kernel/requires'
 
 module ActiveRecord
-  class Base
-    class << self
-      private
-        def parse_sqlite_config!(config)
-          # Require database.
-          unless config[:database]
-            raise ArgumentError, "No database file specified. Missing argument: database"
-          end
-
-          # Allow database path relative to Rails.root, but only if
-          # the database path is not the special path that tells
-          # Sqlite to build a database only in memory.
-          if defined?(Rails.root) && ':memory:' != config[:database]
-            config[:database] = File.expand_path(config[:database], Rails.root)
-          end
-        end
-    end
-  end
-
   module ConnectionAdapters #:nodoc:
     class SQLiteColumn < Column #:nodoc:
       class <<  self
@@ -151,7 +132,7 @@ module ActiveRecord
       # DATABASE STATEMENTS ======================================
 
       def execute(sql, name = nil) #:nodoc:
-        catch_schema_changes { log(sql, name) { @connection.execute(sql) } }
+        log(sql, name) { @connection.execute(sql) }
       end
 
       def update_sql(sql, name = nil) #:nodoc:
@@ -176,15 +157,15 @@ module ActiveRecord
       end
 
       def begin_db_transaction #:nodoc:
-        catch_schema_changes { @connection.transaction }
+        @connection.transaction
       end
 
       def commit_db_transaction #:nodoc:
-        catch_schema_changes { @connection.commit }
+        @connection.commit
       end
 
       def rollback_db_transaction #:nodoc:
-        catch_schema_changes { @connection.rollback }
+        @connection.rollback
       end
 
       # SCHEMA STATEMENTS ========================================
@@ -209,16 +190,21 @@ module ActiveRecord
 
       def indexes(table_name, name = nil) #:nodoc:
         execute("PRAGMA index_list(#{quote_table_name(table_name)})", name).map do |row|
-          index = IndexDefinition.new(table_name, row['name'])
-          index.unique = row['unique'].to_i != 0
-          index.columns = execute("PRAGMA index_info('#{index.name}')").map { |col| col['name'] }
-          index
+          IndexDefinition.new(
+            table_name,
+            row['name'],
+            row['unique'].to_i != 0,
+            execute("PRAGMA index_info('#{row['name']}')").map { |col|
+              col['name']
+            })
         end
       end
 
       def primary_key(table_name) #:nodoc:
-        column = table_structure(table_name).find {|field| field['pk'].to_i == 1}
-        column ? column['name'] : nil
+        column = table_structure(table_name).find { |field|
+          field['pk'].to_i == 1
+        }
+        column && column['name']
       end
 
       def remove_index!(table_name, index_name) #:nodoc:
@@ -246,6 +232,7 @@ module ActiveRecord
       end
 
       def remove_column(table_name, *column_names) #:nodoc:
+        raise ArgumentError.new("You must specify at least one column name.  Example: remove_column(:people, :first_name)") if column_names.empty?
         column_names.flatten.each do |column_name|
           alter_table(table_name) do |definition|
             definition.columns.delete(definition[column_name])
@@ -296,10 +283,8 @@ module ActiveRecord
         def select(sql, name = nil) #:nodoc:
           execute(sql, name).map do |row|
             record = {}
-            row.each_key do |key|
-              if key.is_a?(String)
-                record[key.sub(/^"?\w+"?\./, '')] = row[key]
-              end
+            row.each do |key, value|
+              record[key.sub(/^"?\w+"?\./, '')] = value if key.is_a?(String)
             end
             record
           end
@@ -390,26 +375,15 @@ module ActiveRecord
           end
         end
 
-        def catch_schema_changes
-          return yield
-        rescue ActiveRecord::StatementInvalid => exception
-          if exception.message =~ /database schema has changed/
-            reconnect!
-            retry
-          else
-            raise
-          end
-        end
-
         def sqlite_version
           @sqlite_version ||= SQLiteAdapter::Version.new(select_value('select sqlite_version(*)'))
         end
 
         def default_primary_key_type
           if supports_autoincrement?
-            'INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL'.freeze
+            'INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL'
           else
-            'INTEGER PRIMARY KEY NOT NULL'.freeze
+            'INTEGER PRIMARY KEY NOT NULL'
           end
         end
 

data/lib/active_record/counter_cache.rb

@@ -1,4 +1,5 @@
 module ActiveRecord
+  # = Active Record Counter Cache
   module CounterCache
     # Resets one or more counter caches to their correct value using an SQL
     # count query.  This is useful when adding new counter caches, or if the
@@ -16,9 +17,18 @@ module ActiveRecord
     def reset_counters(id, *counters)
       object = find(id)
       counters.each do |association|
-        child_class = reflect_on_association(association.to_sym).klass
-        belongs_name = self.name.demodulize.underscore.to_sym
-        counter_name = child_class.reflect_on_association(belongs_name).counter_cache_column
+        has_many_association = reflect_on_association(association.to_sym)
+
+        expected_name = if has_many_association.options[:as]
+          has_many_association.options[:as].to_s.classify
+        else
+          self.name
+        end
+
+        child_class  = has_many_association.klass
+        belongs_to   = child_class.reflect_on_all_associations(:belongs_to)
+        reflection   = belongs_to.find { |e| e.class_name == expected_name }
+        counter_name = reflection.counter_cache_column
 
         self.unscoped.where(arel_table[self.primary_key].eq(object.id)).arel.update({
           arel_table[counter_name] => object.send(association).count
@@ -102,4 +112,4 @@ module ActiveRecord
       update_counters(id, counter_name => -1)
     end
   end
-end
+end