activerecord 2.3.18 → 3.0.0.beta

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -1,4 +1,5 @@
 require 'active_record/connection_adapters/abstract_adapter'
+require 'active_support/core_ext/kernel/requires'
 
 begin
   require_library_or_gem 'pg'
@@ -261,12 +262,20 @@ module ActiveRecord
         true
       end
 
-      # Enable standard-conforming strings if available.
-      def set_standard_conforming_strings
-        old, self.client_min_messages = client_min_messages, 'panic'
-        execute('SET standard_conforming_strings = on') rescue nil
-      ensure
-        self.client_min_messages = old
+      # Does PostgreSQL support standard conforming strings?
+      def supports_standard_conforming_strings?
+        # Temporarily set the client message level above error to prevent unintentional
+        # error messages in the logs when working on a PostgreSQL database server that
+        # does not support standard conforming strings.
+        client_min_messages_old = client_min_messages
+        self.client_min_messages = 'panic'
+
+        # postgres-pr does not raise an exception when client_min_messages is set higher
+        # than error and "SHOW standard_conforming_strings" fails, but returns an empty
+        # PGresult instead.
+        has_support = query('SHOW standard_conforming_strings')[0][0] rescue false
+        self.client_min_messages = client_min_messages_old
+        has_support
       end
 
       def supports_insert_with_returning?
@@ -290,7 +299,7 @@ module ActiveRecord
       # QUOTING ==================================================
 
       # Escapes binary strings for bytea input to the database.
-      def escape_bytea(original_value)
+      def escape_bytea(value)
         if @connection.respond_to?(:escape_bytea)
           self.class.instance_eval do
             define_method(:escape_bytea) do |value|
@@ -314,40 +323,62 @@ module ActiveRecord
             end
           end
         end
-        escape_bytea(original_value)
+        escape_bytea(value)
       end
 
       # Unescapes bytea output from a database to the binary string it represents.
       # NOTE: This is NOT an inverse of escape_bytea! This is only to be used
       #       on escaped binary output from database drive.
-      def unescape_bytea(original_value)
+      def unescape_bytea(value)
         # In each case, check if the value actually is escaped PostgreSQL bytea output
         # or an unescaped Active Record attribute that was just written.
-        if @connection.respond_to?(:unescape_bytea)
+        if PGconn.respond_to?(:unescape_bytea)
           self.class.instance_eval do
             define_method(:unescape_bytea) do |value|
-              @connection.unescape_bytea(value) if value
+              if value =~ /\\\d{3}/
+                PGconn.unescape_bytea(value)
+              else
+                value
+              end
             end
           end
-        elsif PGconn.respond_to?(:unescape_bytea)
+        else
           self.class.instance_eval do
             define_method(:unescape_bytea) do |value|
-              PGconn.unescape_bytea(value) if value
+              if value =~ /\\\d{3}/
+                result = ''
+                i, max = 0, value.size
+                while i < max
+                  char = value[i]
+                  if char == ?\\
+                    if value[i+1] == ?\\
+                      char = ?\\
+                      i += 1
+                    else
+                      char = value[i+1..i+3].oct
+                      i += 3
+                    end
+                  end
+                  result << char
+                  i += 1
+                end
+                result
+              else
+                value
+              end
             end
           end
-        else
-          raise 'Your PostgreSQL connection does not support unescape_bytea. Try upgrading to pg 0.9.0 or later.'
         end
-        unescape_bytea(original_value)
+        unescape_bytea(value)
       end
 
       # Quotes PostgreSQL-specific data types for SQL input.
       def quote(value, column = nil) #:nodoc:
         if value.kind_of?(String) && column && column.type == :binary
-          "'#{escape_bytea(value)}'"
-        elsif value.kind_of?(String) && column && column.sql_type == 'xml'
-          "xml '#{quote_string(value)}'"
-        elsif value.kind_of?(Numeric) && column && column.sql_type == 'money'
+          "#{quoted_string_prefix}'#{escape_bytea(value)}'"
+        elsif value.kind_of?(String) && column && column.sql_type =~ /^xml$/
+          "xml E'#{quote_string(value)}'"
+        elsif value.kind_of?(Numeric) && column && 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/
@@ -363,7 +394,7 @@ module ActiveRecord
       end
 
       # Quotes strings for use in SQL input in the postgres driver for better performance.
