ruby-mysql 3.0.1 → 4.0.0

data/lib/mysql/result.rb

@@ -0,0 +1,212 @@
+class Mysql
+  # @!visibility public
+  # Result set
+  class ResultBase
+    include Enumerable
+
+    # @return [Array<Mysql::Field>] field list
+    attr_reader :fields
+    alias fetch_fields fields
+
+    # @return [Mysql::StatementResult]
+    attr_reader :result
+
+    # @param [Array of Mysql::Field] fields
+    def initialize(fields, protocol, record_class, **opts)
+      @fields = fields
+      @field_index = 0             # index of field
+      @records = []                # all records
+      @index = 0                   # index of record
+      @fieldname_with_table = nil
+      @protocol = protocol
+      @record_class = record_class
+      @opts = opts
+    end
+
+    def retrieve
+      @records = @protocol.retr_all_records(@record_class)
+    end
+
+    # ignore
+    # @return [void]
+    def free
+      # dummy
+    end
+
+    # @return [Integer] number of record
+    def size
+      @records.size
+    end
+    alias num_rows size
+
+    # @return [Array] current record data
+    def fetch(**)
+      if @index < @records.size
+        @records[@index] = @records[@index].to_a unless @records[@index].is_a? Array
+        @index += 1
+        return @records[@index-1]
+      end
+      rec = @protocol.retr_record(@record_class)&.to_a
+      return nil unless rec
+      @records[@index] = rec
+      @index += 1
+      return rec
+    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(**opts)
+      row = fetch(**opts)
+      return nil unless row
+      with_table = @opts.merge(opts)[:with_table]
+      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(**opts, &block)
+      @index = 0
+      return enum_for(:each, **opts) unless block
+      while (rec = fetch(**opts))
+        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(**opts, &block)
+      @index = 0
+      return enum_for(:each_hash, **opts) unless block
+      while (rec = fetch_hash(**opts))
+        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
+
+    # Server status value
+    # @return [Integer] server status value
+    def server_status
+      @protocol.server_status
+    end
+  end
+
+  # @!visibility public
+  # Result set for simple query
+  class Result < ResultBase
+    # @private
+    # @param [Array<Mysql::Field>] fields
+    # @param [Mysql::Protocol] protocol
+    # @param [Boolean] auto_store_result
+    def initialize(fields, protocol=nil, **opts)
+      super fields, protocol, RawRecord, **opts
+      return unless protocol
+      fields.each{|f| f.result = self}  # for calculating max_field
+      retrieve if @opts.merge(opts)[:auto_store_result]
+    end
+
+    def fetch(**opts)
+      rec = super
+      rec = rec.map.with_index{|s, i| convert_type(@fields[i], s)} if rec && @opts.merge(opts)[:cast]
+      rec
+    end
+    alias fetch_row fetch
+
+    # @private
+    # calculate max_length of all fields
+    def calculate_field_max_length
+      return unless @records
+      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 |j|
+          max_length[j] = rec[j].to_s.length if rec[j] && rec[j].to_s.length > max_length[j]
+        end
+      end
+      max_length.each_with_index do |len, i|
+        @fields[i].max_length = len
+      end
+    end
+
+    private
+
+    def convert_type(f, s)
+      return nil if s.nil?
+      case f.type
+      when Field::TYPE_STRING, Field::TYPE_VAR_STRING, Field::TYPE_BLOB, Field::TYPE_JSON
+        s
+      when Field::TYPE_NEWDECIMAL
+        s =~ /\./ && s !~ /\.0*\z/ ? BigDecimal(s) : s.to_i
+      when Field::TYPE_TINY, Field::TYPE_SHORT, Field::TYPE_INT24, Field::TYPE_LONG, Field::TYPE_LONGLONG
+        s.to_i
+      when Field::TYPE_FLOAT, Field::TYPE_DOUBLE
+        s.to_f
+      when Field::TYPE_DATE
+        Date.parse(s) rescue nil
+      when Field::TYPE_DATETIME, Field::TYPE_TIMESTAMP
+        Time.parse(s) rescue nil
+      when Field::TYPE_TIME
+        h, m, sec = s.split(/:/)
+        if s =~ /\A-/
+          h.to_i*3600 - m.to_i*60 - sec.to_f
+        else
+          h.to_i*3600 + m.to_i*60 + sec.to_f
+        end
+      when Field::TYPE_YEAR
+        s.to_i
+      when Field::TYPE_BIT
+        s.b
+      else
+        s.b
+      end
+    end
+  end
+
+  # @!visibility private
+  # Result set for prepared statement
+  class StatementResult < ResultBase
+    # @private
+    # @param [Array<Mysql::Field>] fields
+    # @param [Mysql::Protocol] protocol
+    def initialize(fields, protocol, **opts)
+      super fields, protocol, StmtRawRecord, **opts
+      retrieve if @opts.merge(opts)[:auto_store_result]
+    end
+  end
+end

