activerecord 1.14.4 → 1.15.0

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -8,7 +8,7 @@ module ActiveRecord
 
       config = config.symbolize_keys
       host     = config[:host]
-      port     = config[:port]     || 5432 unless host.nil?
+      port     = config[:port] || 5432
       username = config[:username].to_s
       password = config[:password].to_s
 
@@ -46,6 +46,7 @@ module ActiveRecord
     # * <tt>:schema_search_path</tt> -- An optional schema search path for the connection given as a string of comma-separated schema names.  This is backward-compatible with the :schema_order option.
     # * <tt>:encoding</tt> -- An optional client encoding that is using in a SET client_encoding TO <encoding> call on connection.
     # * <tt>:min_messages</tt> -- An optional client min messages that is using in a SET client_min_messages TO <min_messages> call on connection.
+    # * <tt>:allow_concurrency</tt> -- If true, use async query methods so Ruby threads don't deadlock; otherwise, use blocking query methods.
     class PostgreSQLAdapter < AbstractAdapter
       def adapter_name
         'PostgreSQL'
@@ -54,6 +55,7 @@ module ActiveRecord
       def initialize(connection, logger, config = {})
         super(connection, logger)
         @config = config
+        @async = config[:allow_concurrency]
         configure_connection
       end
 
@@ -67,7 +69,7 @@ module ActiveRecord
         end
       # postgres-pr raises a NoMethodError when querying if no conn is available
       rescue PGError, NoMethodError
-        false      
+        false
       end
 
       # Close then reopen the connection.
@@ -78,7 +80,7 @@ module ActiveRecord
           configure_connection
         end
       end
-      
+
       def disconnect!
         # Both postgres and postgres-pr respond to :close
         @connection.close rescue nil
@@ -91,6 +93,7 @@ module ActiveRecord
           :text        => { :name => "text" },
           :integer     => { :name => "integer" },
           :float       => { :name => "float" },
+          :decimal     => { :name => "decimal" },
           :datetime    => { :name => "timestamp" },
           :timestamp   => { :name => "timestamp" },
           :time        => { :name => "time" },
@@ -99,11 +102,11 @@ module ActiveRecord
           :boolean     => { :name => "boolean" }
         }
       end
-      
+
       def supports_migrations?
         true
-      end      
-      
+      end
+
       def table_alias_length
         63
       end
@@ -122,17 +125,12 @@ module ActiveRecord
         %("#{name}")
       end
 
-
-      # DATABASE STATEMENTS ======================================
-
-      def select_all(sql, name = nil) #:nodoc:
-        select(sql, name)
+      def quoted_date(value)
+        value.strftime("%Y-%m-%d %H:%M:%S.#{sprintf("%06d", value.usec)}")
       end
 
-      def select_one(sql, name = nil) #:nodoc:
-        result = select(sql, name)
-        result.first if result
-      end
+
+      # DATABASE STATEMENTS ======================================
 
       def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
         execute(sql, name)
@@ -141,20 +139,29 @@ module ActiveRecord
       end
 
       def query(sql, name = nil) #:nodoc:
-        log(sql, name) { @connection.query(sql) }
+        log(sql, name) do
+          if @async
+            @connection.async_query(sql)
+          else
+            @connection.query(sql)
+          end
+        end
       end
 
       def execute(sql, name = nil) #:nodoc:
-        log(sql, name) { @connection.exec(sql) }
+        log(sql, name) do
+          if @async
+            @connection.async_exec(sql)
+          else
+            @connection.exec(sql)
+          end
+        end
       end
 
       def update(sql, name = nil) #:nodoc:
         execute(sql, name).cmdtuples
       end
 
-      alias_method :delete, :update #:nodoc:
-
-
       def begin_db_transaction #:nodoc:
         execute "BEGIN"
       end
@@ -162,12 +169,11 @@ module ActiveRecord
       def commit_db_transaction #:nodoc:
         execute "COMMIT"
       end
-      
+
       def rollback_db_transaction #:nodoc:
         execute "ROLLBACK"
       end
 
-
       # SCHEMA STATEMENTS ========================================
 
       # Return the list of all tables in the schema search path.