-      def quote_string(original_value) #:nodoc:
+      def quote_string(s) #:nodoc:
         if @connection.respond_to?(:escape)
           self.class.instance_eval do
             define_method(:quote_string) do |s|
@@ -383,7 +414,7 @@ module ActiveRecord
             remove_method(:quote_string)
           end
         end
-        quote_string(original_value)
+        quote_string(s)
       end
 
       # Checks the following cases:
@@ -479,6 +510,7 @@ module ActiveRecord
           end
         end
       end
+      alias :create :insert
 
       # create a 2D array representing the result set
       def result_as_array(res) #:nodoc:
@@ -859,12 +891,9 @@ module ActiveRecord
         execute "ALTER TABLE #{quote_table_name(table_name)} RENAME COLUMN #{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
       end
 
-      def remove_index!(table_name, index_name) #:nodoc:
-        execute "DROP INDEX #{quote_table_name(index_name)}"
-      end
-
-      def index_name_length
-        63
+      # Drops an index from a table.
+      def remove_index(table_name, options = {})
+        execute "DROP INDEX #{quote_table_name(index_name(table_name, options))}"
       end
 
       # Maps logical Rails types to PostgreSQL-specific data types.
@@ -900,20 +929,6 @@ module ActiveRecord
         sql << order_columns * ', '
       end
 
-      # Returns an ORDER BY clause for the passed order option.
-      #
-      # PostgreSQL does not allow arbitrary ordering when using DISTINCT ON, so we work around this
-      # by wrapping the +sql+ string as a sub-select and ordering in that query.
-      def add_order_by_for_association_limiting!(sql, options) #:nodoc:
-        return sql if options[:order].blank?
-
-        order = options[:order].split(',').collect { |s| s.strip }.reject(&:blank?)
-        order.map! { |s| 'DESC' if s =~ /\bdesc$/i }
-        order = order.zip((0...order.size).to_a).map { |s,i| "id_list.alias_#{i} #{s}" }.join(', ')
-
-        sql.replace "SELECT * FROM (#{sql}) AS id_list ORDER BY #{order}"
-      end
-
       protected
         # Returns the version of the connected PostgreSQL version.
         def postgresql_version
@@ -931,6 +946,17 @@ module ActiveRecord
             end
         end
 
+        def translate_exception(exception, message)
+          case exception.message
+          when /duplicate key value violates unique constraint/
+            RecordNotUnique.new(message, exception)
+          when /violates foreign key constraint/
+            InvalidForeignKey.new(message, exception)
+          else
+            super
+          end
+        end
+
       private
         # The internal PostgreSQL identifier of the money data type.
         MONEY_COLUMN_TYPE_OID = 790 #:nodoc:
@@ -944,6 +970,17 @@ module ActiveRecord
           # Ignore async_exec and async_query when using postgres-pr.
           @async = @config[:allow_concurrency] && @connection.respond_to?(:async_exec)
 
+          # Use escape string syntax if available. We cannot do this lazily when encountering
+          # the first string, because that could then break any transactions in progress.
+          # See: http://www.postgresql.org/docs/current/static/runtime-config-compatible.html
+          # If PostgreSQL doesn't know the standard_conforming_strings parameter then it doesn't
+          # support escape string syntax. Don't override the inherited quoted_string_prefix.
+          if supports_standard_conforming_strings?
+            self.class.instance_eval do
+              define_method(:quoted_string_prefix) { 'E' }
+            end
+          end
+
           # Money type has a fixed precision of 10 in PostgreSQL 8.2 and below, and as of
           # PostgreSQL 8.3 it has a fixed precision of 19. PostgreSQLColumn.extract_precision
           # should know about this but can't detect it there, so deal with it here.
@@ -961,7 +998,7 @@ module ActiveRecord
           configure_connection
         end
 
