activerecord 3.0.20 → 3.1.0.beta1

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -3,6 +3,21 @@ require 'active_support/core_ext/kernel/requires'
 require 'active_support/core_ext/object/blank'
 require 'set'
 
+gem 'mysql', '~> 2.8.1'
+require 'mysql'
+
+class Mysql
+  class Time
+    ###
+    # This monkey patch is for test_additional_columns_from_join_table
+    def to_date
+      Date.new(year, month, day)
+    end
+  end
+  class Stmt; include Enumerable end
+  class Result; include Enumerable end
+end
+
 module ActiveRecord
   class Base
     # Establishes a connection to the database that's used by all Active Record objects.
@@ -15,18 +30,6 @@ module ActiveRecord
       password = config[:password].to_s
       database = config[:database]
 
-      unless defined? Mysql
-        begin
-          require 'mysql'
-        rescue LoadError
-          raise "!!! Missing the mysql2 gem. Add it to your Gemfile: gem 'mysql2'"
-        end
-
-        unless defined?(Mysql::Result) && Mysql::Result.method_defined?(:each_hash)
-          raise "!!! Outdated mysql gem. Upgrade to 2.8.1 or later. In your Gemfile: gem 'mysql', '2.8.1'. Or use gem 'mysql2'"
-        end
-      end
-
       mysql = Mysql.init
       mysql.ssl_set(config[:sslkey], config[:sslcert], config[:sslca], config[:sslcapath], config[:sslcipher]) if config[:sslca] || config[:sslkey]
 
@@ -39,6 +42,30 @@ module ActiveRecord
 
   module ConnectionAdapters
     class MysqlColumn < Column #:nodoc:
+      class << self
+        def string_to_time(value)
+          return super unless Mysql::Time === value
+          new_time(
+            value.year,
+            value.month,
+            value.day,
+            value.hour,
+            value.minute,
+            value.second,
+            value.second_part)
+        end
+
+        def string_to_dummy_time(v)
+          return super unless Mysql::Time === v
+          new_time(2000, 01, 01, v.hour, v.minute, v.second, v.second_part)
+        end
+
+        def string_to_date(v)
+          return super unless Mysql::Time === v
+          new_date(v.year, v.month, v.day)
+        end
+      end
+
       def extract_default(default)
         if sql_type =~ /blob/i || type == :text
           if default.blank?
@@ -132,7 +159,7 @@ module ActiveRecord
       cattr_accessor :emulate_booleans
       self.emulate_booleans = true
 
-      ADAPTER_NAME = 'MySQL'.freeze
+      ADAPTER_NAME = 'MySQL'
 
       LOST_CONNECTION_ERROR_MESSAGES = [
         "Server shutdown in progress",
@@ -140,10 +167,10 @@ module ActiveRecord
         "Lost connection to MySQL server during query",
         "MySQL server has gone away" ]
 