@@ -214,9 +220,9 @@ module ActiveRecord
       end
 
       def columns(table_name, name = nil) #:nodoc:
-        column_definitions(table_name).collect do |name, type, default, notnull|
-          Column.new(name, default_value(default), translate_field_type(type),
-            notnull == "f")
+        column_definitions(table_name).collect do |name, type, default, notnull, typmod|
+          # typmod now unused as limit, precision, scale all handled by superclass
+          Column.new(name, default_value(default), translate_field_type(type), notnull == "f")
         end
       end
 
@@ -261,7 +267,7 @@ module ActiveRecord
       def pk_and_sequence_for(table)
         # 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]
+        result = query(<<-end_sql, 'PK and serial sequence')[0]
           SELECT attr.attname, name.nspname, seq.relname
           FROM pg_class      seq,
                pg_attribute  attr,
@@ -284,8 +290,8 @@ module ActiveRecord
           # 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)
+          result = query(<<-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)
@@ -296,8 +302,9 @@ module ActiveRecord
               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]}"]
+        # check for existence of . in sequence name as in public.foo_sequence.  if it does not exist, return unqualified sequence
+        # We cannot qualify unqualified sequences, as rails doesn't qualify any table access, using the search path
+        [result.first, result.last]
       rescue
         nil
       end
@@ -305,42 +312,107 @@ module ActiveRecord
       def rename_table(name, new_name)
         execute "ALTER TABLE #{name} RENAME TO #{new_name}"
       end
-            
+
       def add_column(table_name, column_name, type, options = {})
-        execute("ALTER TABLE #{table_name} ADD #{column_name} #{type_to_sql(type, options[:limit])}")
-        execute("ALTER TABLE #{table_name} ALTER #{column_name} SET NOT NULL") if options[:null] == false
-        change_column_default(table_name, column_name, options[:default]) unless options[:default].nil?
+        default = options[:default]
+        notnull = options[:null] == false
+
+        # Add the column.
+        execute("ALTER TABLE #{table_name} ADD COLUMN #{column_name} #{type_to_sql(type, options[:limit])}")
+
+        # Set optional default. If not null, update nulls to the new default.
+        if options_include_default?(options)
+          change_column_default(table_name, column_name, default)
+          if notnull
+            execute("UPDATE #{table_name} SET #{column_name}=#{quote(default, options[:column])} WHERE #{column_name} IS NULL")
+          end
+        end
+
+        if notnull
+          execute("ALTER TABLE #{table_name} ALTER #{column_name} SET NOT NULL")
+        end
       end
 
       def change_column(table_name, column_name, type, options = {}) #:nodoc:
         begin
-          execute "ALTER TABLE #{table_name} ALTER  #{column_name} TYPE #{type_to_sql(type, options[:limit])}"
+          execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} TYPE #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
         rescue ActiveRecord::StatementInvalid
           # This is PG7, so we use a more arcane way of doing it.
           begin_db_transaction
           add_column(table_name, "#{column_name}_ar_tmp", type, options)
-          execute "UPDATE #{table_name} SET #{column_name}_ar_tmp = CAST(#{column_name} AS #{type_to_sql(type, options[:limit])})"
+          execute "UPDATE #{table_name} SET #{column_name}_ar_tmp = CAST(#{column_name} AS #{type_to_sql(type, options[:limit], options[:precision], options[:scale])})"
           remove_column(table_name, column_name)
           rename_column(table_name, "#{column_name}_ar_tmp", column_name)
           commit_db_transaction
         end
-        change_column_default(table_name, column_name, options[:default]) unless options[:default].nil?
-      end      
+
+        if options_include_default?(options)
+          change_column_default(table_name, column_name, options[:default])
+        end
+      end
 
       def change_column_default(table_name, column_name, default) #:nodoc:
-        execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET DEFAULT '#{default}'"
+        execute "ALTER TABLE #{table_name} ALTER COLUMN #{quote_column_name(column_name)} SET DEFAULT #{quote(default)}"
       end
-      
+
       def rename_column(table_name, column_name, new_column_name) #:nodoc:
-        execute "ALTER TABLE #{table_name} RENAME COLUMN #{column_name} TO #{new_column_name}"
+        execute "ALTER TABLE #{table_name} RENAME COLUMN #{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
       end
 
       def remove_index(table_name, options) #:nodoc:
         execute "DROP INDEX #{index_name(table_name, options)}"
       end
 
+      def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
+        return super unless type.to_s == 'integer'
+
+        if limit.nil? || limit == 4
+          'integer'
+        elsif limit < 4
+          'smallint'
+        else
+          'bigint'
+        end
+      end
+      
+      # SELECT DISTINCT clause for a given set of columns and a given ORDER BY clause.
+      #
+      # PostgreSQL requires the ORDER BY columns in the select list for distinct queries, and
+      # requires that the ORDER BY include the distinct column.
+      #
+      #   distinct("posts.id", "posts.created_at desc")
+      def distinct(columns, order_by)
+        return "DISTINCT #{columns}" if order_by.blank?
+
+        # construct a clean list of column names from the ORDER BY clause, removing
+        # any asc/desc modifiers
+        order_columns = order_by.split(',').collect { |s| s.split.first }
+        order_columns.delete_if &:blank?
+        order_columns = order_columns.zip((0...order_columns.size).to_a).map { |s,i| "#{s} AS alias_#{i}" }
+
+        # return a DISTINCT ON() clause that's distinct on the columns we want but includes
+        # all the required columns for the ORDER BY to work properly
+        sql = "DISTINCT ON (#{columns}) #{columns}, "
+        sql << order_columns * ', '
+      end
+      
+      # 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 as a sub-select and ordering in that query.
+      def add_order_by_for_association_limiting!(sql, options)
+        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
+
       private
         BYTEA_COLUMN_TYPE_OID = 17
+        NUMERIC_COLUMN_TYPE_OID = 1700
         TIMESTAMPOID = 1114
         TIMESTAMPTZOID = 1184
 
@@ -367,12 +439,14 @@ module ActiveRecord
               hashed_row = {}
               row.each_index do |cel_index|
                 column = row[cel_index]
-                
+
                 case res.type(cel_index)
                   when BYTEA_COLUMN_TYPE_OID
                     column = unescape_bytea(column)
                   when TIMESTAMPTZOID, TIMESTAMPOID
                     column = cast_to_time(column)
+                  when NUMERIC_COLUMN_TYPE_OID
+                    column = column.to_d if column.respond_to?(:to_d)
                 end
 
                 hashed_row[fields[cel_index]] = column
@@ -380,6 +454,7 @@ module ActiveRecord
               rows << hashed_row
             end
           end
+          res.clear
           return rows
         end
 
@@ -430,7 +505,7 @@ module ActiveRecord
           end
           unescape_bytea(s)
         end
-        
+
         # Query a table's column names, default values, and types.
         #
         # The underlying query is roughly:
@@ -466,11 +541,13 @@ module ActiveRecord
         def translate_field_type(field_type)
           # Match the beginning of field_type since it may have a size constraint on the end.
           case field_type
+            # PostgreSQL array data types.
+            when /\[\]$/i  then 'string'
             when /^timestamp/i    then 'datetime'
             when /^real|^money/i  then 'float'
             when /^interval/i     then 'string'
             # geometric types (the line type is currently not implemented in postgresql)
-            when /^(?:point|lseg|box|"?path"?|polygon|circle)/i  then 'string' 
+            when /^(?:point|lseg|box|"?path"?|polygon|circle)/i  then 'string'
             when /^bytea/i        then 'binary'
             else field_type       # Pass through standard types.
           end
@@ -480,16 +557,16 @@ module ActiveRecord
           # Boolean types
           return "t" if value =~ /true/i
           return "f" if value =~ /false/i
-          
+
           # Char/String/Bytea type values
           return $1 if value =~ /^'(.*)'::(bpchar|text|character varying|bytea)$/
-          
+
           # Numeric values
           return value if value =~ /^-?[0-9]+(\.[0-9]*)?/
 
           # Fixed dates / times
           return $1 if value =~ /^'(.+)'::(date|timestamp)/
-          
+
           # Anything else is blank, some user type, or some function
           # and we can't know the value of that, so return nil.
           return nil
