activerecord 1.10.1 → 1.11.0

data/lib/active_record/connection_adapters/db2_adapter.rb

@@ -52,8 +52,8 @@ begin
         def execute(sql, name = nil)
           rows_affected = 0
 
-          log(sql, name, @connection) do |connection| 
-            stmt = DB2::Statement.new(connection)
+          log(sql, name) do
+            stmt = DB2::Statement.new(@connection)
             stmt.exec_direct(sql)
             rows_affected = stmt.row_count
             stmt.free
@@ -79,14 +79,16 @@ begin
           @connection.set_auto_commit_on
         end
 
-        def quote_column_name(name) name; end
+        def quote_column_name(column_name)
+          column_name
+        end
 
         def adapter_name()
           'DB2'
         end
 
-        def quote_string(s)
-          s.gsub(/'/, "''") # ' (for ruby-mode)
+        def quote_string(string)
+          string.gsub(/'/, "''") # ' (for ruby-mode)
         end
 
         def add_limit_with_offset!(sql, limit, offset)
@@ -124,9 +126,9 @@ begin
 
         def select(sql, name = nil)
           stmt = nil
-          log(sql, name, @connection) do |connection|
-            stmt = DB2::Statement.new(connection)
-            stmt.exec_direct(sql + " with ur")
+          log(sql, name) do
+            stmt = DB2::Statement.new(@connection)
+            stmt.exec_direct("#{sql} with ur")
           end
 
           rows = []

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -1,6 +1,6 @@
 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.
@@ -11,7 +11,7 @@ module ActiveRecord
           require_library_or_gem 'mysql'
         rescue LoadError => cannot_require_mysql
           # Only use the supplied backup Ruby/MySQL driver if no driver is already in place
-          begin 
+          begin
             require 'active_record/vendor/mysql'
             require 'active_record/vendor/mysql411'
           rescue LoadError
@@ -19,27 +19,27 @@ 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
- 
+
       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
     # 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/).
@@ -57,12 +57,16 @@ module ActiveRecord
     # * <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 = [ 
+      LOST_CONNECTION_ERROR_MESSAGES = [
         "Server shutdown in progress",
-        "Broken pipe", 
-        "Lost connection to MySQL server during query", 
+        "Broken pipe",
+        "Lost connection to MySQL server during query",
         "MySQL server has gone away"
       ]
+      
+      def supports_migrations?
+        true
+      end
 
       def native_database_types
         {
@@ -84,86 +88,85 @@ module ActiveRecord
         super(connection, logger)
         @connection_options = connection_options
       end
- 
+
       def adapter_name
         'MySQL'
       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}" 
+        sql = "SHOW FIELDS FROM #{table_name}"
         columns = []
         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
+        id_value || @connection.insert_id
       end
- 
-      def execute(sql, name = nil)
-        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) }
+
+      def execute(sql, name = nil, retries = 2)
+        unless @logger
+          @connection.query(sql)
+        else
+          log(sql, name) { @connection.query(sql) }
+        end
+      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
-            raise
+            @logger.info "Retrying invalid statement with reopened connection"
+            log(sql, name) { @connection.query(sql) }
           end
+        else
+          raise
         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"
-        rescue Exception
-          # Transactions aren't supported
-        end
+        execute "BEGIN"
+      rescue Exception
+        # Transactions aren't supported
       end
- 
+
       def commit_db_transaction
-        begin
-          execute "COMMIT"
-        rescue Exception
-          # Transactions aren't supported
-        end
+        execute "COMMIT"
+      rescue Exception
+        # Transactions aren't supported
       end
- 
+
       def rollback_db_transaction
-        begin
-          execute "ROLLBACK"
-        rescue Exception
-          # Transactions aren't supported
-        end
+        execute "ROLLBACK"
+      rescue Exception
+        # Transactions aren't supported
       end
 
- 
+
       def quote_column_name(name)
-        return "`#{name}`"
+        "`#{name}`"
       end