-      QUOTED_TRUE, QUOTED_FALSE = '1'.freeze, '0'.freeze
+      QUOTED_TRUE, QUOTED_FALSE = '1', '0'
 
       NATIVE_DATABASE_TYPES = {
-        :primary_key => "int(11) DEFAULT NULL auto_increment PRIMARY KEY".freeze,
+        :primary_key => "int(11) DEFAULT NULL auto_increment PRIMARY KEY",
         :string      => { :name => "varchar", :limit => 255 },
         :text        => { :name => "text" },
         :integer     => { :name => "int", :limit => 4 },
@@ -161,6 +188,8 @@ module ActiveRecord
         super(connection, logger)
         @connection_options, @config = connection_options, config
         @quoted_column_names, @quoted_table_names = {}, {}
+        @statements = {}
+        @client_encoding = nil
         connect
       end
 
@@ -168,14 +197,27 @@ module ActiveRecord
         ADAPTER_NAME
       end
 
+      def supports_bulk_alter? #:nodoc:
+        true
+      end
+
+      # Returns true, since this connection adapter supports prepared statement
+      # caching.
+      def supports_statement_cache?
+        true
+      end
+
+      # Returns true, since this connection adapter supports migrations.
       def supports_migrations? #:nodoc:
         true
       end
 
+      # Returns true.
       def supports_primary_key? #:nodoc:
         true
       end
 
+      # Returns true, since this connection adapter supports savepoints.
       def supports_savepoints? #:nodoc:
         true
       end
@@ -198,8 +240,14 @@ module ActiveRecord
         end
       end
 
+      def type_cast(value, column)
+        return super unless value == true || value == false
+
+        value ? 1 : 0
+      end
+
       def quote_column_name(name) #:nodoc:
-        @quoted_column_names[name] ||= "`#{name.to_s.gsub('`', '``')}`"
+        @quoted_column_names[name] ||= "`#{name}`"
       end
 
       def quote_table_name(name) #:nodoc:
@@ -252,9 +300,12 @@ module ActiveRecord
 
       def reconnect!
         disconnect!
+        clear_cache!
         connect
       end
 
+      # Disconnects from the database if already connected. Otherwise, this
+      # method does nothing.
       def disconnect!
         @connection.close rescue nil
       end
@@ -272,14 +323,105 @@ module ActiveRecord
 
       def select_rows(sql, name = nil)
         @connection.query_with_result = true
-        result = execute(sql, name)
-        rows = []
-        result.each { |row| rows << row }
-        result.free
+        rows = exec_without_stmt(sql, name).rows
         @connection.more_results && @connection.next_result    # invoking stored procedures with CLIENT_MULTI_RESULTS requires this to tidy up else connection will be dropped
         rows
       end
 
+      # Clears the prepared statements cache.
+      def clear_cache!
+        @statements.values.each do |cache|
+          cache[:stmt].close
+        end
+        @statements.clear
+      end
+
+      if "<3".respond_to?(:encode)
+        # Taken from here:
+        #   https://github.com/tmtm/ruby-mysql/blob/master/lib/mysql/charset.rb
+        # Author: TOMITA Masahiro <tommy@tmtm.org>
+        ENCODINGS = {
+          "armscii8" => nil,
+          "ascii"    => Encoding::US_ASCII,
+          "big5"     => Encoding::Big5,
+          "binary"   => Encoding::ASCII_8BIT,
+          "cp1250"   => Encoding::Windows_1250,
+          "cp1251"   => Encoding::Windows_1251,
+          "cp1256"   => Encoding::Windows_1256,
+          "cp1257"   => Encoding::Windows_1257,
+          "cp850"    => Encoding::CP850,
+          "cp852"    => Encoding::CP852,
+          "cp866"    => Encoding::IBM866,
+          "cp932"    => Encoding::Windows_31J,
+          "dec8"     => nil,
+          "eucjpms"  => Encoding::EucJP_ms,
+          "euckr"    => Encoding::EUC_KR,
+          "gb2312"   => Encoding::EUC_CN,
+          "gbk"      => Encoding::GBK,
+          "geostd8"  => nil,
+          "greek"    => Encoding::ISO_8859_7,
+          "hebrew"   => Encoding::ISO_8859_8,
+          "hp8"      => nil,
+          "keybcs2"  => nil,
+          "koi8r"    => Encoding::KOI8_R,
+          "koi8u"    => Encoding::KOI8_U,
+          "latin1"   => Encoding::ISO_8859_1,
+          "latin2"   => Encoding::ISO_8859_2,
+          "latin5"   => Encoding::ISO_8859_9,
+          "latin7"   => Encoding::ISO_8859_13,
+          "macce"    => Encoding::MacCentEuro,
+          "macroman" => Encoding::MacRoman,
+          "sjis"     => Encoding::SHIFT_JIS,
+          "swe7"     => nil,
+          "tis620"   => Encoding::TIS_620,
+          "ucs2"     => Encoding::UTF_16BE,
+          "ujis"     => Encoding::EucJP_ms,
+          "utf8"     => Encoding::UTF_8,
+          "utf8mb4"  => Encoding::UTF_8,
+        }
+      else
+        ENCODINGS = Hash.new { |h,k| h[k] = k }
+      end
+
+      # Get the client encoding for this database
+      def client_encoding
+        return @client_encoding if @client_encoding
+
+        result = exec_query(
+          "SHOW VARIABLES WHERE Variable_name = 'character_set_client'",
+          'SCHEMA')
+        @client_encoding = ENCODINGS[result.rows.last.last]
+      end
+
+      def exec_query(sql, name = 'SQL', binds = [])
+        log(sql, name, binds) do
+          exec_stmt(sql, name, binds) do |cols, stmt|
+            ActiveRecord::Result.new(cols, stmt.to_a) if cols
+          end
+        end
+      end
+
+      def last_inserted_id(result)
+        @connection.insert_id
+      end
+
+      def exec_without_stmt(sql, name = 'SQL') # :nodoc:
+        # Some queries, like SHOW CREATE TABLE don't work through the prepared
+        # statement API.  For those queries, we need to use this method. :'(
+        log(sql, name) do
+          result = @connection.query(sql)
+          cols = []
+          rows = []
+
+          if result
+            cols = result.fetch_fields.map { |field| field.name }
+            rows = result.to_a
+            result.free
+          end
+          ActiveRecord::Result.new(cols, rows)
+        end
+      end
+
       # Executes an SQL query and returns a MySQL::Result object. Note that you have to free
       # the Result object after you're done using it.
       def execute(sql, name = nil) #:nodoc:
@@ -307,9 +449,18 @@ module ActiveRecord
         @connection.affected_rows
       end
 
+      def exec_delete(sql, name, binds)
+        log(sql, name, binds) do
+          exec_stmt(sql, name, binds) do |cols, stmt|
+            stmt.affected_rows
+          end
+        end
+      end
+      alias :exec_update :exec_delete
+
       def begin_db_transaction #:nodoc:
-        execute "BEGIN"
-      rescue Exception
+        exec_without_stmt "BEGIN"
+      rescue Mysql::Error
         # Transactions aren't supported
       end
 
@@ -348,6 +499,7 @@ module ActiveRecord
         end
         sql
       end
+      deprecate :add_limit_offset!
 
       # SCHEMA STATEMENTS ========================================
 
@@ -360,10 +512,13 @@ module ActiveRecord
 
         select_all(sql).map do |table|
           table.delete('Table_type')
-          select_one("SHOW CREATE TABLE #{quote_table_name(table.to_a.first.last)}")["Create Table"] + ";\n\n"
+          sql = "SHOW CREATE TABLE #{quote_table_name(table.to_a.first.last)}"
+          exec_without_stmt(sql).first['Create Table'] + ";\n\n"
         end.join("")
       end
 
+      # Drops the database specified on the +name+ attribute
+      # and creates it again using the provided +options+.
       def recreate_database(name, options = {}) #:nodoc:
         drop_database(name)
         create_database(name, options)
@@ -384,6 +539,10 @@ module ActiveRecord
         end
       end
 
+      # Drops a MySQL database.
+      #
+      # Example:
+      #   drop_database 'sebastian_development'
       def drop_database(name) #:nodoc:
         execute "DROP DATABASE IF EXISTS `#{name}`"
       end
@@ -403,13 +562,8 @@ module ActiveRecord
       end
 
       def tables(name = nil, database = nil) #:nodoc:
-        tables = []
-
-        sql = "SHOW TABLES "
-        sql << "IN #{quote_table_name(database)} " if database
-
-        result = execute(sql, 'SCHEMA')
-        result.each { |field| tables << field[0] }
+        result = execute(["SHOW TABLES", database].compact.join(' IN '), 'SCHEMA')
+        tables = result.collect { |field| field[0] }
         result.free
         tables
       end
@@ -432,6 +586,7 @@ module ActiveRecord
         super(table_name, options)
       end
 
+      # Returns an array of indexes for the given table.
       def indexes(table_name, name = nil)#:nodoc:
         indexes = []
         current_index = nil
@@ -450,11 +605,11 @@ module ActiveRecord
         indexes
       end
 
+      # Returns an array of +MysqlColumn+ objects for the table specified by +table_name+.
       def columns(table_name, name = nil)#:nodoc:
         sql = "SHOW FIELDS FROM #{quote_table_name(table_name)}"
-        columns = []
-        result = execute(sql, :skip_logging)
-        result.each { |field| columns << MysqlColumn.new(field[0], field[4], field[1], field[2] == "YES") }
+        result = execute(sql, 'SCHEMA')
+        columns = result.collect { |field| MysqlColumn.new(field[0], field[4], field[1], field[2] == "YES") }
         result.free
         columns
       end
@@ -463,15 +618,31 @@ module ActiveRecord
         super(table_name, options.reverse_merge(:options => "ENGINE=InnoDB"))
       end
 
+      # Renames a table.
+      #
+      # Example:
+      #   rename_table('octopuses', 'octopi')
       def rename_table(table_name, new_name)
         execute "RENAME TABLE #{quote_table_name(table_name)} TO #{quote_table_name(new_name)}"
       end
 
+      def bulk_change_table(table_name, operations) #:nodoc:
+        sqls = operations.map do |command, args|
+          table, arguments = args.shift, args
+          method = :"#{command}_sql"
+
+          if respond_to?(method)
+            send(method, table, *arguments)
+          else
+            raise "Unknown method called : #{method}(#{arguments.inspect})"
+          end
+        end.flatten.join(", ")
+
+        execute("ALTER TABLE #{quote_table_name(table_name)} #{sqls}")
+      end
+
       def add_column(table_name, column_name, type, options = {})
-        add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-        add_column_options!(add_column_sql, options)
-        add_column_position!(add_column_sql, options)
-        execute(add_column_sql)
+        execute("ALTER TABLE #{quote_table_name(table_name)} #{add_column_sql(table_name, column_name, type, options)}")
       end
 
       def change_column_default(table_name, column_name, default) #:nodoc:
@@ -490,58 +661,24 @@ module ActiveRecord
       end
 
       def change_column(table_name, column_name, type, options = {}) #:nodoc:
-        column = column_for(table_name, column_name)
-
-        unless options_include_default?(options)
-          options[:default] = column.default
-        end
-
-        unless options.has_key?(:null)
-          options[:null] = column.null
-        end
-
-        change_column_sql = "ALTER TABLE #{quote_table_name(table_name)} CHANGE #{quote_column_name(column_name)} #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-        add_column_options!(change_column_sql, options)
-        add_column_position!(change_column_sql, options)
-        execute(change_column_sql)
+        execute("ALTER TABLE #{quote_table_name(table_name)} #{change_column_sql(table_name, column_name, type, options)}")
       end
 
       def rename_column(table_name, column_name, new_column_name) #:nodoc:
-        options = {}
-        if column = columns(table_name).find { |c| c.name == column_name.to_s }
-          options[:default] = column.default
-          options[:null] = column.null
-        else
-          raise ActiveRecordError, "No such column: #{table_name}.#{column_name}"
-        end
-        current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'")["Type"]
-        rename_column_sql = "ALTER TABLE #{quote_table_name(table_name)} CHANGE #{quote_column_name(column_name)} #{quote_column_name(new_column_name)} #{current_type}"
-        add_column_options!(rename_column_sql, options)
-        execute(rename_column_sql)
+        execute("ALTER TABLE #{quote_table_name(table_name)} #{rename_column_sql(table_name, column_name, new_column_name)}")
       end
 
       # Maps logical Rails types to MySQL-specific data types.
       def type_to_sql(type, limit = nil, precision = nil, scale = nil)
-        case type.to_s
-        when 'integer'
-          case limit
-          when 1; 'tinyint'
-          when 2; 'smallint'
-          when 3; 'mediumint'
-          when nil, 4, 11; 'int(11)'  # compatibility with MySQL default
-          when 5..8; 'bigint'
-          else raise(ActiveRecordError, "No integer type has byte size #{limit}")
-          end
-        when 'text'
-          case limit
-          when 0..0xff;               'tinytext'
-          when nil, 0x100..0xffff;    'text'
-          when 0x10000..0xffffff;     'mediumtext'
-          when 0x1000000..0xffffffff; 'longtext'
-          else raise(ActiveRecordError, "No text type has character length #{limit}")
-          end
-        else
-          super
+        return super unless type.to_s == 'integer'
+
+        case limit
+        when 1; 'tinyint'
+        when 2; 'smallint'
+        when 3; 'mediumint'
+        when nil, 4, 11; 'int(11)'  # compatibility with MySQL default
+        when 5..8; 'bigint'
+        else raise(ActiveRecordError, "No integer type has byte size #{limit}")
         end
       end
 
@@ -562,7 +699,7 @@ module ActiveRecord
       # Returns a table's primary key and belonging sequence.
       def pk_and_sequence_for(table) #:nodoc:
         keys = []
-        result = execute("describe #{quote_table_name(table)}")
+        result = execute("describe #{quote_table_name(table)}", 'SCHEMA')
         result.each_hash do |h|
           keys << h["Field"]if h["Key"] == "PRI"
         end
@@ -579,6 +716,11 @@ module ActiveRecord
       def case_sensitive_equality_operator
         "= BINARY"
       end
+      deprecate :case_sensitive_equality_operator
+
+      def case_sensitive_modifier(node)
+        Arel::Nodes::Bin.new(node)
+      end
 
       def limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key)
         where_sql
