ffi-mysql 0.0.1

data/lib/mysql/stmt.rb

@@ -0,0 +1,416 @@
+class Mysql
+    # A MySQL statement.
+    class Stmt
+        class C::Time < FFI::Struct
+            layout(:year,        :uint,
+                   :month,       :uint,
+                   :day,         :uint,
+                   :hour,        :uint,
+                   :minute,      :uint,
+                   :second,      :uint,
+                   :second_part, :ulong,
+                   :neg,         :uchar,
+                   :time_type,   :int)
+        end
+        
+        class C::Bind < FFI::Struct
+            layout(:length,            :pointer,   # output length pointer 
+                   :is_null,           :pointer,   # Pointer to null indicator 
+                   :buffer,            :pointer,   # buffer to get/put data
+                   # set this if you want to track data truncations happened during fetch 
+                   :error,             :pointer,
+                   :buffer_type,       :int, # buffer type 
+                   # output buffer length, must be set when fetching str/binary 
+                   :buffer_length,     :ulong,
+                   :row_ptr,           :pointer,   # for the current data position 
+                   :offset,            :ulong,     # offset position for char/binary fetch 
+                   :length_value,      :ulong,     # Used if length is 0
+                   :param_number,      :uint,      # For null count and error messages
+                   :pack_length,       :uint,      # Internal length for packed data
+                   :error_value,       :char,      # used if error is 0
+                   :is_unsigned,       :char,      # set if integer type is unsigned
+                   :long_data_used,    :char,      # If used with mysql_send_long_data
+                   :is_null_value,     :char,      # Used if is_null is 0
+                   :store_param_func,  :pointer,
+                   :fetch_result,      :pointer,
+                   :skip_result,       :pointer)
+
+            def prepare_result( field )
+                self[:buffer_type] = field.type
+                self[:is_null] = @is_null = FFI::MemoryPointer.new(:int)
+                self[:length] = @buflen = FFI::MemoryPointer.new(:ulong)
+                self[:is_unsigned] = (field.flags & Field::UNSIGNED_FLAG) != 0 ? 1 : 0
+            end
+
+            def set_result( field )
+                case self[:buffer_type]
+                when Field::TYPE_NULL
+                    nil
+                when Field::TYPE_TINY, Field::TYPE_SHORT, Field::TYPE_YEAR, Field::TYPE_INT24,
+                     Field::TYPE_LONG, Field::TYPE_LONGLONG, Field::TYPE_FLOAT, Field::TYPE_DOUBLE
+                    self[:buffer] = @buf = FFI::MemoryPointer.new(8, 1, true)
+                    self[:buffer_length] = 8
+                when Field::TYPE_DECIMAL, Field::TYPE_STRING, Field::TYPE_VAR_STRING, Field::TYPE_TINY_BLOB,
+                     Field::TYPE_BLOB, Field::TYPE_MEDIUM_BLOB, Field::TYPE_LONG_BLOB, Field::TYPE_NEWDECIMAL,
+                     Field::TYPE_BIT
+                    self[:buffer] = @buf = FFI::MemoryPointer.new( field.max_length, 1, true )
+                    self[:buffer_length] = field.max_length
+                when Field::TYPE_TIME, Field::TYPE_DATE, Field::TYPE_DATETIME, Field::TYPE_TIMESTAMP
+                    self[:buffer] = @buf = FFI::MemoryPointer.new( C::Time.size, 1, true )
+                    self[:buffer_length] = C::Time.size
+                else
+                    raise TypeError, "unknown buffer_type: #{self[:buffer_type]}"
+                end
+            end
+
+            def set_bind_result( arg, field )
+                if arg.nil? or arg == NilClass
+                    self[:buffer_type] = field.type
+                elsif arg == String
+                    self[:buffer_type] = Field::TYPE_STRING
+                elsif arg == Numeric or arg == Integer or arg == Fixnum
+                    self[:buffer_type] = Field::TYPE_LONGLONG
+                elsif arg == Float
+                    self[:buffer_type] = Field::TYPE_DOUBLE
+                elsif arg == Mysql::Time or arg == Time
+                    self[:buffer_type] = Field::TYPE_DATETIME
+                else
+                    raise TypeError, "unrecognized class: #{arg.class}"
+                end
+            end
+            
+            def set_param( arg )
+                case arg
+                when nil
+                    self[:buffer_type] = Field::TYPE_NULL
+                when Fixnum
+                    self[:buffer_type] = Field::TYPE_LONG
+                    self[:buffer] = @buf = FFI::MemoryPointer.new( :long )
+                    @buf.write_int(arg)
+                when Bignum
+                    self[:buffer_type] = Field::TYPE_LONGLONG
+                    self[:buffer] = @buf = FFI::MemoryPointer.new( :long_long )
+                    @buf.write_long_long(arg)
+                when Float
+                    self[:buffer_type] = Field::TYPE_DOUBLE
+                    self[:buffer] = @buf = FFI::MemoryPointer.new( :double )
+                    @buf.write_double(arg)
+                when String
+                    self[:buffer_type] = Field::TYPE_STRING
+                    self[:buffer] = @buf = FFI::MemoryPointer::from_string(arg)
+                    self[:buffer_length] = arg.size
+                    self[:length] = @buflen = FFI::MemoryPointer.new( :ulong )
+                    @buflen.write_long( arg.size )
+                when ::Time, Mysql::Time
+                    self[:buffer_type] = Field::TYPE_DATETIME
+                    self[:buffer] = @buf = FFI::MemoryPointer.new( C::Time, 1, true )
+                    self[:buffer_length] = C::Time.size
+                    self[:length] = @buflen = FFI::MemoryPointer.new( :ulong )
+                    @buflen.write_long(C::Time.size)
+                    time = C::Time.new(@buf)
+                    time[:second_part] = 0
+                    time[:neg] = 0
+                    if arg.kind_of? Mysql::Time
+                        time[:second] = arg.second
+                        time[:minute] = arg.minute
+                        time[:hour] = arg.hour
+                        time[:day] = arg.day
+                        time[:month] = arg.month
+                        time[:year] = arg.year
+                    else
+                        time[:second] = arg.sec
+                        time[:minute] = arg.min
+                        time[:hour] = arg.hour
+                        time[:day] = arg.day
+                        time[:month] = arg.month
+                        time[:year] = arg.year
+                    end
+                else
+                    raise TypeError, "unsupported type: #{arg.class}"
+                end
+            end
+
+            def value
+                if @is_null.read_int != 0
+                    nil
+                else
+                    case self[:buffer_type]
+                    when Field::TYPE_TINY
+                        b = @buf.read_long
+                        if self[:is_unsigned] == 0 and b >= 2**7
+                            b -= 2**8
+                        end
+                        b
+                    when Field::TYPE_SHORT, Field::TYPE_YEAR
+                        b = @buf.read_long
+                        if self[:is_unsigned] == 0 and b >= 2**15
+                            b -= 2**16
+                        end
+                        b
+                    when Field::TYPE_INT24, Field::TYPE_LONG
+                        if self[:is_unsigned] != 0
+                            @buf.read_long % (2**32)
+                        else
+                            @buf.read_long
+                        end
+                    when Field::TYPE_LONGLONG
+                        if self[:is_unsigned] != 0
+                            @buf.read_long_long % (2**64)
+                        else
+                            @buf.read_long_long
+                        end
+                    when Field::TYPE_FLOAT
+                        @buf.read_float
+                    when Field::TYPE_DOUBLE
+                        # FIXME currently not supported
+                        @buf.read_double
+                    when Field::TYPE_TIME, Field::TYPE_DATE, Field::TYPE_DATETIME, Field::TYPE_TIMESTAMP
+                        time = C::Time.new(@buf)
+                        Time.new( time[:year], time[:month], time[:day],
+                                  time[:hour], time[:minute], time[:second],
+                                  time[:neg] != 0, time[:second_part] )
+                    when Field::TYPE_DECIMAL, Field::TYPE_STRING, Field::TYPE_VAR_STRING,
+                         Field::TYPE_TINY_BLOB, Field::TYPE_BLOB, Field::TYPE_MEDIUM_BLOB,
+                         Field::TYPE_LONG_BLOB, Field::TYPE_NEWDECIMAL, Field::TYPE_BIT
+                        @buf.read_string( @buflen.read_long % (2**32) )
+                    else
+                        raise TypeError, "unknown buffer type: #{self[:buffer_type]}"
+                    end
+                end
+            end
+        end
+        
+        def initialize( mysql )
+            @mysql = mysql
+            @stmt = C::mysql_stmt_init(mysql)
+            @params = []
+            raise Error, error_msg if @stmt.null?
+            ObjectSpace.define_finalizer( self, Stmt.finalizer(@stmt) )
+            
+            _true = FFI::MemoryPointer.new(:int)
+            _true.write_int(1)
+            if C::mysql_stmt_attr_set(@stmt, :update_max_length, _true) != 0
+                raise Error, error_msg
+            end
+        end
+
+        # Closes the statement.
+        def close
+            C::mysql_stmt_close(@stmt) 
+            @stmt = nil
+            ObjectSpace.undefine_finalizer(self)
+        end
+        
+        # Preparse the statement
+        # @param [String] stmt the SQL statement
+        # @return [self]
+        def prepare(stmt)
+            raise Error, "Statment already closed" unless @stmt
+            if C::mysql_stmt_prepare(@stmt, stmt, stmt.size) != 0
+                raise Error, error_msg
+            end
+
+            nparams = param_count
+            @param_binds_ary = FFI::MemoryPointer.new C::Bind, nparams, true
+            @param_binds = (0...nparams).map {|i|
+                C::Bind.new(FFI::Pointer.new(C::Bind, @param_binds_ary.address + i * C::Bind.size))
+            }
+            
+            if @result = result_metadata
+                fields = @result.fetch_fields
+                @result_binds_ary = FFI::MemoryPointer.new C::Bind, fields.size, true
+                @result_binds = (0...fields.size).map{|i|
+                    bind = C::Bind.new(FFI::Pointer.new(C::Bind, @result_binds_ary.address + i * C::Bind.size))
+                    bind.prepare_result( fields[i] )
+                    bind
+                }
+            else
+                @result_binds_ary = nil
+                @result_binds = []
+            end
+            
+            self
+        end
+
+        # Executes the statement.
+        # @param args statement parameters
+        # @return [self]
+        def execute(*args)
+            raise Error, "Statment already closed" unless @stmt
+            if args.size != @param_binds.size
+                raise Error, "param_count(#{@param_binds.size}) != number of arguments(#{args.size})" 
+            end
+            
+            free_result
+            unless @param_binds.empty?
+                @param_binds.each_with_index do |bind, i|
+                    bind.set_param args[i]
+                end
+                if C::mysql_stmt_bind_param(@stmt, @param_binds_ary) != 0
+                    raise Error, error_msg
+                end
+            end
+            
+            if C::mysql_stmt_execute(@stmt) != 0
+                raise Error, error_msg
+            end
+
+            if @result
+                if C::mysql_stmt_store_result(@stmt) != 0
+                    raise Error, error_msg
+                end
+
+                fields = @result.fetch_fields
+                @result_binds.each_with_index do |bind, i|
+                    bind.set_result fields[i]
+                end
+
+                if C::mysql_stmt_bind_result(@stmt, @result_binds_ary) != 0
+                    raise Error, error_msg
+                end
+            end
+            
+            self
+        end
+
+        # Associated output columns with buffer.
+        # @param [Class] classes of the result columns like Fixnum, String, ...
+        # @return [self]
+        def bind_result(*args)
+            raise Error, "Statment already closed" unless @stmt
+            if args.size != @result_binds.size
+                raise Error, "result value count (#{@result_binds.size}) != number of arguments (#{args.size})"
+            end
+
+            fields = @result.fetch_fields
+            @result_binds.each_with_index do |bind, i|
+                bind.set_bind_result( args[i], fields[i] )
+                if C::mysql_stmt_bind_result( @stmt, @result_binds_ary ) != 0
+                    raise Error, error_msg
+                end
+            end
+            self
+        end
+
+        # @return [Array] the next row.
+        def fetch
+            raise Error, "Statment already closed" unless @stmt
+            r = C::mysql_stmt_fetch(@stmt)
+            case r
+            when NO_DATA
+                nil
+            when DATA_TRUNCATED
+                raise Error, "unexpectedly data truncated"
+            when 1
+                raise Error, error_msg
+            else
+                @result_binds.map{|bind| bind.value}
+            end
+        end
+        
+        # Iterates over all rows in this result set.
+        # @yield [Array] Called once for each row in this result set
+        # @see fetch_row
+        def each
+            while row = fetch
+                yield row
+            end
+        end
+
+        # Seeks to an arbitrary row in the result set.
+        # @param [offset] the row to seek to
+        # @return [self]
+        def data_seek( offset )
+            raise Error, "Statment already closed" unless @stmt
+            C::mysql_stmt_data_seek( @stmt, offset )
+            self
+        end
+
+
+        # @return [Integer] the number of rows changed by the latest
+        #                   execution of this statement
+        def affected_rows
+            raise Error, "Statment already closed" unless @stmt
+            C::mysql_stmt_affected_rows(@stmt)
+        end
+
+        # @return [Integer] the number of columns of this statement
+        def field_count
+            raise Error, "Statment already closed" unless @stmt
+            C::mysql_stmt_field_count(@stmt)
+        end
+
+        # Frees the current result of this statement.
+        # @return [self]
+        def free_result
+            raise Error, "Statment already closed" unless @stmt
+            if C::mysql_stmt_free_result(@stmt) != 0
+                raise Error, error_msg
+            end
+        end
+            
+        # @return [Integer] the number of rows of this statement
+        def num_rows
+            raise Error, "Statment already closed" unless @stmt
+            C::mysql_stmt_num_rows(@stmt)
+        end
+
+        # @return [Integer] the number of parameters of this statement
+        def param_count
+            raise Error, "Statment already closed" unless @stmt
+            C::mysql_stmt_param_count(@stmt)
+        end
+
+        # @return [Integer] the number of the current row of the most recent result
+        def row_tell
+            raise Error, "Statment already closed" unless @stmt
+            C::mysql_stmt_row_tell(@stmt)
+        end
+
+        # Sets the position of the row cursor.
+        # @param [Integer] offset the new position of the row cursor
+        # @return [Integer] the former position of the row cursor
+        def row_seek( offset )
+            raise Error, "Statment already closed" unless @stmt
+            C::mysql_stmt_row_seek(@stmt, offset)
+        end
+
+        # @return [Result] the result metadata of the current statement
+        def result_metadata
+            raise Error, "Statment already closed" unless @stmt
+            result = C::mysql_stmt_result_metadata(@stmt)
+            if result.null?
+                if C::mysql_stmt_errno(@stmt) != 0
+                    raise Error, error_msg
+                end
+                nil
+            else
+                Result.new(@mysql, result)
+            end
+        end
+
+        # @return [Integer] the value of an auto-increment column of
+        #                   the last INSERT or UPDATE statement
+        def insert_id
+            raise Error, "Statment already closed" unless @stmt
+            C::mysql_stmt_insert_id(@stmt)
+        end
+
+        # @return [String] the SQLSTATE error code for this statement
+        def sqlstate
+            raise Error, "Statment already closed" unless @stmt
+            C::mysql_stmt_sqlstate(@stmt)
+        end
+
+        private
+        def error_msg
+            C::mysql_stmt_error(@stmt)
+        end
+
+        def self.finalizer(stmt)
+            Proc.new do |*args|
+                C::mysql_stmt_close(stmt) 
+            end
+        end
+    end
+end

data/lib/mysql/time.rb

@@ -0,0 +1,33 @@
+class Mysql
+    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 ==(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 eql?(other)
+            self == other
+        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
+        end
+
+    end
+end