- 
-      def quote_string(s)
-        Mysql::quote(s)
+
+      def quote_string(string)
+        Mysql::quote(string)
       end
 
 
@@ -172,39 +175,63 @@ module ActiveRecord
           structure += select_one("SHOW CREATE TABLE #{table.to_a.first.last}")["Create Table"] + ";\n\n"
         end
       end
-      
-      def add_limit_with_offset!(sql, limit, offset)
-        sql << " LIMIT #{offset}, #{limit}"
+
+      def add_limit_offset!(sql, options)
+        if options[:limit]
+          if options[:offset].blank?
+            sql << " LIMIT #{options[:limit]}"
+          else
+            sql << " LIMIT #{options[:offset]}, #{options[:limit]}"
+          end
+        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 create_table(name)
-        super(name, "ENGINE=InnoDB")
+      def change_column_default(table_name, column_name, default)
+        current_type = select_one("SHOW COLUMNS FROM #{table_name} LIKE '#{column_name}'")["Type"]
+
+        change_column(table_name, column_name, current_type, { :default => default })
+      end
+
+      def change_column(table_name, column_name, type, options = {})
+        options[:default] ||= select_one("SHOW COLUMNS FROM #{table_name} LIKE '#{column_name}'")["Default"]
+        
+        change_column_sql = "ALTER TABLE #{table_name} CHANGE #{column_name} #{column_name} #{type_to_sql(type, options[:limit])}"
+        add_column_options!(change_column_sql, options)
+        execute(change_column_sql)
+      end
+
+      def rename_column(table_name, column_name, new_column_name)
+        current_type = select_one("SHOW COLUMNS FROM #{table_name} LIKE '#{column_name}'")["Type"]
+        execute "ALTER TABLE #{table_name} CHANGE #{column_name} #{new_column_name} #{current_type}"
+      end
+
+      def create_table(name, options = {})
+        super(name, {:options => "ENGINE=InnoDB"}.merge(options))
       end
 
       private
         def select(sql, name = nil)
-          result = nil
           @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) }
+          result.free
           rows
         end
     end
   end
-end
+end

data/lib/active_record/connection_adapters/oci_adapter.rb

@@ -99,8 +99,8 @@ begin
       # * <tt>:password</tt> -- Defaults to nothing
       # * <tt>:host</tt> -- Defaults to localhost
       class OCIAdapter < AbstractAdapter
-        def quote_string(s)
-          s.gsub /'/, "''"
+        def quote_string(string)
+          string.gsub(/'/, "''")
         end
 
         def quote(value, column = nil)
@@ -125,7 +125,7 @@ begin
           elsif offset > 0
             sql = "select * from (select raw_sql_.*, rownum raw_rnum_ from (#{sql}) raw_sql_) where raw_rnum_ > #{offset}"
           end
-          cursor = log(sql, name, @connection) { @connection.exec sql }
+          cursor = log(sql, name) { @connection.exec sql }
           cols = cursor.get_col_names.map { |x| x.downcase }
           rows = []
           while row = cursor.fetch
@@ -167,16 +167,16 @@ begin
           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 }
+            log(sql, name) { @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 }
+            log(sql, name) { @connection.exec sql, id_value }
           end
           id_value
         end
 
         def execute(sql, name = nil)
-          log(sql, name, @connection) { @connection.exec sql }
+          log(sql, name) { @connection.exec sql }
         end
 
         alias :update :execute

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -24,7 +24,8 @@ module ActiveRecord
       username = config[:username].to_s
       password = config[:password].to_s
 
-      schema_order = config[:schema_order]
+      encoding = config[:encoding]
+      min_messages = config[:min_messages]
 
       if config.has_key?(:database)
         database = config[:database]
@@ -36,7 +37,9 @@ module ActiveRecord
         PGconn.connect(host, port, "", "", database, username, password), logger
       )
 
-      pga.execute("SET search_path TO #{schema_order}") if schema_order
+      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
@@ -53,8 +56,30 @@ module ActiveRecord
     # * <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.