-        # Configures the encoding, verbosity, and schema search path of the connection.
+        # Configures the encoding, verbosity, schema search path, and time zone of the connection.
         # This is called by #connect and should not be called manually.
         def configure_connection
           if @config[:encoding]
@@ -973,9 +1010,10 @@ module ActiveRecord
           end
           self.client_min_messages = @config[:min_messages] if @config[:min_messages]
           self.schema_search_path = @config[:schema_search_path] || @config[:schema_order]
-
-          # 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
+          # TIMESTAMP WITH ZONE types in UTC.
+          execute("SET time zone 'UTC'") if ActiveRecord::Base.default_timezone == :utc
         end
 
         # Returns the current ID of a table's sequence.

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -24,11 +24,17 @@ module ActiveRecord
 
   module ConnectionAdapters #:nodoc:
     class SQLite3Adapter < SQLiteAdapter # :nodoc:
-      def table_structure(table_name)
-        @connection.table_info(quote_table_name(table_name)).tap do |structure|
-          raise(ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'") if structure.empty?
+      
+      # Returns the current database encoding format as a string, eg: 'UTF-8'
+      def encoding
+        if @connection.respond_to?(:encoding)
+          @connection.encoding[0]['encoding']
+        else
+          encoding = @connection.send(:get_query_pragma, 'encoding')
+          encoding[0]['encoding']
         end
       end
+
     end
   end
 end

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -1,51 +1,21 @@
-# encoding: binary
 require 'active_record/connection_adapters/abstract_adapter'
+require 'active_support/core_ext/kernel/requires'
 
 module ActiveRecord
   class Base
     class << self
-      # Establishes a connection to the database that's used by all Active Record objects
-      def sqlite_connection(config) # :nodoc:
-        parse_sqlite_config!(config)
-
-        unless self.class.const_defined?(:SQLite)
-          require_library_or_gem(config[:adapter])
-
-          db = SQLite::Database.new(config[:database], 0)
-          db.show_datatypes   = "ON" if !defined? SQLite::Version
-          db.results_as_hash  = true if defined? SQLite::Version
-          db.type_translation = false
-
-          message = "Support for SQLite2Adapter and DeprecatedSQLiteAdapter has been removed from Rails 3. "
-          message << "You should migrate to SQLite 3+ or use the plugin from git://github.com/rails/sqlite2_adapter.git with Rails 3."
-          ActiveSupport::Deprecation.warn(message)
-
-          # "Downgrade" deprecated sqlite API
-          if SQLite.const_defined?(:Version)
-            ConnectionAdapters::SQLite2Adapter.new(db, logger, config)
-          else
-            ConnectionAdapters::DeprecatedSQLiteAdapter.new(db, logger, config)
-          end
-        end
-      end
-
       private
         def parse_sqlite_config!(config)
-          if config.include?(:dbfile)
-            ActiveSupport::Deprecation.warn "Please update config/database.yml to use 'database' instead of 'dbfile'"
-          end
-
-          config[:database] ||= config[:dbfile]
           # 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
+          # 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 Object.const_defined?(:RAILS_ROOT) && ':memory:' != config[:database]
-            config[:database] = File.expand_path(config[:database], RAILS_ROOT)
+          if defined?(Rails.root) && ':memory:' != config[:database]
+            config[:database] = File.expand_path(config[:database], Rails.root)
           end
         end
     end
@@ -55,7 +25,6 @@ module ActiveRecord
     class SQLiteColumn < Column #:nodoc:
       class <<  self
         def string_to_binary(value)
-          value = value.dup.force_encoding(Encoding::BINARY) if value.respond_to?(:force_encoding)
           value.gsub(/\0|\%/n) do |b|
             case b
               when "\0" then "%00"
@@ -65,7 +34,6 @@ module ActiveRecord
         end
 
         def binary_to_string(value)
-          value = value.dup.force_encoding(Encoding::BINARY) if value.respond_to?(:force_encoding)
           value.gsub(/%00|%25/n) do |b|
             case b
               when "%00" then "\0"
@@ -123,7 +91,7 @@ module ActiveRecord
       def supports_add_column?
         sqlite_version >= '3.1.6'
       end
- 
+
       def disconnect!
         super
         @connection.close rescue nil
@@ -162,7 +130,17 @@ module ActiveRecord
       end
 
       def quote_column_name(name) #:nodoc:
-        %Q("#{name.to_s.gsub('"', '""')}")
+        %Q("#{name}")
+      end
+
+      # Quote date/time values for use in SQL input. Includes microseconds
+      # if the value is a Time responding to usec.
+      def quoted_date(value) #:nodoc:
+        if value.acts_like?(:time) && value.respond_to?(:usec)
+          "#{super}.#{sprintf("%06d", value.usec)}"
+        else
+          super
+        end
       end
 
 
@@ -185,6 +163,7 @@ module ActiveRecord
       def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
         super || @connection.last_insert_row_id
       end
+      alias :create :insert_sql
 
       def select_rows(sql, name = nil)
         execute(sql, name).map do |row|
@@ -204,12 +183,6 @@ module ActiveRecord
         catch_schema_changes { @connection.rollback }
       end
 
-      # SELECT ... FOR UPDATE is redundant since the table is locked.
-      def add_lock!(sql, options) #:nodoc:
-        sql
-      end
-
-
       # SCHEMA STATEMENTS ========================================
 
       def tables(name = nil) #:nodoc:
@@ -244,12 +217,12 @@ module ActiveRecord
         column ? column['name'] : nil
       end
 
-      def remove_index!(table_name, index_name) #:nodoc:
-        execute "DROP INDEX #{quote_column_name(index_name)}"
+      def remove_index(table_name, options={}) #:nodoc:
+        execute "DROP INDEX #{quote_column_name(index_name(table_name, options))}"
       end
 
       def rename_table(name, new_name)
-        execute "ALTER TABLE #{name} RENAME TO #{new_name}"
+        execute "ALTER TABLE #{quote_table_name(name)} RENAME TO #{quote_table_name(new_name)}"
       end
 
       # See: http://www.sqlite.org/lang_altertable.html
@@ -269,7 +242,6 @@ 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])
@@ -312,8 +284,8 @@ module ActiveRecord
         alter_table(table_name, :rename => {column_name.to_s => new_column_name.to_s})
       end
 
