outback 0.0.14 → 1.0.2

data/lib/outback/errors.rb

@@ -0,0 +1,7 @@
+module Outback
+  class Error < StandardError; end
+  
+  class ConfigurationError < Error; end
+  class BackupError < Error; end
+  class ProcessingError < Error; end
+end

data/lib/outback/logging.rb

@@ -0,0 +1,7 @@
+module Outback
+  module Logging
+    def logger
+      Outback
+    end
+  end
+end

data/lib/outback/mysql_source.rb

@@ -7,7 +7,7 @@ module Outback
     end
     
     def excludes
-      @excludes ||= []
+      @excludes ||= ['mysql', 'performance_schema', 'information_schema']
     end
     
     def database(*names)
@@ -22,13 +22,13 @@ module Outback
       user && password
     end
     
-    def create_archives(backup_name, timestamp, tmpdir)
+    def create_archives(timestamp, tmpdir)
       mysql_host = host || 'localhost'
       mysql_port = (port || 3306) unless socket
       if databases.empty?
-        #        (host=nil, user=nil, passwd=nil, db=nil, port=nil, socket=nil, flag=nil)
+        # (host=nil, user=nil, passwd=nil, db=nil, port=nil, socket=nil, flag=nil)
         mysql = Mysql.connect(mysql_host, user, password, nil, mysql_port, socket)
-        @databases = mysql.databases - excludes
+        @databases = mysql.list_dbs - excludes
         mysql.close
       end
       
@@ -37,13 +37,13 @@ module Outback
         mysql_conf_file = Pathname.new(tmpdir).join('outback_my.cnf')
         File.open(mysql_conf_file, 'w') { |f| f << "[client]\npassword=#{password}\n" }
         FileUtils.chmod 0600, mysql_conf_file
-        Outback.debug "MysqlSource: dumping database '#{database}'"
+        logger.debug "MysqlSource: dumping database '#{database}'"
         commandline = "mysqldump --defaults-extra-file=#{mysql_conf_file} --opt --user=#{user} --host=#{mysql_host} --port=#{mysql_port} #{database} | gzip > #{archive_name}"
         result = `#{commandline}`.strip
-        Outback.debug(result) unless result.blank?
-        Outback.info "Archived database #{database}"
-        TempArchive.new(archive_name, self).tap { |archive| Outback.debug "dumped #{archive.filename.basename} with #{archive.size} bytes" }
+        logger.debug(result) unless result.blank?
+        logger.info "Archived database #{database}"
+        SourceArchive.new(archive_name).tap { |archive| logger.debug "dumped #{archive.filename.basename} with #{archive.size} bytes" }
       end
     end
   end
-end
+end

data/lib/outback/processor.rb

@@ -0,0 +1,17 @@
+module Outback
+  class Processor
+    include Configurable
+    include Logging
+    
+    attr_reader :backup_name
+    
+    def initialize(backup_name)
+      @backup_name = backup_name
+    end
+        
+    def process!(archives)
+      archives.map { |archive| process_archive!(archive) }.flatten.compact
+    end
+    
+  end
+end

data/lib/outback/s3_target.rb

@@ -2,7 +2,7 @@ module Outback
   class S3Target < Target
     attr_setter :bucket_name, :access_key, :secret_key, :ttl, :prefix
     
-    def display_name
+    def to_s
       "s3:#{bucket_name}/#{prefix}"
     end
     
@@ -12,7 +12,7 @@ module Outback
     
     def service(force_reconnect = false)
       @service = nil if force_reconnect
-      @service ||= S3::Service.new(:access_key_id => access_key, :secret_access_key => secret_key)
+      @service ||= S3::Service.new(access_key_id: access_key, secret_access_key: secret_key, use_ssl: true)
     end
     
     def bucket
@@ -23,7 +23,7 @@ module Outback
       size = count = 0
       archives.each do |archive|
         object_name = [prefix.to_s, archive.filename.basename.to_s].join('/')
-        Outback.debug "S3Target: storing #{archive.filename} in s3://#{bucket_name}/#{object_name}"
+        logger.debug "S3Target: storing #{archive.filename} in s3://#{bucket_name}/#{object_name}"
         object = bucket.objects.build(object_name)
         object.content = archive.open
         object.acl = :private
@@ -32,17 +32,26 @@ module Outback
           size += archive.size
           count += 1
         else
-          Outback.error "S3 archive upload failed: #{object_name}"
+          logger.error "S3 archive upload failed: #{object_name}"
         end
       end
-      Outback.info "Uploaded #{count} archives (#{size} bytes) to #{display_name}"
+      logger.info "Uploaded #{count} archives (#{size} bytes) to #{self}"
       count
     end
     
-    def list_archives(name)
+    private
+
+    def list_all_archives
       entries = bucket.objects.select { |e| e.key.start_with?(prefix.to_s) && e.key[prefix.to_s.size..-1].match(Archive::NAME_PATTERN) }
-      entries.map { |e| S3Archive.new(e.key, self) }.select(&its.backup_name == name)
+      entries.map { |e| build_archive(e.key, e.size) }
     end
+    
+    def unlink_archive!(archive)
+      logger.debug "purging S3Archive: #{archive.filename}"
+      object = bucket.objects.find(archive.filename.to_s)
+      return true if object && object.destroy
+      raise BackupError, "could not find object #{archive.filename} for purging"
+    end
+
   end
-  
-end
+end

data/lib/outback/sftp_target.rb