-    # * <tt>:schema_order</tt> -- An optional schema order string that is using in a SET search_path TO <schema_order> call on connection.
+    # * <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.
     class PostgreSQLAdapter < AbstractAdapter
+      def native_database_types
+        {
+          :primary_key => "serial primary key",
+          :string      => { :name => "character varying", :limit => 255 },
+          :text        => { :name => "text" },
+          :integer     => { :name => "integer" },
+          :float       => { :name => "float" },
+          :datetime    => { :name => "timestamp" },
+          :timestamp   => { :name => "timestamp" },
+          :time        => { :name => "timestamp" },
+          :date        => { :name => "date" },
+          :binary      => { :name => "bytea" },
+          :boolean     => { :name => "boolean"}
+        }
+      end
+      
+      def supports_migrations?
+        true
+      end      
+      
       def select_all(sql, name = nil)
         select(sql, name)
       end
@@ -65,26 +90,27 @@ module ActiveRecord
       end
 
       def columns(table_name, name = nil)
-        table_structure(table_name).inject([]) do |columns, field|
-          columns << Column.new(field[0], field[2], field[1])
-          columns
+        column_definitions(table_name).collect do |name, type, default|
+          Column.new(name, default_value(default), translate_field_type(type))
         end
       end
 
       def insert(sql, name = nil, pk = nil, id_value = nil)
-        execute(sql, name = nil)
+        execute(sql, name)
         table = sql.split(" ", 4)[2]
         return id_value || last_insert_id(table, pk)
       end
 
+      def query(sql, name = nil)
+        log(sql, name) { @connection.query(sql) }
+      end
+
       def execute(sql, name = nil)
-        log(sql, name, @connection) { |connection| connection.query(sql) }
+        log(sql, name) { @connection.exec(sql) }
       end
 
       def update(sql, name = nil)
-        result = nil
-        log(sql, name, @connection) { |connection| result = connection.exec(sql) }
-        result.cmdtuples
+        execute(sql, name).cmdtuples
       end
 
       alias_method :delete, :update
@@ -102,23 +128,55 @@ module ActiveRecord
       end
 
       def quote_column_name(name)
-        return "\"#{name}\""
+        %("#{name}")
       end
 
-      def adapter_name()
+      def adapter_name
         'PostgreSQL'
       end
 
+
+      # Set the schema search path to a string of comma-separated schema names.
+      # Names beginning with $ are quoted (e.g. $user => '$user')
+      # See http://www.postgresql.org/docs/8.0/interactive/ddl-schemas.html
+      def schema_search_path=(schema_csv)
+        if schema_csv
+          execute "SET search_path TO #{schema_csv}"
+          @schema_search_path = nil
+        end
+      end
+
+      def schema_search_path
+        @schema_search_path ||= query('SHOW search_path')[0][0]
+      end
+            
+      def change_column(table_name, column_name, type, options = {})
+        execute = "ALTER TABLE #{table_name} ALTER  #{column_name} TYPE #{type}"
+        change_column_default(table_name, column_name, options[:default]) unless options[:default].nil?
+      end      
+
+      def change_column_default(table_name, column_name, default)
+        execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET DEFAULT '#{default}'"
+      end
+      
+      def rename_column(table_name, column_name, new_column_name)
+        execute "ALTER TABLE #{table_name} RENAME COLUMN #{column_name} TO #{new_column_name}"
+      end
+
+      def remove_index(table_name, column_name)
+        execute "DROP INDEX #{table_name}_#{column_name}_index"
+      end      
+      
       private
+        BYTEA_COLUMN_TYPE_OID = 17
+
         def last_insert_id(table, column = "id")
           sequence_name = "#{table}_#{column || 'id'}_seq"
           @connection.exec("SELECT currval('#{sequence_name}')")[0][0].to_i
         end
 
         def select(sql, name = nil)
