tmtm-ruby-mysql 3.0.0 → 3.0.1

data/ChangeLog

@@ -1,3 +1,20 @@
-== 3.0.0 / 2009-03-22
+2009-07-12  TOMITA Masahiro  <tommy@tmtm.org>
 
-* initial release for v3.0.
+	* version 3.0.1-alpha
+
+2009-07-10  TOMITA Masahiro  <tommy@tmtm.org>
+
+	* lib/mysql/compat.rb: updated.
+
+	* lib/mysql.rb: Mysql#query without parameter no longer use prepared statement.
+	Mysql::Statement#execute returns Mysql::Result.
+	Mysql::Statement no longer have some methods: fetch_row(), fetch_hash(), each(), each_hash().
+	Mysql::Result#fetch returns value that converted to Ruby object.
+	
+2009-04-12  TOMITA Masahiro  <tommy@tmtm.org>
+
+	* for Ruby 1.8.6
+
+2009-03-22  TOMITA Masahiro  <tommy@tmtm.org>
+
+	* Version 3.0.0-alpha

data/README

@@ -3,7 +3,7 @@
 == Description
 MySQL connector for Ruby.
 
-ALPHA バージョンです。将来のバージョンで互換がない変更がされる可能性あります。
+ALPHA バージョンです。将来のバージョンで互換がない変更がされる可能性があります。
 
 == Installation
 
@@ -18,13 +18,14 @@ ALPHA バージョンです。将来のバージョンで互換がない変更
 * Ruby だけで書かれているのでコンパイル不要です。
 * Ruby 1.9 の M17N に対応しています。
 * Ruby/MySQL 0.x, MySQL/Ruby 2.x とは互換がありません。
+  require "mysql/compat" すれば、MySQL/Ruby 2.x 用のプログラムもそこそこ動くかもしれません。
 * 英語ドキュメントがありません。
 
 == Synopsis
 
 使用例:
 
- Mysql.connect("mysql://username@password:hostname:3306/dbname") do |my|
+ Mysql.connect("mysql://username:password@hostname:3306/dbname") do |my|
    my.query("select col1, col2 from tblname").each do |col1, col2|
      p col1, col2
    end

data/lib/mysql/charset.rb

@@ -1,7 +1,7 @@
 # Copyright (C) 2008 TOMITA Masahiro
 # mailto:tommy@tmtm.org
 
-require "mysql/error"
+require "#{File.dirname __FILE__}/error"
 
 class Mysql
   class Charset

data/lib/mysql/compat.rb

@@ -5,11 +5,20 @@
 
 class Mysql
   class << self
-    alias connect new
-    alias real_connect new
+
+    def connect(*args)
+      my = self.allocate
+      my.instance_eval{initialize}
+      my.connect(*args)
+      my
+    end
+    alias new connect
+    alias real_connect connect
 
     def init
-      self.allocate
+      my = self.allocate
+      my.instance_eval{initialize}
+      my
     end
 
     def client_version
@@ -35,24 +44,31 @@ class Mysql
     alias quote escape_string
   end
 
-  alias orig_initialize initialize
-  alias stmt_init stmt
-  alias query simple_query
+  attr_accessor :query_with_result, :reconnect
+
+  alias stmt_init statement
+  alias real_connect connect
+  alias initialize_orig initialize
 
   def initialize(*args)
-    if args.first.is_a? Hash || defined?(URI) && args.first.is_a?(URI) || args.first =~ /\Amysql:\/\//
-      orig_initialize *args
-    else
-      host, user, password, db, port, socket, flag = args
-      orig_initialize :host=>host, :user=>user, :password=>password, :db=>db, :port=>port, :socket=>socket, :flag=>flag
-    end
+    initialize_orig(*args)
+    @query_with_result = true
+    @reconnect = false
   end
 
-  def connect(host, user, password, db, port, socket, flag)
-    initialize :host=>host, :user=>user, :password=>password, :db=>db, :port=>port, :socket=>socket, :flag=>flag
-    self
+  def query(str)
+    res = simple_query str
+    if res
+      res.each do |rec|
+        rec.map!{|v| v && v.to_s}
+        rec.each_index do |i|
+          @fields[i].max_length = [rec[i] ? rec[i].length : 0, @fields[i].max_length||0].max
+        end
+      end
+      res.data_seek 0
+    end
+    res
   end