-      def empty_insert_statement(table_name)
-        "INSERT INTO #{table_name} VALUES(NULL)"
+      def empty_insert_statement_value
+        "VALUES(NULL)"
       end
 
       protected
@@ -330,9 +302,9 @@ module ActiveRecord
         end
 
         def table_structure(table_name)
-          execute("PRAGMA table_info(#{quote_table_name(table_name)})").tap do |structure|
-            raise(ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'") if structure.empty?
-          end
+          structure = @connection.table_info(quote_table_name(table_name))
+          raise(ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'") if structure.empty?
+          structure
         end
 
         def alter_table(table_name, options = {}) #:nodoc:
@@ -360,7 +332,7 @@ module ActiveRecord
                 (options[:rename][column.name] ||
                  options[:rename][column.name.to_sym] ||
                  column.name) : column.name
-              
+
               @definition.column(column_name, column.type,
                 :limit => column.limit, :default => column.default,
                 :null => column.null)
@@ -436,19 +408,16 @@ module ActiveRecord
             'INTEGER PRIMARY KEY NOT NULL'.freeze
           end
         end
-    end
 
-    class SQLite2Adapter < SQLiteAdapter # :nodoc:
-      def rename_table(name, new_name)
-        move_table(name, new_name)
-      end
-    end
+        def translate_exception(exception, message)
+          case exception.message
+          when /column(s)? .* (is|are) not unique/
+            RecordNotUnique.new(message, exception)
+          else
+            super
+          end
+        end
 
-    class DeprecatedSQLiteAdapter < SQLite2Adapter # :nodoc:
-      def insert(sql, name = nil, pk = nil, id_value = nil)
-        execute(sql, name = nil)
-        id_value || @connection.last_insert_rowid
-      end
     end
   end
 end