-          res = nil
-          log(sql, name, @connection) { |connection| res = connection.exec(sql) }
-  
+          res = execute(sql, name)
           results = res.result           
           rows = []
           if results.length > 0
@@ -127,7 +185,7 @@ module ActiveRecord
               hashed_row = {}
               row.each_index do |cel_index|
                 column = row[cel_index]
-                if res.type(cel_index) == 17  # type oid for bytea
+                if res.type(cel_index) == BYTEA_COLUMN_TYPE_OID
                   column = unescape_bytea(column)
                 end
                 hashed_row[fields[cel_index]] = column
@@ -150,54 +208,49 @@ module ActiveRecord
           s.gsub(/\\([0-9][0-9][0-9])/) { $1.oct.chr }.gsub(/\\\\/) { '\\' } unless s.nil?
         end
 
-        def split_table_schema(table_name)
-          schema_split = table_name.split('.')
-          schema_name = "public"
-          if schema_split.length > 1
-            schema_name = schema_split.first.strip
-            table_name = schema_split.last.strip
-          end
-          return [schema_name, table_name]
+        # Query a table's column names, default values, and types.
+        #
+        # The underlying query is roughly:
+        #  SELECT column.name, column.type, default.value
+        #    FROM column LEFT JOIN default
+        #      ON column.table_id = default.table_id
+        #     AND column.num = default.column_num
+        #   WHERE column.table_id = get_table_id('table_name')
+        #     AND column.num > 0
+        #     AND NOT column.is_dropped
+        #   ORDER BY column.num
+        #
+        # If the table name is not prefixed with a schema, the database will
+        # take the first match from the schema search path.
+        #
+        # Query implementation notes:
+        #  - format_type includes the column size constraint, e.g. varchar(50)
+        #  - ::regclass is a function that gives the id for a table name
+        def column_definitions(table_name)
+          query <<-end_sql
+            SELECT a.attname, format_type(a.atttypid, a.atttypmod), d.adsrc
+              FROM pg_attribute a LEFT JOIN pg_attrdef d
+                ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+             WHERE a.attrelid = '#{table_name}'::regclass
+               AND a.attnum > 0 AND NOT a.attisdropped
+             ORDER BY a.attnum
+          end_sql
         end
 
-        def table_structure(table_name)
-          database_name = @connection.db
-          schema_name, table_name = split_table_schema(table_name)
-          
-          # Grab a list of all the default values for the columns.
-          sql =  "SELECT column_name, column_default, character_maximum_length, data_type "
-          sql << "  FROM information_schema.columns "
-          sql << " WHERE table_catalog = '#{database_name}' "
-          sql << "   AND table_schema = '#{schema_name}' "
-          sql << "   AND table_name = '#{table_name}';"
-
-          column_defaults = nil
-          log(sql, nil, @connection) { |connection| column_defaults = connection.query(sql) }
-          column_defaults.collect do |row|
-              field   = row[0]
-              type    = type_as_string(row[3], row[2])
-              default = default_value(row[1])
-              length  = row[2]
-
-              [field, type, default, length]
+        # Translate PostgreSQL-specific types into simplified SQL types.
+        # These are special cases; standard types are handled by
+        # ConnectionAdapters::Column#simplified_type.
+        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
+            when /^timestamp/i    then 'datetime'
+            when /^real|^money/i  then 'float'
+            when /^interval/i     then 'string'
+            when /^bytea/i        then 'binary'
+            else field_type       # Pass through standard types.
           end
         end
 
-        def type_as_string(field_type, field_length)
-          type = case field_type
-            when 'numeric', 'real', 'money'      then 'float'
-            when 'character varying', 'interval' then 'string'
-            when 'timestamp without time zone'   then 'datetime'
-            when 'timestamp with time zone'      then 'datetime'
-            when 'bytea'                         then 'binary'
-            else field_type
-          end
-
-          size = field_length.nil? ? "" : "(#{field_length})"
-
-          return type + size
-        end
-
         def default_value(value)
           # Boolean types
           return "t" if value =~ /true/i