-  alias real_connect connect
 
   def client_version
     self.class.client_version
@@ -102,10 +118,6 @@ class Mysql
     self
   end
 
-  def sqlstate
-    @stream ? @stream.sqlstate : "00000"
-  end
-
   def store_result
     raise ClientError, "no result set" unless @fields
     Result.new @fields, @stream
@@ -117,6 +129,12 @@ class Mysql
   end
 
   class Result
+    alias initialize_orig initialize
+    def initialize(*args)
+      initialize_orig *args
+      @field_index = 0
+    end
+
     def num_rows
       @records.length
     end
@@ -139,6 +157,11 @@ class Mysql
       # do nothing
     end
 
+    alias fetch_row_orig fetch_row
+    def fetch_row
+      @fetched_record = fetch_row_orig
+    end
+
     def fetch_field
       return nil if @field_index >= @fields.length
       ret = @fields[@field_index]
@@ -173,23 +196,54 @@ class Mysql
     end
   end
 
+  class Field
+    attr_accessor :max_length
+    def hash
+      {
+        "name"       => @name,
+        "table"      => @table,
+        "def"        => @default,
+        "type"       => @type,
+        "length"     => @length,
+        "max_length" => @max_length,
+        "flags"      => @flags,
+        "decimals"   => @decimals
+      }
+    end
+    def inspect
+      "#<Mysql::Field:#{@name}>"
+    end
+  end
+
   class Statement
+    alias execute_orig execute
+    def execute(*args)
+      @res = execute_orig *args
+    end
+
+    def fetch
+      @res.fetch
+    end
+    alias fetch_row fetch
+
+    def each(*args, &block)
+      @res.each(*args, &block)
+    end
+
     def num_rows
-      @records.length
+      @res.num_rows
     end
 
     def data_seek(n)
-      @index = n
+      @res.data_seek(n)
     end
 
     def row_tell
-      @index
+      @res.row_tell
     end
 
     def row_seek(n)
-      ret = @index
-      @index = n
-      ret
+      @res.row_seek(n)
     end
 
     def field_count
@@ -202,7 +256,11 @@ class Mysql
 
     def result_metadata
       return nil if @fields.empty?
-      Result.new @fields, nil, false
+      res = Result.allocate
+      res.instance_variable_set :@mysql, @mysql
+      res.instance_variable_set :@fields, @fields
+      res.instance_variable_set :@records, []
+      res
     end
   end
   Stmt = Statement

data/lib/mysql/protocol.rb

@@ -52,7 +52,7 @@ class Mysql
         lcb[0, 9] = ""
         return (v2 << 32) | v1
       else
-        return ord! lcb
+        return ord!(lcb)
       end
     end
 
@@ -432,9 +432,9 @@ class Mysql
           affected_rows = Protocol.lcb2int! data
           insert_id = Protocol.lcb2int!(data)
           server_status, warning_count, message = data.unpack("vva*")
-          return self.new field_count, affected_rows, insert_id, server_status, warning_count, message
+          return self.new(field_count, affected_rows, insert_id, server_status, warning_count, message)
         else
-          return self.new field_count
+          return self.new(field_count)
         end
       end
 
@@ -457,7 +457,7 @@ class Mysql
         f0, charsetnr, length, type, flags, decimals, f1, data = data.unpack("CvVCvCva*")
         raise ProtocolError, "invalid packet: f1=#{f1}" unless f1 == 0
         default = Protocol.lcs2str! data
-        return self.new db, table, org_table, name, org_name, charsetnr, length, type, flags, decimals, default
+        return self.new(db, table, org_table, name, org_name, charsetnr, length, type, flags, decimals, default)
       end
 
       attr_accessor :db, :table, :org_table, :name, :org_name, :charsetnr, :length, :type, :flags, :decimals, :default

data/lib/mysql.rb

@@ -1,16 +1,26 @@
-# Copyright (C) 2008 TOMITA Masahiro
+# Copyright (C) 2008-2009 TOMITA Masahiro
 # mailto:tommy@tmtm.org
 
-$LOAD_PATH.unshift File.dirname(__FILE__)
-require "mysql/constants"
-require "mysql/error"
-require "mysql/charset"
-require "mysql/protocol"
-require "mysql/cache"
-
+require "enumerator"
+require "uri"
+
+# MySQL connection class.
+# === Example
+#  Mysql.connect("mysql://user:password@hostname:port/dbname") do |my|
+#    res = my.query "select col1,col2 from tbl where id=?", 123
+#    res.each do |c1, c2|
+#      p c1, c2
+#    end
+#  end
 class Mysql
 