data/lib/mysql/stmt.rb

@@ -0,0 +1,219 @@
+class Mysql
+  # @!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, :info, :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
+    def initialize(protocol, **opts)
+      @protocol = protocol
+      @opts = opts
+      @statement_id = nil
+      @affected_rows = @insert_id = @server_status = @warning_count = 0
+      @sqlstate = "00000"
+      @param_count = nil
+    end
+
+    # @private
+    # parse prepared-statement and return {Mysql::Stmt} object
+    # @param [String] str query string
+    # @return self
+    def prepare(str)
+      raise ClientError, 'MySQL client is not connected' unless @protocol
+      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::Result] if return_result is true and the query returns result set.
+    # @return [nil] if return_result is true and the query does not return result set.
+    # @return [self] if return_result is false or block is specified.
+    def execute(*values, **opts, &block)
+      raise ClientError, "Invalid statement handle" unless @statement_id
+      raise ClientError, "not prepared" unless @param_count
+      raise ClientError, "parameter count mismatch" if values.length != @param_count
+      values = values.map{|v| @protocol.charset.convert v}
+      opts = @opts.merge(opts)
+      begin
+        @sqlstate = "00000"
+        @protocol.stmt_execute_command @statement_id, values
+        @fields = @result = nil
+        if block
+          while true
+            get_result
+            res = store_result(**opts)
+            block.call res if res || opts[:yield_null_result]
+            break unless more_results?
+          end
+          return self
+        end
+        get_result
+        return self unless opts[:return_result]
+        return store_result(**opts)
+      rescue ServerError => e
+        @last_error = e
+        @sqlstate = e.sqlstate
+        raise
+      end
+    end
+
+    def get_result
+      @protocol.get_result
+      @affected_rows, @insert_id, @server_status, @warning_count, @info =
+        @protocol.affected_rows, @protocol.insert_id, @protocol.server_status, @protocol.warning_count, @protocol.message
+    end
+
+    def store_result(**opts)
+      return nil if @protocol.field_count.nil? || @protocol.field_count == 0
+      @fields = @protocol.retr_fields
+      opts = @opts.merge(opts)
+      @result = StatementResult.new(@fields, @protocol, **opts)
+    end
+
+    def more_results?
+      @protocol.more_results?
+    end
+
+    # execute next query if precedure is called.
+    # @return [Mysql::StatementResult] result set of query if return_result is true.
+    # @return [true] if return_result is false and result exists.
+    # @return [nil] query returns no results or no more results.
+    def next_result(**opts)
+      return nil unless more_results?
+      opts = @opts.merge(opts)
+      @fields = @result = nil
+      get_result
+      return self unless opts[:return_result]
+      return store_result(**opts)
+    rescue ServerError => e
+      @last_error = e
+      @sqlstate = e.sqlstate
+      raise
+    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(**opts)
+      @result.fetch(**opts)
+    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(**opts)
+      @result.fetch_hash(**opts)
+    end
+
+    # Iterate block with record.
+    # @yield [Array] record data
+    # @return [Mysql::Stmt] self
+    # @return [Enumerator] If block is not specified
+    def each(**opts, &block)
+      return enum_for(:each, **opts) unless block
+      while (rec = fetch(*opts))
+        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(**opts, &block)
+      return enum_for(:each_hash, **opts) unless block
+      while (rec = fetch_hash(**opts))
+        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
+      # dummy
+    end
+
+    # Returns Mysql::Result object that is empty.
+    # Use fields to get list of fields.
+    # @return [Mysql::Result]
+    def result_metadata
+      return nil if @fields.empty?
+      Result.new @fields
+    end
+  end
+end