@@ -611,7 +753,110 @@ module ActiveRecord
           end
         end
 
+        def add_column_sql(table_name, column_name, type, options = {})
+          add_column_sql = "ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+          add_column_options!(add_column_sql, options)
+          add_column_position!(add_column_sql, options)
+          add_column_sql
+        end
+
+        def remove_column_sql(table_name, *column_names)
+          columns_for_remove(table_name, *column_names).map {|column_name| "DROP #{column_name}" }
+        end
+        alias :remove_columns_sql :remove_column
+
+        def change_column_sql(table_name, column_name, type, options = {})
+          column = column_for(table_name, column_name)
+
+          unless options_include_default?(options)
+            options[:default] = column.default
+          end
+
+          unless options.has_key?(:null)
+            options[:null] = column.null
+          end
+
+          change_column_sql = "CHANGE #{quote_column_name(column_name)} #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+          add_column_options!(change_column_sql, options)
+          add_column_position!(change_column_sql, options)
+          change_column_sql
+        end
+
+        def rename_column_sql(table_name, column_name, new_column_name)
+          options = {}
+
+          if column = columns(table_name).find { |c| c.name == column_name.to_s }
+            options[:default] = column.default
+            options[:null] = column.null
+          else
+            raise ActiveRecordError, "No such column: #{table_name}.#{column_name}"
+          end
+
+          current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'")["Type"]
+          rename_column_sql = "CHANGE #{quote_column_name(column_name)} #{quote_column_name(new_column_name)} #{current_type}"
+          add_column_options!(rename_column_sql, options)
+          rename_column_sql
+        end
+
+        def add_index_sql(table_name, column_name, options = {})
+          index_name, index_type, index_columns = add_index_options(table_name, column_name, options)
+          "ADD #{index_type} INDEX #{index_name} (#{index_columns})"
+        end
+
+        def remove_index_sql(table_name, options = {})
+          index_name = index_name_for_remove(table_name, options)
+          "DROP INDEX #{index_name}"
+        end
+
+        def add_timestamps_sql(table_name)
+          [add_column_sql(table_name, :created_at, :datetime), add_column_sql(table_name, :updated_at, :datetime)]
+        end
+
+        def remove_timestamps_sql(table_name)
+          [remove_column_sql(table_name, :updated_at), remove_column_sql(table_name, :created_at)]
+        end
+
       private