-  VERSION            = 30000               # Version number of this library
+  dir = File.dirname __FILE__
+  require "#{dir}/mysql/constants"
+  require "#{dir}/mysql/error"
+  require "#{dir}/mysql/charset"
+  require "#{dir}/mysql/protocol"
+
+  VERSION            = 30001               # Version number of this library
   MYSQL_UNIX_PORT    = "/tmp/mysql.sock"   # UNIX domain socket filename
   MYSQL_TCP_PORT     = 3306                # TCP socket port number
 
@@ -35,7 +45,6 @@ class Mysql
 #    :report_data_truncation  => x,
 #    :reconnect               => x,
 #    :ssl_verify_server_cert  => x,
-    :prepared_statement_cache_size => Integer,
   }  # :nodoc:
 
   OPT2FLAG = {
@@ -58,13 +67,14 @@ class Mysql
   attr_reader :warning_count         #
   attr_reader :server_version        #
   attr_reader :protocol              #
+  attr_reader :sqlstate
 
   def self.new(*args, &block)  # :nodoc:
     my = self.allocate
     my.instance_eval{initialize(*args)}
     return my unless block
     begin
-      return block.call my
+      return block.call(my)
     ensure
       my.close
     end
@@ -74,11 +84,11 @@ class Mysql
   # The value that block returns if block is specified.
   # Otherwise this returns Mysql object.
   def self.connect(*args, &block)
-    my = self.new *args
+    my = self.new(*args)
     my.connect
     return my unless block
     begin
-      return block.call my
+      return block.call(my)
     ensure
       my.close
     end
@@ -120,13 +130,19 @@ class Mysql
     @init_command = nil
     @affected_rows = nil
     @server_version = nil
-    @param, opt = conninfo *args
+    @sqlstate = "00000"
+    @param, opt = conninfo(*args)
     @connected = false
     set_option opt
   end
 
+  # :call-seq:
+  # connect(conninfo, opt={})
+  #
+  # connect to mysql server.
+  # arguments are same as new().
   def connect(*args)
-    param, opt = conninfo *args
+    param, opt = conninfo(*args)
     set_option opt
     param = @param.merge param
     @protocol = Protocol.new param[:host], param[:port], param[:socket], @connect_timeout, @read_timeout, @write_timeout
@@ -145,11 +161,11 @@ class Mysql
       @protocol.send_packet auth_packet
       @protocol.read            # skip OK packet
     end
-    @stmt_cache = Cache.new(@prepared_statement_cache_size)
     simple_query @init_command if @init_command
     return self
   end
 
+  # disconnect from mysql.
   def close
     if @protocol
       @protocol.synchronize do
@@ -174,78 +190,82 @@ class Mysql
   end
 
   # Execute query string.
-  # If str begin with "sel" or params is specified, then the query is executed as prepared-statement automatically.
-  # So the values in result set are not only String.
+  # If params is specified, then the query is executed as prepared-statement automatically.
   # === Argument
   # str :: [String] Query.
   # params :: Parameters corresponding to place holder (`?') in str.
+  # block :: If it is given then it is evaluated with Result object as argument.
   # === Return
-  # Mysql::Statement :: If result set exist when str begin with "sel".
-  # Mysql::Result :: If result set exist when str does not begin with "sel".
-  # nil :: If result set does not exist.
+  # Mysql::Result :: If result set exist.
+  # nil :: If the query does not return result set.
+  # self :: If block is specified.
+  # === Block parameter
+  # [ Mysql::Result ]
   # === Example
   #  my.query("select 1,NULL,'abc'").fetch  # => [1, nil, "abc"]
-  def query(str, *params)
-    if not params.empty? or str =~ /\A\s*sel/i
-      st = @stmt_cache.get str do |s|
-        prepare s
-      end
-      st.execute(*params)
-      if st.fields.empty?
-        @affected_rows = st.affected_rows
-        @insert_id = st.insert_id
-        @server_status = st.server_status
-        @warning_count = st.warning_count
-        return nil
-      end
-      return st
+  def query(str, *params, &block)
+    if params.empty?
+      res = simple_query(str, &block)
     else
-      return simple_query(str)
+      res = prepare_query(str, *params, &block)
+    end
+    if res && block
+      yield res
+      return self
     end
+    return res
   end
 
-  # Execute query string.
-  # The values in result set are String even if it is numeric.
-  # === Argument
-  # str :: [String] query string
-  # === Return
-  # Mysql::Result :: If result set is exist.
-  # nil :: If result set is not eixst.
-  # === Example
-  #  my.simple_query("select 1,NULL,'abc'").fetch  # => ["1", nil, "abc"]
-  def simple_query(str, &block)
+  def simple_query(str)  # :nodoc:
     @affected_rows = @insert_id = @server_status = @warning_count = 0
-    @fields = nil
     @protocol.synchronize do
-      @protocol.reset
-      @protocol.send_packet Protocol::QueryPacket.new @charset.convert(str)
-      res_packet = @protocol.read_result_packet
-      if res_packet.field_count == 0
-        @affected_rows, @insert_id, @server_status, @warning_conut =
-          res_packet.affected_rows, res_packet.insert_id, res_packet.server_status, res_packet.warning_count
-      else
-        @fields = (1..res_packet.field_count).map{Field.new @protocol.read_field_packet}
-        @protocol.read_eof_packet
-      end
-      if block
-        yield Result.new(self, @fields)
-        return self
+      begin
+        @protocol.reset
+        @protocol.send_packet Protocol::QueryPacket.new(@charset.convert(str))
+        res_packet = @protocol.read_result_packet
+        if res_packet.field_count == 0
+          @affected_rows, @insert_id, @server_status, @warning_conut =
+            res_packet.affected_rows, res_packet.insert_id, res_packet.server_status, res_packet.warning_count
+          return nil
+        else
+          @fields = (1..res_packet.field_count).map{Field.new @protocol.read_field_packet}
+          @protocol.read_eof_packet
+          return SimpleQueryResult.new self, @fields
+        end
+      rescue ServerError => e
+        @sqlstate = e.sqlstate
+        raise
       end
-      return @fields && Result.new(self, @fields)
     end
   end
 
+  def prepare_query(str, *params)  # :nodoc:
+    st = prepare(str)
+    res = st.execute(*params)
+    if st.fields.empty?
+      @affected_rows = st.affected_rows
+      @insert_id = st.insert_id
+      @server_status = st.server_status
+      @warning_count = st.warning_count
+    end
+    st.close
+    return res
+  end
+
   # Parse prepared-statement.
+  # If block is specified then prepared-statement is closed when exiting the block.
   # === Argument
-  # str :: [String] query string
+  # str   :: [String] query string
+  # block :: If it is given then it is evaluated with Mysql::Statement object as argument.
   # === Return
   # Mysql::Statement :: Prepared-statement object
+  # The block value if block is given.
   def prepare(str, &block)
     st = Statement.new self
     st.prepare str
     if block
       begin
-        return block.call st
+        return block.call(st)
       ensure
         st.close
       end
@@ -285,7 +305,7 @@ class Mysql
     st = Statement.new self
     if block
       begin
-        return block.call st
+        return block.call(st)
       ensure
         st.close
       end
@@ -330,9 +350,8 @@ class Mysql
         end
       else
         if args.first =~ /\Amysql:/
-          require "uri" unless defined? URI
           uri = URI.parse args.first
-        elsif defined? URI and args.first.is_a? URI
+        elsif args.first.is_a? URI
           uri = args.first
         else
           raise ArgumentError, "Invalid argument: #{args.first.inspect}"
@@ -370,8 +389,6 @@ class Mysql
     return param, opt
   end
 
-  private
-
   def set_option(opt)
     opt.each do |k,v|
       raise ClientError, "unknown option: #{k.inspect}" unless OPTIONS.key? k
@@ -386,9 +403,9 @@ class Mysql
     @init_command = opt[:init_command] || @init_command
     @read_timeout = opt[:read_timeout] || @read_timeout
     @write_timeout = opt[:write_timeout] || @write_timeout
-    @prepared_statement_cache_size = opt[:prepared_statement_cache_size] || @prepared_statement_cache_size || 10
   end
 
+  # Field class
   class Field
     attr_reader :db, :table, :org_table, :name, :org_name, :charsetnr, :length, :type, :flags, :decimals, :default
     alias :def :default
@@ -401,14 +418,17 @@ class Mysql
       @flags |= NUM_FLAG if is_num_type?
     end
 
+    # Return true if numeric field.
     def is_num?
       @flags & NUM_FLAG != 0
     end
 
+    # Return true if not null field.
     def is_not_null?
       @flags & NOT_NULL_FLAG != 0
     end
 
+    # Return true if primary key field.
     def is_pri_key?
       @flags & PRI_KEY_FLAG != 0
     end
@@ -421,26 +441,30 @@ class Mysql
 
   end
 
+  # Result set
   class Result
-
     include Enumerable
 
     attr_reader :fields
 
     def initialize(mysql, fields)
-      @mysql = mysql
       @fields = fields
       @fieldname_with_table = nil
-      @field_index = 0
-      @records = recv_all_records mysql.protocol, @fields, mysql.charset
       @index = 0
+      @records = recv_all_records mysql.protocol, fields, mysql.charset
+    end
+
+    def size
+      @records.size
     end
 
     def fetch_row
+      return nil if @index >= @records.size
       rec = @records[@index]
-      @index += 1 if @index < @records.length
+      @index += 1
       return rec
     end
+
     alias fetch fetch_row
 
     def fetch_hash(with_table=nil)
@@ -472,6 +496,10 @@ class Mysql
       end
       self
     end
+  end
+
+  # Result set for simple query
+  class SimpleQueryResult < Result
 
     private
 
@@ -482,59 +510,83 @@ class Mysql
         break if Protocol.eof_packet? data
         rec = fields.map do |f|
           v = Protocol.lcs2str! data
-          v.nil? ? nil : f.flags & Field::BINARY_FLAG == 0 ? charset.force_encoding(v) : Charset.to_binary(v)
+          convert_str_to_ruby_value f, v, charset
         end
         ret.push rec
       end
       ret
     end
-  end
 
-  class Time
-    def initialize(year=0, month=0, day=0, hour=0, minute=0, second=0, neg=false, second_part=0)
-      @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
+    def convert_str_to_ruby_value(field, value, charset)
+      return nil if value.nil?
+      case field.type
+      when Field::TYPE_BIT, Field::TYPE_DECIMAL, Field::TYPE_VARCHAR,
+        Field::TYPE_NEWDECIMAL, Field::TYPE_TINY_BLOB,
+        Field::TYPE_MEDIUM_BLOB, Field::TYPE_LONG_BLOB,
+        Field::TYPE_BLOB, Field::TYPE_VAR_STRING, Field::TYPE_STRING
+        field.flags & Field::BINARY_FLAG == 0 ? charset.force_encoding(value) : Charset.to_binary(value)
+      when Field::TYPE_TINY, Field::TYPE_SHORT, Field::TYPE_LONG,
+        Field::TYPE_LONGLONG, Field::TYPE_INT24, Field::TYPE_YEAR
+        value.to_i
+      when Field::TYPE_FLOAT, Field::TYPE_DOUBLE
+        value.to_f
+      when Field::TYPE_TIMESTAMP, Field::TYPE_DATE, Field::TYPE_DATETIME, Field::TYPE_NEWDATE
+        unless value =~ /\A(\d\d\d\d).(\d\d).(\d\d)(?:.(\d\d).(\d\d).(\d\d))?\z/
+          raise "unsupported format date type: #{value}"
+        end
+        Time.new($1, $2, $3, $4, $5, $6)
+      when Field::TYPE_TIME
+        unless value =~ /\A(-?)(\d+).(\d\d).(\d\d)?\z/
+          raise "unsupported format time type: #{value}"
+        end
+        Time.new(0, 0, 0, $2, $3, $4, $1=="-")
+      else
+        raise "unknown mysql type: #{field.type}"
+      end
     end
-    attr_accessor :year, :month, :day, :hour, :minute, :second, :neg, :second_part
-    alias mon month
-    alias min minute
-    alias sec second
+  end
 
-    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
+  # Result set for prepared statement
+  class StatementResult < Result
 
-    def eql?(other)
-      self == other
-    end
+    private
 
-    def to_s
-      if year == 0 and mon == 0 and day == 0
-        sprintf "%02d:%02d:%02d", hour, min, sec
-      else
-        sprintf "%04d-%02d-%02d %02d:%02d:%02d", year, mon, day, hour, min, sec
+    def recv_all_records(protocol, fields, charset)
+      ret = []
+      while rec = parse_data(protocol.read, fields, charset)
+        ret.push rec
       end
+      ret
     end
 
+    def parse_data(data, fields, charset)
+      return nil if Protocol.eof_packet? data
+      data.slice!(0)  # skip first byte
+      null_bit_map = data.slice!(0, (fields.length+7+2)/8).unpack("C*")
+      ret = (0...fields.length).map do |i|
+        if null_bit_map[(i+2)/8][(i+2)%8] == 1
+          nil
+        else
+          unsigned = fields[i].flags & Field::UNSIGNED_FLAG != 0
+          v = Protocol.net2value(data, fields[i].type, unsigned)
+          fields[i].flags & Field::BINARY_FLAG == 0 ? charset.force_encoding(v) : Charset.to_binary(v)
+        end
+      end
+      ret
+    end
   end
 
+  # Prepared statement
   class Statement
-
-    include Enumerable
-
     attr_reader :affected_rows, :insert_id, :server_status, :warning_count
     attr_reader :param_count, :fields, :sqlstate
-    attr_accessor :cursor_type
 
     def self.finalizer(protocol, statement_id)
       proc do
         Thread.new do
           protocol.synchronize do
             protocol.reset
-            protocol.send_packet Protocol::StmtClosePacket.new statement_id
+            protocol.send_packet Protocol::StmtClosePacket.new(statement_id)
           end
         end
       end
@@ -545,9 +597,7 @@ class Mysql
       @protocol = mysql.protocol
       @statement_id = nil
       @affected_rows = @insert_id = @server_status = @warning_count = 0
-      @eof = false
       @sqlstate = "00000"
-      @cursor_type = CURSOR_TYPE_NO_CURSOR
       @param_count = nil
     end
 
@@ -562,7 +612,7 @@ class Mysql
         begin
           @sqlstate = "00000"
           @protocol.reset
-          @protocol.send_packet Protocol::PreparePacket.new @mysql.charset.convert(str)
+          @protocol.send_packet Protocol::PreparePacket.new(@mysql.charset.convert(str))
           res_packet = @protocol.read_prepare_result_packet
           if res_packet.param_count > 0
             res_packet.param_count.times{@protocol.read}   # skip parameter packet
@@ -586,6 +636,9 @@ class Mysql
       self
     end
 
+    # execute prepared-statement.
+    # === Return
+    # Mysql::Result
     def execute(*values)
       raise ClientError, "not prepared" unless @param_count
       raise ClientError, "parameter count mismatch" if values.length != @param_count
@@ -594,28 +647,18 @@ class Mysql
         begin
           @sqlstate = "00000"
           @protocol.reset
-          cursor_type = @fields.empty? ? CURSOR_TYPE_NO_CURSOR : @cursor_type
-          @protocol.send_packet Protocol::ExecutePacket.new @statement_id, cursor_type, values
+          @protocol.send_packet Protocol::ExecutePacket.new(@statement_id, CURSOR_TYPE_NO_CURSOR, values)
           res_packet = @protocol.read_result_packet
           raise ProtocolError, "invalid field_count" unless res_packet.field_count == @fields.length
           @fieldname_with_table = nil
           if res_packet.field_count == 0
             @affected_rows, @insert_id, @server_status, @warning_conut =
               res_packet.affected_rows, res_packet.insert_id, res_packet.server_status, res_packet.warning_count
-            @records = nil
-          else
-            @fields = (1..res_packet.field_count).map{Field.new @protocol.read_field_packet}
-            @protocol.read_eof_packet
-            @eof = false
-            @index = 0
-            if @cursor_type == CURSOR_TYPE_NO_CURSOR
-              @records = []
-              while rec = parse_data(@protocol.read)
-                @records.push rec
-              end
-            end
+            return nil
           end
-          return self
+          @fields = (1..res_packet.field_count).map{Field.new @protocol.read_field_packet}
+          @protocol.read_eof_packet
+          return StatementResult.new(@mysql, @fields)
         rescue ServerError => e
           @sqlstate = e.sqlstate
           raise
@@ -623,86 +666,48 @@ class Mysql
       end
     end
 
-    def fetch_row
-      return nil if @fields.empty?
-      if @records
-        rec = @records[@index]
-        @index += 1 if @index < @records.length
-        return rec
-      end
-      return nil if @eof
+    def close
+      ObjectSpace.undefine_finalizer(self)
       @protocol.synchronize do
         @protocol.reset
-        @protocol.send_packet Protocol::FetchPacket.new @statement_id, 1
-        data = @protocol.read
-        if Protocol.eof_packet? data
-          @eof = true
-          return nil
+        if @statement_id
+          @protocol.send_packet Protocol::StmtClosePacket.new(@statement_id)
+          @statement_id = nil
         end
-        @protocol.read_eof_packet
-        return parse_data data
-      end
-    end
-    alias fetch fetch_row
-
-    def fetch_hash(with_table=nil)
-      row = fetch_row
-      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
+  end
 
-    def each(&block)
-      return enum_for(:each) unless block
-      while rec = fetch_row
-        block.call rec
-      end
-      self
+  class Time
+    def initialize(year=0, month=0, day=0, hour=0, minute=0, second=0, neg=false, second_part=0)
+      @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
 
-    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
+    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
 
-    def close
-      ObjectSpace.undefine_finalizer(self)
-      @protocol.synchronize do
-        @protocol.reset
-        if @statement_id
-          @protocol.send_packet Protocol::StmtClosePacket.new @statement_id
-          @statement_id = nil
-        end
-      end
+    def eql?(other)
+      self == other
     end
 
-    private
-
-    def parse_data(data)
-      return nil if Protocol.eof_packet? data
-      data.slice!(0)  # skip first byte
-      null_bit_map = data.slice!(0, (@fields.length+7+2)/8).unpack("C*")
-      ret = (0...@fields.length).map do |i|
-        if null_bit_map[(i+2)/8][(i+2)%8] == 1
-          nil
-        else
-          unsigned = @fields[i].flags & Field::UNSIGNED_FLAG != 0
-          v = Protocol.net2value(data, @fields[i].type, unsigned)
-          @fields[i].flags & Field::BINARY_FLAG == 0 ? @mysql.charset.force_encoding(v) : Charset.to_binary(v)
-        end
+    def to_s
+      if 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
-      ret
     end
 
   end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tmtm-ruby-mysql
 version: !ruby/object:Gem::Version 
-  version: 3.0.0
+  version: 3.0.1
 platform: ruby
 authors: 
 - tommy
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-22 00:00:00 -07:00
+date: 2009-07-12 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -25,15 +25,12 @@ extra_rdoc_files:
 files: 
 - README
 - ChangeLog
-- Rakefile
 - lib/mysql
 - lib/mysql/constants.rb
 - lib/mysql/compat.rb
 - lib/mysql/protocol.rb
-- lib/mysql/cache.rb
 - lib/mysql/charset.rb
 - lib/mysql/error.rb
-- lib/mysql.rb~
 - lib/mysql.rb
 has_rdoc: true
 homepage: http://github.com/tmtm/ruby-mysql

data/Rakefile

@@ -1,144 +0,0 @@
-require 'rubygems'
-require 'rake'
-require 'rake/clean'
-require 'rake/testtask'
-require 'rake/packagetask'
-require 'rake/gempackagetask'
-require 'rake/rdoctask'
-require 'rake/contrib/rubyforgepublisher'
-require 'rake/contrib/sshpublisher'
-require 'fileutils'
-require 'lib/mysql'
-include FileUtils
-
-NAME              = "ruby-mysql"
-AUTHOR            = "tommy"
-EMAIL             = "tommy@tmtm.org"
-DESCRIPTION       = "MySQL connector for Ruby"
-RUBYFORGE_PROJECT = "rubymysql"
-HOMEPATH          = "http://github.com/tmtm/ruby-mysql"
-BIN_FILES         = %w(  )
-
-VERS              = "3.0.0"
-REV = File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
-CLEAN.include ['**/.*.sw?', '*.gem', '.config']
-RDOC_OPTS = [
-	'--title', "#{NAME} documentation",
-	"--charset", "utf-8",
-	"--opname", "index.html",
-	"--line-numbers",
-	"--main", "README",
-	"--inline-source",
-]
-
-task :default => [:test]
-task :package => [:clean]
-
-Rake::TestTask.new("test") do |t|
-	t.libs   << "test"
-	t.pattern = "test/**/*_test.rb"
-	t.verbose = true
-end
-
-spec = Gem::Specification.new do |s|
-	s.name              = NAME
-	s.version           = VERS
-	s.platform          = Gem::Platform::RUBY
-	s.has_rdoc          = true
-	s.extra_rdoc_files  = ["README", "ChangeLog"]
-	s.rdoc_options     += RDOC_OPTS + ['--exclude', '^(examples|extras)/']
-	s.summary           = DESCRIPTION
-	s.description       = DESCRIPTION
-	s.author            = AUTHOR
-	s.email             = EMAIL
-	s.homepage          = HOMEPATH
-	s.executables       = BIN_FILES
-	s.rubyforge_project = RUBYFORGE_PROJECT
-	s.bindir            = "bin"
-	s.require_path      = "lib"
-	#s.autorequire       = ""
-	s.test_files        = Dir["test/*_test.rb"]
-
-	#s.add_dependency('activesupport', '>=1.3.1')
-	s.required_ruby_version = '>= 1.8.7'
-
-	s.files = %w(README ChangeLog Rakefile) +
-		Dir.glob("{bin,doc,test,lib,templates,generator,extras,website,script}/**/*") + 
-		Dir.glob("ext/**/*.{h,c,rb}") +
-		Dir.glob("examples/**/*.rb") +
-		Dir.glob("tools/*.rb") +
-		Dir.glob("rails/*.rb")
-
-	s.extensions = FileList["ext/**/extconf.rb"].to_a
-end
-
-Rake::GemPackageTask.new(spec) do |p|
-	p.need_tar = true
-	p.gem_spec = spec
-end
-
-task :install do
-	name = "#{NAME}-#{VERS}.gem"
-	sh %{rake package}
-	sh %{sudo gem install pkg/#{name}}
-end
-
-task :uninstall => [:clean] do
-	sh %{sudo gem uninstall #{NAME}}
-end
-
-
-Rake::RDocTask.new do |rdoc|
-	rdoc.rdoc_dir = 'html'
-	rdoc.options += RDOC_OPTS
-	rdoc.template = "resh"
-	#rdoc.template = "#{ENV['template']}.rb" if ENV['template']
-	if ENV['DOC_FILES']
-		rdoc.rdoc_files.include(ENV['DOC_FILES'].split(/,\s*/))
-	else
-		rdoc.rdoc_files.include('README', 'ChangeLog')
-		rdoc.rdoc_files.include('lib/**/*.rb')
-		rdoc.rdoc_files.include('ext/**/*.c')
-	end
-end
-
-desc "Publish to RubyForge"
-task :rubyforge => [:rdoc, :package] do
-	require 'rubyforge'
-	Rake::RubyForgePublisher.new(RUBYFORGE_PROJECT, 'tommy').upload
-end
-
-desc 'Package and upload the release to rubyforge.'
-task :release => [:clean, :package] do |t|
-	v = ENV["VERSION"] or abort "Must supply VERSION=x.y.z"
-	abort "Versions don't match #{v} vs #{VERS}" unless v == VERS
-	pkg = "pkg/#{NAME}-#{VERS}"
-
-	require 'rubyforge'
-	rf = RubyForge.new.configure
-	puts "Logging in"
-	rf.login
-
-	c = rf.userconfig
-#	c["release_notes"] = description if description
-#	c["release_changes"] = changes if changes
-	c["preformatted"] = true
-
-	files = [
-		"#{pkg}.tgz",
-		"#{pkg}.gem"
-	].compact
-
-	puts "Releasing #{NAME} v. #{VERS}"
-	rf.add_release RUBYFORGE_PROJECT, NAME, VERS, *files
-end
-
-desc 'Show information about the gem.'
-task :debug_gem do
-	puts spec.to_ruby
-end
-
-desc 'Update gem spec'
-task :gemspec do
-  open("#{NAME}.gemspec", 'w').write spec.to_ruby
-end

data/lib/mysql/cache.rb

@@ -1,26 +0,0 @@
-# Copyright (C) 2008 TOMITA Masahiro
-# mailto:tommy@tmtm.org
-
-class Mysql
-  class Cache
-    def initialize(size)
-      @size = size || 0
-      @cache = {}
-      @timestamp = {}
-    end
-    def get(key)
-      if @size <= 0
-        return yield key
-      end
-      if @cache.key? key
-        @timestamp[key] = ::Time.now
-        return @cache[key]
-      end
-      if @cache.size >= @size
-        oldest_key = @timestamp.min_by{|k,v| v}.first
-        @cache.delete oldest_key
-      end
-      @cache[key] = yield key
-    end
-  end
-end