ruby-mysql2 0.5.4

data/lib/mysql2/client.rb

@@ -0,0 +1,461 @@
+module Mysql2
+  class Client
+    Mysql.constants.each do |c|
+      case c.to_s
+      when /\ACLIENT_/
+        self.const_set($', Mysql.const_get(c))
+      when /\ASSL_MODE_|\AOPTION_MULTI_STATEMENTS_/
+        self.const_set(c, Mysql.const_get(c))
+      when /\ASESSION_TRACK_/
+        self.const_set(c, Mysql.const_get(c))
+      end
+    end
+
+    attr_reader :query_options, :read_timeout
+
+    def self.default_query_options
+      @default_query_options ||= {
+        as: :hash,                   # the type of object you want each row back as; also supports :array (an array of values)
+        async: false,                # don't wait for a result after sending the query, you'll have to monitor the socket yourself then eventually call Mysql2::Client#async_result
+        cast_booleans: false,        # cast tinyint(1) fields as true/false in ruby
+        symbolize_keys: false,       # return field names as symbols instead of strings
+        database_timezone: :local,   # timezone Mysql2 will assume datetime objects are stored in
+        application_timezone: nil,   # timezone Mysql2 will convert to before handing the object back to the caller
+        cache_rows: true,            # tells Mysql2 to use its internal row cache for results
+        connect_flags: REMEMBER_OPTIONS | LONG_PASSWORD | LONG_FLAG | TRANSACTIONS | PROTOCOL_41 | SECURE_CONNECTION | CONNECT_ATTRS,
+        cast: true,
+        default_file: nil,
+        default_group: nil,
+      }
+    end
+
+    def self.escape(s)
+      s2 = Mysql.quote(s)
+      s.size == s2.size ? s : s2
+    end
+
+    def self.info
+      {
+        id: Mysql::VERSION.split('.').each_with_index.map{|v, i| v.to_i * 100**(2-i)}.sum,
+        version: Mysql::VERSION.encode('us-ascii'),
+        header_version: Mysql::VERSION.encode('us-ascii'),
+      }
+    end
+
+    def self.finalizer(mysql, finalizer_opts)
+      proc do
+        if finalizer_opts[:automatic_close]
+          mysql.close rescue nil
+        else
+          mysql.close! rescue nil
+        end
+      end
+    end
+
+    class ::Mysql
+      def async_query(str, **)
+        check_connection
+        @fields = nil
+        @protocol.query_command str
+        return self
+      rescue ServerError => e
+        @last_error = e
+        @sqlstate = e.sqlstate
+        raise
+      end
+
+      def async_query_result(**opts)
+        @protocol.get_result
+        store_result(**opts)
+      rescue ServerError => e
+        @last_error = e
+        @sqlstate = e.sqlstate
+        raise
+      end
+    end
+
+    attr_accessor :reconnect
+
+    def initialize(opts = {})
+      raise Mysql2::Error, "Options parameter must be a Hash" unless opts.is_a? Hash
+      opts = Mysql2::Util.key_hash_as_symbols(opts)
+      @read_timeout = nil
+      @query_options = self.class.default_query_options.dup
+      @query_options.merge! opts
+      @automatic_close = true
+
+      @mutex = Mutex.new
+      @mysql = Mysql.new
+
+      # Set default connect_timeout to avoid unlimited retries from signal interruption
+      opts[:connect_timeout] = 120 unless opts.key?(:connect_timeout)
+
+      # TODO: stricter validation rather than silent massaging
+      %i[reconnect connect_timeout local_infile read_timeout write_timeout default_file default_group secure_auth init_command automatic_close enable_cleartext_plugin default_auth].each do |key|
+        next unless opts.key?(key)
+        case key
+        when :reconnect
+          send(:"#{key}=", !!opts[key]) # rubocop:disable Style/DoubleNegation
+        when :automatic_close
+          @automatic_close = opts[key]
+        when :local_infile, :secure_auth, :enable_cleartext_plugin
+          @mysql.send(:"#{key}=", !!opts[key]) # rubocop:disable Style/DoubleNegation
+        when :connect_timeout, :read_timeout, :write_timeout
+          t = opts[key]
+          if t
+            raise Mysql2::Error, 'time interval must not be negative' if t < 0
+            t = 0.0000001 if t == 0
+            @mysql.send(:"#{key}=", t)
+          end
+        else
+          @mysql.send(:"#{key}=", opts[key])
+        end
+      end
+
+      # force the encoding to utf8
+      self.charset_name = opts[:encoding] || 'utf8'
+
+      mode = parse_ssl_mode(opts[:ssl_mode]) if opts[:ssl_mode]
+      if (mode == SSL_MODE_VERIFY_CA || mode == SSL_MODE_VERIFY_IDENTITY) && !opts[:sslca]
+        opts[:sslca] = find_default_ca_path
+      end
+
+      ssl_options = {}
+      ssl_options[:key] = OpenSSL::PKey::RSA.new(File.read(opts[:sslkey])) if opts[:sslkey]
+      ssl_options[:cert] = OpenSSL::X509::Certificate.new(File.read(opts[:sslcert])) if opts[:sslcert]
+      ssl_options[:ca_file] = opts[:sslca] if opts[:sslca]
+      ssl_options[:ca_path] = opts[:sslcapath] if opts[:sslcapath]
+      ssl_options[:ciphers] = opts[:sslcipher] if opts[:sslcipher]
+      @mysql.ssl_context_params = ssl_options if ssl_options.any? || opts.key?(:sslverify)
+      @mysql.ssl_mode = mode if mode
+
+      flags = case opts[:flags]
+      when Array
+        parse_flags_array(opts[:flags], @query_options[:connect_flags])
+      when String
+        parse_flags_array(opts[:flags].split(' '), @query_options[:connect_flags])
+      when Integer
+        @query_options[:connect_flags] | opts[:flags]
+      else
+        @query_options[:connect_flags]
+      end
+
+      # SSL verify is a connection flag rather than a mysql_ssl_set option
+      flags |= SSL_VERIFY_SERVER_CERT if opts[:sslverify]
+
+      if %i[user pass hostname dbname db sock].any? { |k| @query_options.key?(k) }
+        warn "============= WARNING FROM mysql2 ============="
+        warn "The options :user, :pass, :hostname, :dbname, :db, and :sock are deprecated and will be removed at some point in the future."
+        warn "Instead, please use :username, :password, :host, :port, :database, :socket, :flags for the options."
+        warn "============= END WARNING FROM mysql2 ========="
+      end
+
+      user     = opts[:username] || opts[:user]
+      pass     = opts[:password] || opts[:pass]
+      host     = opts[:host] || opts[:hostname]
+      port     = opts[:port]
+      database = opts[:database] || opts[:dbname] || opts[:db]
+      socket   = opts[:socket] || opts[:sock]
+
+      # Correct the data types before passing these values down to the C level
+      user = user.to_s unless user.nil?
+      pass = pass.to_s unless pass.nil?
+      host = host.to_s unless host.nil?
+      port = port.to_i unless port.nil?
+      database = database.to_s unless database.nil?
+      socket = socket.to_s unless socket.nil?
+      conn_attrs = parse_connect_attrs(opts[:connect_attrs])
+
+      connect user, pass, host, port, database, socket, flags, conn_attrs
+      @finalizer_opts = {automatic_close: @automatic_close}
+      ObjectSpace.define_finalizer(self, self.class.finalizer(@mysql, @finalizer_opts))
+    rescue Mysql::Error => e
+      raise Mysql2::Error.new(e.message, @mysql&.server_version, e.errno, e.sqlstate)
+    rescue Errno::ECONNREFUSED => e
+      raise Mysql2::Error::ConnectionError, e.message
+    end
+
+    def connect(user, pass, host, port, database, socket, flags, conn_attrs)
+      @conn_params ||= [ user, pass, host, port, database, socket, flags, conn_attrs ]
+      @mysql.connect(host, user, pass, database, port, socket, flags, connect_attrs: conn_attrs)
+    rescue Mysql::Error => e
+      raise Mysql2::Error::ConnectionError, e.message
+    end
+
+    def close
+      @mysql.close rescue nil
+      nil
+    end
+
+    def closed?
+      s = @mysql.protocol&.instance_variable_get(:@socket)
+      s ? s.closed? : true
+    end
+
+    def charset_name=(cs)
+      unless cs.is_a? String
+        raise TypeError, "wrong argument type Symbol (expected String)"
+      end
+      @mysql.charset = cs
+    rescue Mysql::Error => e
+      raise Mysql2::Error.new(e.message, @mysql&.server_version, e.errno, e.sqlstate)
+    end
+
+    def encoding
+      Mysql::Charset::CHARSET_ENCODING[@mysql.character_set_name]
+    end
+
+    def escape(s)
+      self.class.escape(s)
+    end
+
+    def more_results?
+      @mysql.more_results?
+    end
+
+    def next_result
+      !! @mysql.next_result(return_result: false)
+    rescue Mysql::Error => e
+      raise Mysql2::Error.new(e.message, @mysql&.server_version, e.errno, e.sqlstate)
+    end
+
+    def abandon_results!
+      while more_results?
+        next_result
+        store_result
+      end
+    end
+
+    def store_result
+      res = @mysql.store_result
+      reset_active_thread
+      res && Result.new(res, @current_query_options)
+    end
+
+    def async_result
+      current_thread_active?
+      res = @mysql.async_query_result
+      reset_active_thread
+      Result.new(res, @current_query_options)
+    end
+
+    def affected_rows
+      @mysql.affected_rows
+    end
+
+    def parse_ssl_mode(mode)
+      m = mode.to_s.upcase
+      if m.start_with?('SSL_MODE_')
+        return Mysql2::Client.const_get(m) if Mysql2::Client.const_defined?(m)
+      else
+        x = 'SSL_MODE_' + m
+        return Mysql2::Client.const_get(x) if Mysql2::Client.const_defined?(x)
+      end
+      warn "Unknown MySQL ssl_mode flag: #{mode}"
+    end
+
+    def ssl_cipher
+      @mysql.protocol&.ssl_cipher&.first
+    end
+
+    def parse_flags_array(flags, initial = 0)
+      flags.reduce(initial) do |memo, f|
+        fneg = f.start_with?('-') ? f[1..-1] : nil
+        if fneg && fneg =~ /^\w+$/ && Mysql2::Client.const_defined?(fneg)
+          memo & ~ Mysql2::Client.const_get(fneg)
+        elsif f && f =~ /^\w+$/ && Mysql2::Client.const_defined?(f)
+          memo | Mysql2::Client.const_get(f)
+        else
+          warn "Unknown MySQL connection flag: '#{f}'"
+          memo
+        end
+      end
+    end
+
+    # Find any default system CA paths to handle system roots
+    # by default if stricter validation is requested and no
+    # path is provide.
+    def find_default_ca_path
+      [
+        "/etc/ssl/certs/ca-certificates.crt",
+        "/etc/pki/tls/certs/ca-bundle.crt",
+        "/etc/ssl/ca-bundle.pem",
+        "/etc/ssl/cert.pem",
+      ].find { |f| File.exist?(f) }
+    end
+
+    # Set default program_name in performance_schema.session_connect_attrs
+    # and performance_schema.session_account_connect_attrs
+    def parse_connect_attrs(conn_attrs)
+      return {} if Mysql2::Client::CONNECT_ATTRS.zero?
+      conn_attrs ||= {}
+      conn_attrs[:program_name] ||= $PROGRAM_NAME
+      conn_attrs.each_with_object({}) do |(key, value), hash|
+        hash[key.to_s] = value.to_s
+      end
+    end
+
+    def set_active_thread
+      @mutex.synchronize do
+        if @active_thread
+          if @active_thread == Thread.current
+            raise Mysql2::Error, 'This connection is still waiting for a result, try again once you have the result'
+          else
+            raise Mysql2::Error, "This connection is in use by: #{@active_thread.inspect}"
+          end
+        end
+        @active_thread = Thread.current
+      end
+    end
+
+    def reset_active_thread
+      @mutex.synchronize do
+        @active_thread = nil
+      end
+    end
+
+    def current_thread_active?
+      unless Thread.current == @active_thread
+        raise Mysql2::Error, 'This connection is still waiting for a result, try again once you have the result'
+      end
+    end
+
+    def query(sql, options = {})
+      if @reconnect && @mysql.protocol && closed?
+        connect(*@conn_params)
+      end
+      raise TypeError, "wrong argument type #{sql.class} (expected String)" unless sql.is_a? String
+      raise Mysql2::Error, 'MySQL client is not connected' if closed?
+      set_active_thread
+      @current_query_options = @query_options.merge(options)
+      Thread.handle_interrupt(::Mysql2::Util::TIMEOUT_ERROR_NEVER) do
+        if options[:async]
+          @mysql.async_query(sql, auto_store_result: !options[:stream], **options)
+          return nil
+        end
+        res = @mysql.query(sql, auto_store_result: !options[:stream], **options)
+        reset_active_thread
+        return res && Result.new(res, @current_query_options)
+      end
+    rescue Mysql::Error => e
+      reset_active_thread
+      if e.message =~ /timeout$/
+        raise Mysql2::Error::TimeoutError, e.message
+      else
+        raise Mysql2::Error.new(e.message, @mysql&.server_version, e.errno, e.sqlstate)
+      end
+    rescue Errno::ENOENT => e
+      reset_active_thread
+      raise Mysql2::Error, e.message
+    rescue
+      reset_active_thread
+      @mysql&.protocol&.close
+      raise
+    end
+
+    def row_to_hash(res, fields, &block)
+      res.each do |row|
+        h = {}
+        fields.each_with_index do |f, i|
+          key = @current_query_options[:symbolize_keys] ? f.name.intern : f.name
+          h[key] = convert_type(row[i], f.type)
+        end
+        block.call h
+      end
+    end
+
+    def query_info
+      info = query_info_string
+      return {} unless info
+      info_hash = {}
+      info.split.each_slice(2) { |s| info_hash[s[0].downcase.delete(':').to_sym] = s[1].to_i }
+      info_hash
+    end
+
+    def query_info_string
+      @mysql.info
+    end
+
+    def info
+      self.class.info
+    end
+
+    def server_info
+      {
+        id: @mysql.server_version,
+        version: @mysql.server_info.encode(Encoding.default_internal || encoding),
+      }
+    rescue => e
+      raise Mysql2::Error, e.message
+    end
+
+    def last_id
+      @mysql.insert_id
+    end
+
+    def ping
+      @mysql.ping
+      true
+    rescue
+      false
+    end
+
+    def thread_id
+      @mysql.thread_id
+    end
+
+    def select_db(db)
+      query("use `#{db}`")
+      db
+    end
+
+    def set_server_option(opt)
+      @mysql.set_server_option(opt)
+      true
+    rescue Mysql::Error => e
+      return false if e.message == 'Unknown command'
+      raise Mysql2::Error.new(e.message, @mysql&.server_version, e.errno, e.sqlstate)
+    end
+
+    def warning_count
+      @mysql.warning_count
+    end
+
+    def socket
+      raise Mysql2::Error, 'MySQL client is not connected' if closed?
+      @mysql.protocol.instance_variable_get(:@socket).fileno
+    end
+
+    def automatic_close
+      @automatic_close
+    end
+
+    def automatic_close=(f)
+      @automatic_close = f
+      @finalizer_opts[:automatic_close] = f
+    end
+
+    def automatic_close?
+      @automatic_close ? true : false
+    end
+
+    def prepare(*args)
+      st = @mysql.prepare(*args)
+      Statement.new(st, **@query_options)
+    rescue Mysql::Error => e
+      raise Mysql2::Error.new(e.message, @mysql&.server_version, e.errno, e.sqlstate)
+    end
+
+    def session_track(type)
+      @mysql.session_track[type]&.flatten
+    end
+
+    class << self
+      private
+
+      def local_offset
+        ::Time.local(2010).utc_offset.to_r / 86400
+      end
+    end
+  end
+end

data/lib/mysql2/console.rb

@@ -0,0 +1,5 @@
+# Loaded by script/console. Land helpers here.
+
+Pry.config.prompt = lambda do |context, *|
+  "[mysql2] #{context}> "
+end

data/lib/mysql2/error.rb

@@ -0,0 +1,101 @@
+module Mysql2
+  class Error < StandardError
+    ENCODE_OPTS = {
+      undef: :replace,
+      invalid: :replace,
+      replace: '?'.freeze,
+    }.freeze
+
+    ConnectionError = Class.new(Error)
+    TimeoutError = Class.new(Error)
+
+    CODES = {
+      1205 => TimeoutError, # ER_LOCK_WAIT_TIMEOUT
+
+      1044 => ConnectionError, # ER_DBACCESS_DENIED_ERROR
+      1045 => ConnectionError, # ER_ACCESS_DENIED_ERROR
+      1152 => ConnectionError, # ER_ABORTING_CONNECTION
+      1153 => ConnectionError, # ER_NET_PACKET_TOO_LARGE
+      1154 => ConnectionError, # ER_NET_READ_ERROR_FROM_PIPE
+      1155 => ConnectionError, # ER_NET_FCNTL_ERROR
+      1156 => ConnectionError, # ER_NET_PACKETS_OUT_OF_ORDER
+      1157 => ConnectionError, # ER_NET_UNCOMPRESS_ERROR
+      1158 => ConnectionError, # ER_NET_READ_ERROR
+      1159 => ConnectionError, # ER_NET_READ_INTERRUPTED
+      1160 => ConnectionError, # ER_NET_ERROR_ON_WRITE
+      1161 => ConnectionError, # ER_NET_WRITE_INTERRUPTED
+      1927 => ConnectionError, # ER_CONNECTION_KILLED
+
+      2001 => ConnectionError, # CR_SOCKET_CREATE_ERROR
+      2002 => ConnectionError, # CR_CONNECTION_ERROR
+      2003 => ConnectionError, # CR_CONN_HOST_ERROR
+      2004 => ConnectionError, # CR_IPSOCK_ERROR
+      2005 => ConnectionError, # CR_UNKNOWN_HOST
+      2006 => ConnectionError, # CR_SERVER_GONE_ERROR
+      2007 => ConnectionError, # CR_VERSION_ERROR
+      2009 => ConnectionError, # CR_WRONG_HOST_INFO
+      2012 => ConnectionError, # CR_SERVER_HANDSHAKE_ERR
+      2013 => ConnectionError, # CR_SERVER_LOST
+      2020 => ConnectionError, # CR_NET_PACKET_TOO_LARGE
+      2026 => ConnectionError, # CR_SSL_CONNECTION_ERROR
+      2027 => ConnectionError, # CR_MALFORMED_PACKET
+      2047 => ConnectionError, # CR_CONN_UNKNOW_PROTOCOL
+      2048 => ConnectionError, # CR_INVALID_CONN_HANDLE
+      2049 => ConnectionError, # CR_UNUSED_1
+    }.freeze
+
+    attr_reader :error_number, :sql_state
+
+    # Mysql gem compatibility
+    alias errno error_number
+    alias error message
+
+    def initialize(msg, server_version = nil, error_number = nil, sql_state = nil)
+      @server_version = server_version
+      @error_number = error_number
+      @sql_state = sql_state ? sql_state.encode('ascii', **ENCODE_OPTS) : nil
+
+      super(clean_message(msg))
+    end
+
+    def self.new_with_args(msg, server_version, error_number, sql_state)
+      error_class = CODES.fetch(error_number, self)
+      error_class.new(msg, server_version, error_number, sql_state)
+    end
+
+    private
+
+    # In MySQL 5.5+ error messages are always constructed server-side as UTF-8
+    # then returned in the encoding set by the `character_set_results` system
+    # variable.
+    #
+    # See http://dev.mysql.com/doc/refman/5.5/en/charset-errors.html for
+    # more context.
+    #
+    # Before MySQL 5.5 error message template strings are in whatever encoding
+    # is associated with the error message language.
+    # See http://dev.mysql.com/doc/refman/5.1/en/error-message-language.html
+    # for more information.
+    #
+    # The issue is that the user-data inserted in the message could potentially
+    # be in any encoding MySQL supports and is insert into the latin1, euckr or
+    # koi8r string raw. Meaning there's a high probability the string will be
+    # corrupt encoding-wise.
+    #
+    # See http://dev.mysql.com/doc/refman/5.1/en/charset-errors.html for
+    # more information.
+    #
+    # So in an attempt to make sure the error message string is always in a valid
+    # encoding, we'll assume UTF-8 and clean the string of anything that's not a
+    # valid UTF-8 character.
+    #
+    # Returns a valid UTF-8 string.
+    def clean_message(message)
+      if @server_version && @server_version > 50500
+        message.encode(**ENCODE_OPTS)
+      else
+        message.encode(Encoding::UTF_8, **ENCODE_OPTS)
+      end
+    end
+  end
+end

data/lib/mysql2/field.rb

@@ -0,0 +1,3 @@
+module Mysql2
+  Field = Struct.new(:name, :type)
+end