+      def exec_stmt(sql, name, binds)
+        cache = {}
+        if binds.empty?
+          stmt = @connection.prepare(sql)
+        else
+          cache = @statements[sql] ||= {
+            :stmt => @connection.prepare(sql)
+          }
+          stmt = cache[:stmt]
+        end
+
+
+        begin
+          stmt.execute(*binds.map { |col, val| type_cast(val, col) })
+        rescue Mysql::Error => e
+          # Older versions of MySQL leave the prepared statement in a bad
+          # place when an error occurs.  To support older mysql versions, we
+          # need to close the statement and delete the statement from the
+          # cache.
+          stmt.close
+          @statements.delete sql
+          raise e
+        end
+
+        cols = nil
+        if metadata = stmt.result_metadata
+          cols = cache[:cols] ||= metadata.fetch_fields.map { |field|
+            field.name
+          }
+        end
+
+        result = yield [cols, stmt]
+
+        stmt.result_metadata.free if cols
+        stmt.free_result
+        stmt.close if binds.empty?
+
+        result
+      end
+
         def connect
           encoding = @config[:encoding]
           if encoding
@@ -643,12 +888,9 @@ module ActiveRecord
           execute("SET SQL_AUTO_IS_NULL=0", :skip_logging)
         end
 
-        def select(sql, name = nil)
+        def select(sql, name = nil, binds = [])
           @connection.query_with_result = true
-          result = execute(sql, name)
-          rows = []
-          result.each_hash { |row| rows << row }
-          result.free
+          rows = exec_query(sql, name, binds).to_a
           @connection.more_results && @connection.next_result    # invoking stored procedures with CLIENT_MULTI_RESULTS requires this to tidy up else connection will be dropped
           rows
         end
@@ -657,6 +899,7 @@ module ActiveRecord
           version[0] >= 5
         end
 
+        # Returns the version of the connected MySQL server.
         def version
           @version ||= @connection.server_info.scan(/^(\d+)\.(\d+)\.(\d+)/).flatten.map { |v| v.to_i }
         end