@@ -0,0 +1,70 @@
+require 'net/sftp'
+
+module Outback
+  class SftpTarget < Target
+    
+    attr_reader :host
+    attr_setter :user, :password, :port, :path, :ttl, :ssh_opts
+    
+    def initialize(backup_name, host)
+      super(backup_name)
+      @host = host
+    end
+    
+    def valid?
+      host.present?
+    end
+    
+    def to_s
+      "sftp:#{user}@#{host}#{':' + port.to_s if port}:#{path}"
+    end
+    
+    def put(archives)
+      size = count = 0
+      connect do
+        archives.each do |archive|
+          basename = archive.filename.basename.to_s
+          upload_filename = path ? File.join(path, basename) : basename
+          logger.debug "SftpTarget: storing #{archive.filename} in sftp://#{user}@#{host}#{':' + port.to_s if port}:#{upload_filename}"
+          connection.upload!(archive.filename.to_s, upload_filename)
+          size += archive.size
+          count += 1
+        end
+      end
+      logger.info "Uploaded #{count} archives (#{size} bytes) to #{self}"
+      count
+    end
+
+    private
+  
+    def connect
+      result = nil
+      Net::SFTP.start(host, user, ssh_options) do |sftp|
+        @connection = sftp
+        result = yield
+      end
+      result
+    ensure
+      @connection = nil
+    end
+  
+    def ssh_options
+      options = ssh_opts || {}
+      if password
+        options[:password] = password
+        options[:auth_methods] ||= %w[password]
+      end
+      options[:port] = port if port
+      options
+    end
+    
+    def list_all_archives
+      connection.dir.entries(path).select(&:file?).map { |entry| build_archive(File.join(path, entry.name), entry.attributes.size.to_i) }
+    end
+    
+    def unlink_archive!(archive)
+      connection.remove!(archive.filename)
+    end
+
+  end
+end

data/lib/outback/source.rb

@@ -1,10 +1,17 @@
 module Outback
   class Source
     include Configurable
+    include Logging
+    
+    attr_reader :backup_name
+    
+    def initialize(backup_name)
+      @backup_name = backup_name
+    end
     
     def create_archive(backup_name, timestamp, tmpdir)
-      # implement in subclasses
+      raise NotImplementedError
     end
     
   end
-end
+end

data/lib/outback/source_archive.rb

@@ -0,0 +1,17 @@
+module Outback
+  class SourceArchive < Archive
+    
+    def initialize(filename)
+      super(filename)
+      @size = @filename.size
+    end
+    
+    def open
+      filename.open
+    end
+    
+    def unlink
+      filename.unlink
+    end
+  end
+end

data/lib/outback/support/attr_setter.rb

@@ -21,4 +21,4 @@ module Outback
     end
   end
 
-end
+end

data/lib/outback/support/configurable.rb

@@ -3,11 +3,13 @@ module Outback
     
     def self.included(base)
       base.extend ClassMethods
-      base.class_attribute :attributes
-      base.attributes = []
     end
     
     module ClassMethods
+      def attributes
+        @attributes ||= []
+      end
+      
       def configure(*args, &block)
         returning new(*args) do |instance|
           if block_given?
@@ -28,4 +30,4 @@ module Outback
     end
     
   end
-end
+end

data/lib/outback/target.rb

@@ -1,22 +1,59 @@
 module Outback
   class Target
     include Configurable
-
-    def outdated_archives(name)
-      list_archives(name).select(&:outdated?)
-    end
-    
-    def purge!(name)
-      size = count = 0
-      outdated_archives(name).each do |archive|
-        archive_size = archive.size
-        if archive.purge!
-          count += 1
-          size += archive_size
+    include Logging
+    
+    attr_reader :backup_name
+    
+    def initialize(backup_name)
+      @backup_name = backup_name
+    end
+    
+    def purge!
+      purged_archives = connect { purge_archives }
+      logger.info "Purged #{purged_archives.size} archives (#{purged_archives.sum(&:size)} bytes) from #{self}"
+    end
+    
+    private
+    
+    def connection
+      @connection
+    end
+    
+    def connect
+      yield
+    end
+    
+    def build_archive(filename, size)
+      TargetArchive.new(filename, size, self)
+    end
+    
+    def list_all_archives
+      raise NotImplemented
+    end
+    
+    def archives
+      list_all_archives.select(&it.match?(backup_name))
+    end
+    
+    def purge_archives
+      archives.select do |archive|
+        if archive.outdated?
+          begin
+            logger.debug "purging archive: #{archive}"
+            unlink_archive!(archive)
+            true
+          rescue => e
+            logger.error "could not unlink archive #{archive}: #{e} #{e.message}"
+            false
+          end
         end
       end
-      Outback.info "Purged #{count} archives (#{size} bytes) from #{display_name}"
+    end
+    
+    def unlink_archive!(archive)
+      raise NotImplemented
     end
   
   end
-end
+end

data/lib/outback/target_archive.rb

@@ -0,0 +1,30 @@
+module Outback
+  class TargetArchive < Archive
+    attr_reader :target
+    
+    def initialize(filename, size, target)
+      super(filename)
+      @size = size
+      @target = target
+    end    
+    
+    def match?(name)
+      name == backup_name
+    end
+    
+    def ttl
+      target && target.ttl
+    end
+
+    def outdated?
+      if timestamp && ttl
+        Time.now - Time.strptime(timestamp, Outback::TIME_FORMAT) > ttl
+      end
+    end
+    
+    def to_s
+      "#{target}: #{filename}"
+    end
+     
+  end
+end

data/lib/outback/version.rb

@@ -0,0 +1,3 @@
+module Outback
+  VERSION = '1.0.2'
+end

data/lib/vendor/enumerable_ext.rb

@@ -0,0 +1,9 @@
+module Enumerable
+  def sum(identity = 0, &block)
+    if block_given?
+      map(&block).sum(identity)
+    else
+      inject { |sum, element| sum + element } || identity
+    end
+  end
+end

data/lib/{outback/vendor → vendor}/metaclass.rb

@@ -12,4 +12,4 @@ class Object
   def class_def name, &blk
     class_eval { define_method name, &blk }
  end
-end
+end

data/lib/{outback/vendor → vendor}/methodphitamine.rb

@@ -22,4 +22,4 @@ class It < BasicObject
       @methods.inject(obj) { |current, (args,block)| current.send(*args, &block) }
     end
   end
-end
+end

data/lib/vendor/mysql.rb

@@ -0,0 +1,1093 @@
+class Mysql
+
+  require_relative "mysql/constants"
+  require_relative "mysql/error"
+  require_relative "mysql/charset"
+  require_relative "mysql/protocol"
+  require_relative "mysql/packet.rb"
+  begin
+    require_relative "mysql/ext.so"
+  rescue LoadError
+  end
+
+  VERSION            = 20913               # Version number of this library
+  MYSQL_UNIX_PORT    = "/tmp/mysql.sock"   # UNIX domain socket filename
+  MYSQL_TCP_PORT     = 3306                # TCP socket port number
+
+  # @return [Mysql::Charset] character set of MySQL connection
+  attr_reader :charset
+  # @private
+  attr_reader :protocol
+
+  # @return [Boolean] if true, {#query} return {Mysql::Result}.
+  attr_accessor :query_with_result
+
+  class << self
+    # Make Mysql object without connecting.
+    # @return [Mysql]
+    def init
+      my = self.allocate
+      my.instance_eval{initialize}
+      my
+    end
+
+    # Make Mysql object and connect to mysqld.
+    # @param args same as arguments for {#connect}.
+    # @return [Mysql]
+    def new(*args)
+      my = self.init
+      my.connect(*args)
+    end
+
+    alias real_connect new
+    alias connect new
+
+    # Escape special character in string.
+    # @param [String] str
+    # @return [String]
+    def escape_string(str)
+      str.gsub(/[\0\n\r\\\'\"\x1a]/) do |s|
+        case s
+        when "\0" then "\\0"
+        when "\n" then "\\n"
+        when "\r" then "\\r"
+        when "\x1a" then "\\Z"
+        else "\\#{s}"
+        end
+      end
+    end
+    alias quote escape_string
+
+    # @return [String] client version. This value is dummy for MySQL/Ruby compatibility.
+    def client_info
+      "5.0.0"
+    end
+    alias get_client_info client_info
+
+    # @return [Integer] client version. This value is dummy for MySQL/Ruby compatibility.
+    def client_version
+      50000
+    end
+    alias get_client_version client_version
+  end
+
+  def initialize
+    @fields = nil
+    @protocol = nil
+    @charset = nil
+    @connect_timeout = nil
+    @read_timeout = nil
+    @write_timeout = nil
+    @init_command = nil
+    @sqlstate = "00000"
+    @query_with_result = true
+    @host_info = nil
+    @last_error = nil
+    @result_exist = false
+    @local_infile = nil
+  end
+
+  # Connect to mysqld.
+  # @param [String / nil] host hostname mysqld running
+  # @param [String / nil] user username to connect to mysqld
+  # @param [String / nil] passwd password to connect to mysqld
+  # @param [String / nil] db initial database name
+  # @param [Integer / nil] port port number (used if host is not 'localhost' or nil)
+  # @param [String / nil] socket socket file name (used if host is 'localhost' or nil)
+  # @param [Integer / nil] flag connection flag. Mysql::CLIENT_* ORed
+  # @return self
+  def connect(host=nil, user=nil, passwd=nil, db=nil, port=nil, socket=nil, flag=0)
+    if flag & CLIENT_COMPRESS != 0
+      warn 'unsupported flag: CLIENT_COMPRESS' if $VERBOSE
+      flag &= ~CLIENT_COMPRESS
+    end
+    @protocol = Protocol.new host, port, socket, @connect_timeout, @read_timeout, @write_timeout
+    @protocol.authenticate user, passwd, db, (@local_infile ? CLIENT_LOCAL_FILES : 0) | flag, @charset
+    @charset ||= @protocol.charset
+    @host_info = (host.nil? || host == "localhost") ? 'Localhost via UNIX socket' : "#{host} via TCP/IP"
+    query @init_command if @init_command
+    return self
+  end
+  alias real_connect connect
+
+  # Disconnect from mysql.
+  # @return [Mysql] self
+  def close
+    if @protocol
+      @protocol.quit_command
+      @protocol = nil
+    end
+    return self
+  end
+
+  # Disconnect from mysql without QUIT packet.
+  # @return [Mysql] self
+  def close!
+    if @protocol
+      @protocol.close
+      @protocol = nil
+    end
+    return self
+  end
+
+  # Set option for connection.
+  #
+  # Available options:
+  #   Mysql::INIT_COMMAND, Mysql::OPT_CONNECT_TIMEOUT, Mysql::OPT_READ_TIMEOUT,
+  #   Mysql::OPT_WRITE_TIMEOUT, Mysql::SET_CHARSET_NAME
+  # @param [Integer] opt option
+  # @param [Integer] value option value that is depend on opt
+  # @return [Mysql] self
+  def options(opt, value=nil)
+    case opt
+    when Mysql::INIT_COMMAND
+      @init_command = value.to_s
+#    when Mysql::OPT_COMPRESS
+    when Mysql::OPT_CONNECT_TIMEOUT
+      @connect_timeout = value
+#    when Mysql::GUESS_CONNECTION
+    when Mysql::OPT_LOCAL_INFILE
+      @local_infile = value
+#    when Mysql::OPT_NAMED_PIPE
+#    when Mysql::OPT_PROTOCOL
+    when Mysql::OPT_READ_TIMEOUT
+      @read_timeout = value.to_i
+#    when Mysql::OPT_RECONNECT
+#    when Mysql::SET_CLIENT_IP
+#    when Mysql::OPT_SSL_VERIFY_SERVER_CERT
+#    when Mysql::OPT_USE_EMBEDDED_CONNECTION
+#    when Mysql::OPT_USE_REMOTE_CONNECTION
+    when Mysql::OPT_WRITE_TIMEOUT
+      @write_timeout = value.to_i
+#    when Mysql::READ_DEFAULT_FILE
+#    when Mysql::READ_DEFAULT_GROUP
+#    when Mysql::REPORT_DATA_TRUNCATION
+#    when Mysql::SECURE_AUTH
+#    when Mysql::SET_CHARSET_DIR
+    when Mysql::SET_CHARSET_NAME
+      @charset = Charset.by_name value.to_s
+#    when Mysql::SHARED_MEMORY_BASE_NAME
+    else
+      warn "option not implemented: #{opt}" if $VERBOSE
+    end
+    self
+  end
+
+  # Escape special character in MySQL.
+  #
+  # In Ruby 1.8, this is not safe for multibyte charset such as 'SJIS'.
+  # You should use place-holder in prepared-statement.
+  # @param [String] str
+  # return [String]
+  def escape_string(str)
+    if not defined? Encoding and @charset.unsafe
+      raise ClientError, 'Mysql#escape_string is called for unsafe multibyte charset'
+    end
+    self.class.escape_string str
+  end
+  alias quote escape_string
+
+  # @return [String] client version
+  def client_info
+    self.class.client_info
+  end
+  alias get_client_info client_info
+
+  # @return [Integer] client version
+  def client_version
+    self.class.client_version
+  end
+  alias get_client_version client_version
+
+  # Set charset of MySQL connection.
+  # @param [String / Mysql::Charset] cs
+  def charset=(cs)
+    charset = cs.is_a?(Charset) ? cs : Charset.by_name(cs)
+    if @protocol
+      @protocol.charset = charset
+      query "SET NAMES #{charset.name}"
+    end
+    @charset = charset
+    cs
+  end
+
+  # @return [String] charset name
+  def character_set_name
+    @charset.name
+  end
+
+  # @return [Integer] last error number
+  def errno
+    @last_error ? @last_error.errno : 0
+  end
+
+  # @return [String] last error message
+  def error
+    @last_error && @last_error.error
+  end
+
+  # @return [String] sqlstate for last error
+  def sqlstate
+    @last_error ? @last_error.sqlstate : "00000"
+  end
+
+  # @return [Integer] number of columns for last query
+  def field_count
+    @fields.size
+  end
+
+  # @return [String] connection type
+  def host_info
+    @host_info
+  end
+  alias get_host_info host_info
+
+  # @return [Integer] protocol version
+  def proto_info
+    Mysql::Protocol::VERSION
+  end
+  alias get_proto_info proto_info
+
+  # @return [String] server version
+  def server_info
+    check_connection
+    @protocol.server_info
+  end
+  alias get_server_info server_info
+
+  # @return [Integer] server version
+  def server_version
+    check_connection
+    @protocol.server_version
+  end
+  alias get_server_version server_version
+
+  # @return [String] information for last query
+  def info
+    @protocol && @protocol.message
+  end
+
+  # @return [Integer] number of affected records by insert/update/delete.
+  def affected_rows
+    @protocol ? @protocol.affected_rows : 0
+  end
+
+  # @return [Integer] latest auto_increment value
+  def insert_id
+    @protocol ? @protocol.insert_id : 0
+  end
+
+  # @return [Integer] number of warnings for previous query
+  def warning_count
+    @protocol ? @protocol.warning_count : 0
+  end
+
+  # Kill query.
+  # @param [Integer] pid thread id
+  # @return [Mysql] self
+  def kill(pid)
+    check_connection
+    @protocol.kill_command pid
+    self
+  end
+
+  # database list.
+  # @param [String] db database name that may contain wild card.
+  # @return [Array<String>] database list
+  def list_dbs(db=nil)
+    db &&= db.gsub(/[\\\']/){"\\#{$&}"}
+    query(db ? "show databases like '#{db}'" : "show databases").map(&:first)
+  end
+
+  # Execute query string.
+  # @param [String] str Query.
+  # @yield [Mysql::Result] evaluated per query.
+  # @return [Mysql::Result] If {#query_with_result} is true and result set exist.
+  # @return [nil] If {#query_with_result} is true and the query does not return result set.
+  # @return [Mysql] If {#query_with_result} is false or block is specified
+  # @example
+  #  my.query("select 1,NULL,'abc'").fetch  # => [1, nil, "abc"]
+  def query(str, &block)
+    check_connection
+    @fields = nil
+    begin
+      nfields = @protocol.query_command str
+      if nfields
+        @fields = @protocol.retr_fields nfields
+        @result_exist = true
+      end
+      if block
+        while true
+          block.call store_result if @fields
+          break unless next_result
+        end
+        return self
+      end
+      if @query_with_result
+        return @fields ? store_result : nil
+      else
+        return self
+      end
+    rescue ServerError => e
+      @last_error = e
+      @sqlstate = e.sqlstate
+      raise
+    end
+  end
+  alias real_query query
+
+  # Get all data for last query if query_with_result is false.
+  # @return [Mysql::Result]
+  def store_result
+    check_connection
+    raise ClientError, 'invalid usage' unless @result_exist
+    res = Result.new @fields, @protocol
+    @result_exist = false
+    res
+  end
+
+  # @return [Integer] Thread ID
+  def thread_id
+    check_connection
+    @protocol.thread_id
+  end
+
+  # Use result of query. The result data is retrieved when you use Mysql::Result#fetch.
+  # @return [Mysql::Result]
+  def use_result
+    store_result
+  end
+
+  # Set server option.
+  # @param [Integer] opt {Mysql::OPTION_MULTI_STATEMENTS_ON} or {Mysql::OPTION_MULTI_STATEMENTS_OFF}
+  # @return [Mysql] self
+  def set_server_option(opt)
+    check_connection
+    @protocol.set_option_command opt
+    self
+  end
+
+  # @return [Boolean] true if multiple queries are specified and unexecuted queries exists.
+  def more_results
+    @protocol.server_status & SERVER_MORE_RESULTS_EXISTS != 0
+  end
+  alias more_results? more_results
+
+  # execute next query if multiple queries are specified.
+  # @return [Boolean] true if next query exists.
+  def next_result
+    return false unless more_results
+    check_connection
+    @fields = nil
+    nfields = @protocol.get_result
+    if nfields
+      @fields = @protocol.retr_fields nfields
+      @result_exist = true
+    end
+    return true
+  end
+
+  # Parse prepared-statement.
+  # @param [String] str query string
+  # @return [Mysql::Stmt] Prepared-statement object
+  def prepare(str)
+    st = Stmt.new @protocol, @charset
+    st.prepare str
+    st
+  end
+
+  # @private
+  # Make empty prepared-statement object.
+  # @return [Mysql::Stmt] If block is not specified.
+  def stmt_init
+    Stmt.new @protocol, @charset
+  end
+
+  # Returns Mysql::Result object that is empty.
+  # Use fetch_fields to get list of fields.
+  # @param [String] table table name.
+  # @param [String] field field name that may contain wild card.
+  # @return [Mysql::Result]
+  def list_fields(table, field=nil)
+    check_connection
+    begin
+      fields = @protocol.field_list_command table, field
+      return Result.new fields
+    rescue ServerError => e
+      @last_error = e
+      @sqlstate = e.sqlstate
+      raise
+    end
+  end
+
+  # @return [Mysql::Result] containing process list
+  def list_processes
+    check_connection
+    @fields = @protocol.process_info_command
+    @result_exist = true
+    store_result
+  end
+
+  # @note for Ruby 1.8: This is not multi-byte safe. Don't use for multi-byte charset such as cp932.
+  # @param [String] table database name that may contain wild card.
+  # @return [Array<String>] list of table name.
+  def list_tables(table=nil)
+    q = table ? "show tables like '#{quote table}'" : "show tables"
+    query(q).map(&:first)
+  end
+
+  # Check whether the  connection is available.
+  # @return [Mysql] self
+  def ping
+    check_connection
+    @protocol.ping_command
+    self
+  end
+
+  # Flush tables or caches.
+  # @param [Integer] op operation. Use Mysql::REFRESH_* value.
+  # @return [Mysql] self
+  def refresh(op)
+    check_connection
+    @protocol.refresh_command op
+    self
+  end
+
+  # Reload grant tables.
+  # @return [Mysql] self
+  def reload
+    refresh Mysql::REFRESH_GRANT
+  end
+
+  # Select default database
+  # @return [Mysql] self
+  def select_db(db)
+    query "use #{db}"
+    self
+  end
+
+  # shutdown server.
+  # @return [Mysql] self
+  def shutdown(level=0)
+    check_connection
+    @protocol.shutdown_command level
+    self
+  end
+
+  # @return [String] statistics message
+  def stat
+    @protocol ? @protocol.statistics_command : 'MySQL server has gone away'
+  end
+
+  # Commit transaction
+  # @return [Mysql] self
+  def commit
+    query 'commit'
+    self
+  end
+
+  # Rollback transaction
+  # @return [Mysql] self
+  def rollback
+    query 'rollback'
+    self
+  end
+
+  # Set autocommit mode
+  # @param [Boolean] flag
+  # @return [Mysql] self
+  def autocommit(flag)
+    query "set autocommit=#{flag ? 1 : 0}"
+    self
+  end
+
+  private
+
+  def check_connection
+    raise ClientError::ServerGoneError, 'MySQL server has gone away' unless @protocol
+  end
+
+  # @!visibility public
+  # Field class
+  class Field
+    # @return [String] database name
+    attr_reader :db
+    # @return [String] table name
+    attr_reader :table
+    # @return [String] original table name
+    attr_reader :org_table
+    # @return [String] field name
+    attr_reader :name
+    # @return [String] original field name
+    attr_reader :org_name
+    # @return [Integer] charset id number
+    attr_reader :charsetnr
+    # @return [Integer] field length
+    attr_reader :length
+    # @return [Integer] field type
+    attr_reader :type
+    # @return [Integer] flag
+    attr_reader :flags
+    # @return [Integer] number of decimals
+    attr_reader :decimals
+    # @return [String] defualt value
+    attr_reader :default
+    alias :def :default
+
+    # @private
+    attr_accessor :result
+
+    # @attr [Protocol::FieldPacket] packet
+    def initialize(packet)
+      @db, @table, @org_table, @name, @org_name, @charsetnr, @length, @type, @flags, @decimals, @default =
+        packet.db, packet.table, packet.org_table, packet.name, packet.org_name, packet.charsetnr, packet.length, packet.type, packet.flags, packet.decimals, packet.default
+      @flags |= NUM_FLAG if is_num_type?
+      @max_length = nil
+    end
+
+    # @return [Hash] field information
+    def hash
+      {
+        "name"       => @name,
+        "table"      => @table,
+        "def"        => @default,
+        "type"       => @type,
+        "length"     => @length,
+        "max_length" => max_length,
+        "flags"      => @flags,
+        "decimals"   => @decimals
+      }
+    end
+
+    # @private
+    def inspect
+      "#<Mysql::Field:#{@name}>"
+    end
+
+    # @return [Boolean] true if numeric field.
+    def is_num?
+      @flags & NUM_FLAG != 0
+    end
+
+    # @return [Boolean] true if not null field.
+    def is_not_null?
+      @flags & NOT_NULL_FLAG != 0
+    end
+
+    # @return [Boolean] true if primary key field.
+    def is_pri_key?
+      @flags & PRI_KEY_FLAG != 0
+    end
+
+    # @return [Integer] maximum width of the field for the result set
+    def max_length
+      return @max_length if @max_length
+      @max_length = 0
+      @result.calculate_field_max_length if @result
+      @max_length
+    end
+
+    attr_writer :max_length
+
+    private
+
+    def is_num_type?
+      [TYPE_DECIMAL, TYPE_TINY, TYPE_SHORT, TYPE_LONG, TYPE_FLOAT, TYPE_DOUBLE, TYPE_LONGLONG, TYPE_INT24].include?(@type) || (@type == TYPE_TIMESTAMP && (@length == 14 || @length == 8))
+    end
+
+  end
+
+  # @!visibility public
+  # Result set
+  class ResultBase
+    include Enumerable
+
+    # @return [Array<Mysql::Field>] field list
+    attr_reader :fields
+
+    # @param [Array of Mysql::Field] fields
+    def initialize(fields)
+      @fields = fields
+      @field_index = 0             # index of field
+      @records = []                # all records
+      @index = 0                   # index of record
+      @fieldname_with_table = nil
+      @fetched_record = nil
+    end
+
+    # ignore
+    # @return [void]
+    def free
+    end
+
+    # @return [Integer] number of record
+    def size
+      @records.size
+    end
+    alias num_rows size
+
+    # @return [Array] current record data
+    def fetch
+      @fetched_record = nil
+      return nil if @index >= @records.size
+      @records[@index] = @records[@index].to_a unless @records[@index].is_a? Array
+      @fetched_record = @records[@index]
+      @index += 1
+      return @fetched_record
+    end
+    alias fetch_row fetch
+
+    # Return data of current record as Hash.
+    # The hash key is field name.
+    # @param [Boolean] with_table if true, hash key is "table_name.field_name".
+    # @return [Hash] current record data
+    def fetch_hash(with_table=nil)
+      row = fetch
+      return nil unless row
+      if with_table and @fieldname_with_table.nil?
+        @fieldname_with_table = @fields.map{|f| [f.table, f.name].join(".")}
+      end
+      ret = {}
+      @fields.each_index do |i|
+        fname = with_table ? @fieldname_with_table[i] : @fields[i].name
+        ret[fname] = row[i]
+      end
+      ret
+    end
+
+    # Iterate block with record.
+    # @yield [Array] record data
+    # @return [self] self. If block is not specified, this returns Enumerator.
+    def each(&block)
+      return enum_for(:each) unless block
+      while rec = fetch
+        block.call rec
+      end
+      self
+    end
+
+    # Iterate block with record as Hash.
+    # @param [Boolean] with_table if true, hash key is "table_name.field_name".
+    # @yield [Hash] record data
+    # @return [self] self. If block is not specified, this returns Enumerator.
+    def each_hash(with_table=nil, &block)
+      return enum_for(:each_hash, with_table) unless block
+      while rec = fetch_hash(with_table)
+        block.call rec
+      end
+      self
+    end
+
+    # Set record position
+    # @param [Integer] n record index
+    # @return [self] self
+    def data_seek(n)
+      @index = n
+      self
+    end
+
+    # @return [Integer] current record position
+    def row_tell
+      @index
+    end
+
+    # Set current position of record
+    # @param [Integer] n record index
+    # @return [Integer] previous position
+    def row_seek(n)
+      ret = @index
+      @index = n
+      ret
+    end
+  end
+
+  # @!visibility public
+  # Result set for simple query
+  class Result < ResultBase
+    # @private
+    # @param [Array<Mysql::Field>] fields
+    # @param [Mysql::Protocol] protocol
+    def initialize(fields, protocol=nil)
+      super fields
+      return unless protocol
+      @records = protocol.retr_all_records fields
+      fields.each{|f| f.result = self}  # for calculating max_field
+    end
+
+    # @private
+    # calculate max_length of all fields
+    def calculate_field_max_length
+      max_length = Array.new(@fields.size, 0)
+      @records.each_with_index do |rec, i|
+        rec = @records[i] = rec.to_a if rec.is_a? RawRecord
+        max_length.each_index do |i|
+          max_length[i] = rec[i].length if rec[i] && rec[i].length > max_length[i]
+        end
+      end
+      max_length.each_with_index do |len, i|
+        @fields[i].max_length = len
+      end
+    end
+
+    # @return [Mysql::Field] current field
+    def fetch_field
+      return nil if @field_index >= @fields.length
+      ret = @fields[@field_index]
+      @field_index += 1
+      ret
+    end
+
+    # @return [Integer] current field position
+    def field_tell
+      @field_index
+    end
+
+    # Set field position
+    # @param [Integer] n field index
+    # @return [Integer] previous position
+    def field_seek(n)
+      ret = @field_index
+      @field_index = n
+      ret
+    end
+
+    # Return specified field
+    # @param [Integer] n field index
+    # @return [Mysql::Field] field
+    def fetch_field_direct(n)
+      raise ClientError, "invalid argument: #{n}" if n < 0 or n >= @fields.length
+      @fields[n]
+    end
+
+    # @return [Array<Mysql::Field>] all fields
+    def fetch_fields
+      @fields
+    end
+
+    # @return [Array<Integer>] length of each fields
+    def fetch_lengths
+      return nil unless @fetched_record
+      @fetched_record.map{|c|c.nil? ? 0 : c.length}
+    end
+
+    # @return [Integer] number of fields
+    def num_fields
+      @fields.size
+    end
+  end
+
+  # @!visibility private
+  # Result set for prepared statement
+  class StatementResult < ResultBase
+    # @private
+    # @param [Array<Mysql::Field>] fields
+    # @param [Mysql::Protocol] protocol
+    # @param [Mysql::Charset] charset
+    def initialize(fields, protocol, charset)
+      super fields
+      @records = protocol.stmt_retr_all_records @fields, charset
+    end
+  end
+
+  # @!visibility public
+  # Prepared statement
+  # @!attribute [r] affected_rows
+  #   @return [Integer]
+  # @!attribute [r] insert_id
+  #   @return [Integer]
+  # @!attribute [r] server_status
+  #   @return [Integer]
+  # @!attribute [r] warning_count
+  #   @return [Integer]
+  # @!attribute [r] param_count
+  #   @return [Integer]
+  # @!attribute [r] fields
+  #   @return [Array<Mysql::Field>]
+  # @!attribute [r] sqlstate
+  #   @return [String]
+  class Stmt
+    include Enumerable
+
+    attr_reader :affected_rows, :insert_id, :server_status, :warning_count
+    attr_reader :param_count, :fields, :sqlstate
+
+    # @private
+    def self.finalizer(protocol, statement_id)
+      proc do
+        protocol.gc_stmt statement_id
+      end
+    end
+
+    # @private
+    # @param [Mysql::Protocol] protocol
+    # @param [Mysql::Charset] charset
+    def initialize(protocol, charset)
+      @protocol = protocol
+      @charset = charset
+      @statement_id = nil
+      @affected_rows = @insert_id = @server_status = @warning_count = 0
+      @sqlstate = "00000"
+      @param_count = nil
+      @bind_result = nil
+    end
+
+    # @private
+    # parse prepared-statement and return {Mysql::Stmt} object
+    # @param [String] str query string
+    # @return self
+    def prepare(str)
+      close
+      begin
+        @sqlstate = "00000"
+        @statement_id, @param_count, @fields = @protocol.stmt_prepare_command(str)
+      rescue ServerError => e
+        @last_error = e
+        @sqlstate = e.sqlstate
+        raise
+      end
+      ObjectSpace.define_finalizer(self, self.class.finalizer(@protocol, @statement_id))
+      self
+    end
+
+    # Execute prepared statement.
+    # @param [Object] values values passed to query
+    # @return [Mysql::Stmt] self
+    def execute(*values)
+      raise ClientError, "not prepared" unless @param_count
+      raise ClientError, "parameter count mismatch" if values.length != @param_count
+      values = values.map{|v| @charset.convert v}
+      begin
+        @sqlstate = "00000"
+        nfields = @protocol.stmt_execute_command @statement_id, values
+        if nfields
+          @fields = @protocol.retr_fields nfields
+          @result = StatementResult.new @fields, @protocol, @charset
+        else
+          @affected_rows, @insert_id, @server_status, @warning_count, @info =
+            @protocol.affected_rows, @protocol.insert_id, @protocol.server_status, @protocol.warning_count, @protocol.message
+        end
+        return self
+      rescue ServerError => e
+        @last_error = e
+        @sqlstate = e.sqlstate
+        raise
+      end
+    end
+
+    # Close prepared statement
+    # @return [void]
+    def close
+      ObjectSpace.undefine_finalizer(self)
+      @protocol.stmt_close_command @statement_id if @statement_id
+      @statement_id = nil
+    end
+
+    # @return [Array] current record data
+    def fetch
+      row = @result.fetch
+      return row unless @bind_result
+      row.zip(@bind_result).map do |col, type|
+        if col.nil?
+          nil
+        elsif [Numeric, Integer, Fixnum].include? type
+          col.to_i
+        elsif type == String
+          col.to_s
+        elsif type == Float && !col.is_a?(Float)
+          col.to_i.to_f
+        elsif type == Mysql::Time && !col.is_a?(Mysql::Time)
+          if col.to_s =~ /\A\d+\z/
+            i = col.to_s.to_i
+            if i < 100000000
+              y = i/10000
+              m = i/100%100
+              d = i%100
+              h, mm, s = 0
+            else
+              y = i/10000000000
+              m = i/100000000%100
+              d = i/1000000%100
+              h = i/10000%100
+              mm= i/100%100
+              s = i%100
+            end
+            if y < 70
+              y += 2000
+            elsif y < 100
+              y += 1900
+            end
+            Mysql::Time.new(y, m, d, h, mm, s)
+          else
+            Mysql::Time.new
+          end
+        else
+          col
+        end
+      end
+    end
+
+    # Return data of current record as Hash.
+    # The hash key is field name.
+    # @param [Boolean] with_table if true, hash key is "table_name.field_name".
+    # @return [Hash] record data
+    def fetch_hash(with_table=nil)
+      @result.fetch_hash with_table
+    end
+
+    # Set retrieve type of value
+    # @param [Numeric / Fixnum / Integer / Float / String / Mysql::Time / nil] args value type
+    # @return [Mysql::Stmt] self
+    def bind_result(*args)
+      if @fields.length != args.length
+        raise ClientError, "bind_result: result value count(#{@fields.length}) != number of argument(#{args.length})"
+      end
+      args.each do |a|
+        raise TypeError unless [Numeric, Fixnum, Integer, Float, String, Mysql::Time, nil].include? a
+      end
+      @bind_result = args
+      self
+    end
+
+    # Iterate block with record.
+    # @yield [Array] record data
+    # @return [Mysql::Stmt] self
+    # @return [Enumerator] If block is not specified
+    def each(&block)
+      return enum_for(:each) unless block
+      while rec = fetch
+        block.call rec
+      end
+      self
+    end
+
+    # Iterate block with record as Hash.
+    # @param [Boolean] with_table if true, hash key is "table_name.field_name".
+    # @yield [Hash] record data
+    # @return [Mysql::Stmt] self
+    # @return [Enumerator] If block is not specified
+    def each_hash(with_table=nil, &block)
+      return enum_for(:each_hash, with_table) unless block
+      while rec = fetch_hash(with_table)
+        block.call rec
+      end
+      self
+    end
+
+    # @return [Integer] number of record
+    def size
+      @result.size
+    end
+    alias num_rows size
+
+    # Set record position
+    # @param [Integer] n record index
+    # @return [void]
+    def data_seek(n)
+      @result.data_seek(n)
+    end
+
+    # @return [Integer] current record position
+    def row_tell
+      @result.row_tell
+    end
+
+    # Set current position of record
+    # @param [Integer] n record index
+    # @return [Integer] previous position
+    def row_seek(n)
+      @result.row_seek(n)
+    end
+
+    # @return [Integer] number of columns for last query
+    def field_count
+      @fields.length
+    end
+
+    # ignore
+    # @return [void]
+    def free_result
+    end
+
+    # Returns Mysql::Result object that is empty.
+    # Use fetch_fields to get list of fields.
+    # @return [Mysql::Result]
+    def result_metadata
+      return nil if @fields.empty?
+      Result.new @fields
+    end
+  end
+
+  # @!visibility public
+  # @!attribute [rw] year
+  #   @return [Integer]
+  # @!attribute [rw] month
+  #   @return [Integer]
+  # @!attribute [rw] day
+  #   @return [Integer]
+  # @!attribute [rw] hour
+  #   @return [Integer]
+  # @!attribute [rw] minute
+  #   @return [Integer]
+  # @!attribute [rw] second
+  #   @return [Integer]
+  # @!attribute [rw] neg
+  #   @return [Boolean] negative flag
+  # @!attribute [rw] second_part
+  #   @return [Integer]
+  class Time
+    # @param [Integer] year
+    # @param [Integer] month
+    # @param [Integer] day
+    # @param [Integer] hour
+    # @param [Integer] minute
+    # @param [Integer] second
+    # @param [Boolean] neg negative flag
+    # @param [Integer] second_part
+    def initialize(year=0, month=0, day=0, hour=0, minute=0, second=0, neg=false, second_part=0)
+      @date_flag = !(hour && minute && second)
+      @year, @month, @day, @hour, @minute, @second, @neg, @second_part =
+        year.to_i, month.to_i, day.to_i, hour.to_i, minute.to_i, second.to_i, neg, second_part.to_i
+    end
+    attr_accessor :year, :month, :day, :hour, :minute, :second, :neg, :second_part
+    alias mon month
+    alias min minute
+    alias sec second
+
+    # @private
+    def ==(other)
+      other.is_a?(Mysql::Time) &&
+        @year == other.year && @month == other.month && @day == other.day &&
+        @hour == other.hour && @minute == other.minute && @second == other.second &&
+        @neg == neg && @second_part == other.second_part
+    end
+
+    # @private
+    def eql?(other)
+      self == other
+    end
+
+    # @return [String] "yyyy-mm-dd HH:MM:SS"
+    def to_s
+      if @date_flag
+        sprintf "%04d-%02d-%02d", year, mon, day
+      elsif year == 0 and mon == 0 and day == 0
+        h = neg ? hour * -1 : hour
+        sprintf "%02d:%02d:%02d", h, min, sec
+      else
+        sprintf "%04d-%02d-%02d %02d:%02d:%02d", year, mon, day, hour, min, sec
+      end
+    end
+
+    # @return [Integer] yyyymmddHHMMSS
+    def to_i
+      sprintf("%04d%02d%02d%02d%02d%02d", year, mon, day, hour, min, sec).to_i
+    end
+
+    # @private
+    def inspect
+      sprintf "#<#{self.class.name}:%04d-%02d-%02d %02d:%02d:%02d>", year, mon, day, hour, min, sec
+    end
+
+  end
+
+end