@@ -499,7 +576,7 @@ module ActiveRecord
         def cast_to_time(value)
           return value unless value.class == DateTime
           v = value
-          time_array = [v.year, v.month, v.day, v.hour, v.min, v.sec]
+          time_array = [v.year, v.month, v.day, v.hour, v.min, v.sec, v.usec]
           Time.send(Base.default_timezone, *time_array) rescue nil
         end
     end

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -19,6 +19,9 @@ module ActiveRecord
           :results_as_hash => true,
           :type_translation => false
         )
+
+        db.busy_timeout(config[:timeout]) unless config[:timeout].nil?
+
         ConnectionAdapters::SQLiteAdapter.new(db, logger)
       end
 
@@ -98,6 +101,10 @@ module ActiveRecord
       def supports_migrations? #:nodoc:
         true
       end
+
+      def requires_reloading?
+        true
+      end
       
       def supports_count_distinct? #:nodoc:
         false
@@ -110,6 +117,7 @@ module ActiveRecord
           :text        => { :name => "text" },
           :integer     => { :name => "integer" },
           :float       => { :name => "float" },
+          :decimal     => { :name => "decimal" },
           :datetime    => { :name => "datetime" },
           :timestamp   => { :name => "datetime" },
           :time        => { :name => "datetime" },
@@ -184,6 +192,12 @@ module ActiveRecord
       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:
@@ -217,13 +231,13 @@ module ActiveRecord
       end
       
       def rename_table(name, new_name)
-        move_table(name, new_name)
+        execute "ALTER TABLE #{name} RENAME TO #{new_name}"
       end
 
       def add_column(table_name, column_name, type, options = {}) #:nodoc:
-        alter_table(table_name) do |definition|
-          definition.column(column_name, type, options)
-        end
+        super(table_name, column_name, type, options)
+        # See last paragraph on http://www.sqlite.org/lang_altertable.html
+        execute "VACUUM"
       end
       
       def remove_column(table_name, column_name) #:nodoc:
@@ -240,10 +254,11 @@ module ActiveRecord
 
       def change_column(table_name, column_name, type, options = {}) #:nodoc:
         alter_table(table_name) do |definition|
+          include_default = options_include_default?(options)
           definition[column_name].instance_eval do
             self.type    = type
-            self.limit   = options[:limit] if options[:limit]
-            self.default = options[:default] if options[:default]
+            self.limit   = options[:limit] if options.include?(:limit)
+            self.default = options[:default] if include_default
           end
         end
       end
@@ -306,8 +321,9 @@ module ActiveRecord
             elsif from == "altered_#{to}"
               name = name[5..-1]
             end
-
-            opts = { :name => name }
+            
+            # index name can't be the same
+            opts = { :name => name.gsub(/_(#{from})_/, "_#{to}_") }
             opts[:unique] = true if index.unique
             add_index(to, index.columns, opts)
           end
@@ -316,9 +332,10 @@ module ActiveRecord
         def copy_table_contents(from, to, columns, rename = {}) #:nodoc:
           column_mappings = Hash[*columns.map {|name| [name, name]}.flatten]
           rename.inject(column_mappings) {|map, a| map[a.last] = a.first; map}
-          
+          from_columns = columns(from).collect {|col| col.name}
+          columns = columns.find_all{|col| from_columns.include?(column_mappings[col])}
           @connection.execute "SELECT * FROM #{from}" do |row|
-            sql = "INSERT INTO #{to} VALUES ("
+            sql = "INSERT INTO #{to} ("+columns*','+") VALUES ("            
             sql << columns.map {|col| quote row[column_mappings[col]]} * ', '
             sql << ')'
             @connection.execute sql
@@ -359,6 +376,17 @@ module ActiveRecord
           sql
         end
       end
+      
+      def rename_table(name, new_name)
+        move_table(name, new_name)
+      end
+      
+      def add_column(table_name, column_name, type, options = {}) #:nodoc:
+        alter_table(table_name) do |definition|
+          definition.column(column_name, type, options)
+        end
+      end
+      
     end
 
     class DeprecatedSQLiteAdapter < SQLite2Adapter # :nodoc: