ffi-mysql 0.0.1

data/lib/mysql/mysql.rb

@@ -0,0 +1,365 @@
+require 'ffi'
+
+# @author Frank Fischer
+#
+# Basic MySQL class, provides interface to a server.
+class Mysql
+    
+    # FFI interface.
+    module C
+        extend FFI::Library
+        #ffi_lib ["mysqlclient", "libmysqlclient.so.15"]
+        ffi_lib ["mysqlclient", "libmysqlclient.so.15", "libmysqlclient.so.16"]
+        
+#        FieldType = enum(:decimal,     Mysql::Field::TYPE_DECIMAL,
+#                         :tiny,        Mysql::Field::TYPE_TINY,
+#                         :short,       Mysql::Field::TYPE_SHORT,
+#                         :long,        Mysql::Field::TYPE_LONG,
+#                         :float,       Mysql::Field::TYPE_FLOAT,
+#                         :double,      Mysql::Field::TYPE_DOUBLE,
+#                         :null,        Mysql::Field::TYPE_NULL,
+#                         :timestamp,   Mysql::Field::TYPE_TIMESTAMP,
+#                         :longlong,    Mysql::Field::TYPE_LONGLONG,
+#                         :int24,       Mysql::Field::TYPE_INT24,
+#                         :date,        Mysql::Field::TYPE_DATE,
+#                         :time,        Mysql::Field::TYPE_TIME,
+#                         :datetime,    Mysql::Field::TYPE_DATETIME,
+#                         :year,        Mysql::Field::TYPE_YEAR,
+#                         :newdate,     Mysql::Field::TYPE_NEWDATE,
+#                         :varchar,     Mysql::Field::TYPE_VARCHAR,
+#                         :bit,         Mysql::Field::TYPE_BIT,
+#                         :newdecimal,  Mysql::Field::TYPE_NEWDECIMAL,
+#                         :enum,        Mysql::Field::TYPE_ENUM,
+#                         :set,         Mysql::Field::TYPE_SET,
+#                         :tiny_blob,   Mysql::Field::TYPE_TINY_BLOB,
+#                         :medium_blob, Mysql::Field::TYPE_MEDIUM_BLOB,
+#                         :long_blob,   Mysql::Field::TYPE_LONG_BLOB,
+#                         :blob,        Mysql::Field::TYPE_BLOB,
+#                         :var_string,  Mysql::Field::TYPE_VAR_STRING,
+#                         :string,      Mysql::Field::TYPE_STRING,
+#                         :geometry,    Mysql::Field::TYPE_GEOMETRY,
+#                         :char,        Mysql::Field::TYPE_CHAR,
+#                         :interval,    Mysql::Field::TYPE_INTERVAL)
+        FieldType = :uchar
+
+        class Field < FFI::Struct
+            layout(:name,             :string,
+                   :org_name,         :string,
+                   :table,            :string,
+                   :org_table,        :string,
+                   :db,               :string,
+                   :catalog,          :string,
+                   :def,              :string,
+                   :length,           :ulong,
+                   :max_length,       :ulong,
+                   :name_length,      :uint,
+                   :org_name_length,  :uint,
+                   :table_length,     :uint,
+                   :org_table_length, :uint,
+                   :db_length,        :uint,
+                   :catalog_length,   :uint,
+                   :def_length,       :uint,
+                   :flags,            :uint,
+                   :decimals,         :uint,
+                   :charsetnr,        :uint,
+                   :type,             FieldType)
+        end
+
+        StmtAttrType = enum( :update_max_length, :cursor_type, :prefetch_rows )
+
+        attach_function :mysql_init, [:pointer], :pointer
+        attach_function :mysql_close, [:pointer], :void
+        attach_function :mysql_error, [:pointer], :string
+        attach_function :mysql_get_client_version, [], :int
+        attach_function :mysql_get_client_info, [], :string
+        attach_function :mysql_get_server_version, [:pointer], :int
+        attach_function :mysql_get_server_info, [:pointer], :string
+        attach_function :mysql_real_connect, [:pointer, :string, :string, :string, :string, :uint, :string, :ulong], :pointer
+        attach_function :mysql_options, [:pointer, :int, :pointer], :int
+        attach_function :mysql_set_server_option, [:pointer, :int], :int
+        attach_function :mysql_real_query, [:pointer, :string, :ulong], :int
+        attach_function :mysql_field_count, [:pointer], :uint
+        attach_function :mysql_store_result, [:pointer], :pointer
+        attach_function :mysql_free_result, [:pointer], :void
+        attach_function :mysql_next_result, [:pointer], :int
+        attach_function :mysql_more_results, [:pointer], :bool
+        attach_function :mysql_affected_rows, [:pointer], :ulong_long
+        attach_function :mysql_num_rows, [:pointer], :ulong_long
+        attach_function :mysql_fetch_row, [:pointer], :pointer
+        attach_function :mysql_fetch_lengths, [:pointer], :pointer
+        attach_function :mysql_row_tell, [:pointer], :ulong_long
+        attach_function :mysql_row_seek, [:pointer, :ulong_long], :ulong_long
+        attach_function :mysql_num_fields, [:pointer], :uint
+        attach_function :mysql_fetch_field, [:pointer], :pointer
+        attach_function :mysql_fetch_field_direct, [:pointer, :uint], :pointer
+        attach_function :mysql_field_tell, [:pointer], :uint
+        attach_function :mysql_field_seek, [:pointer, :uint], :uint
+        attach_function :mysql_data_seek, [:pointer, :ulong_long], :void
+        attach_function :mysql_sqlstate, [:pointer], :string
+        attach_function :mysql_stmt_init, [:pointer], :pointer
+        attach_function :mysql_stmt_attr_set, [:pointer, StmtAttrType, :pointer], :int
+        attach_function :mysql_stmt_close, [:pointer], :void
+        attach_function :mysql_stmt_prepare, [:pointer, :string, :ulong], :int
+        attach_function :mysql_stmt_execute, [:pointer], :int
+        attach_function :mysql_stmt_free_result, [:pointer], :int
+        attach_function :mysql_stmt_param_count, [:pointer], :ulong
+        attach_function :mysql_stmt_bind_param, [:pointer, :pointer], :char
+        attach_function :mysql_stmt_result_metadata, [:pointer], :pointer
+        attach_function :mysql_stmt_bind_result, [:pointer, :pointer], :char
+        attach_function :mysql_stmt_affected_rows, [:pointer], :ulong_long
+        attach_function :mysql_stmt_store_result, [:pointer], :int
+        attach_function :mysql_stmt_fetch, [:pointer], :int
+        attach_function :mysql_stmt_data_seek, [:pointer, :ulong_long], :void
+        attach_function :mysql_stmt_field_count, [:pointer], :uint
+        attach_function :mysql_stmt_num_rows, [:pointer], :ulong_long
+        attach_function :mysql_stmt_row_tell, [:pointer], :ulong_long
+        attach_function :mysql_stmt_row_seek, [:pointer, :ulong_long], :ulong_long
+        attach_function :mysql_stmt_insert_id, [:pointer], :ulong_long
+        attach_function :mysql_stmt_sqlstate, [:pointer], :string
+        attach_function :mysql_stmt_errno, [:pointer], :uint
+        attach_function :mysql_stmt_error, [:pointer], :string
+    end
+
+    # Creates a new MySQL object.
+    def self.init
+        mysql = allocate
+        mysql.send :initialize
+        mysql
+    end
+
+    # Creates a new MySQL connector and opens a connection.
+    def self.new( host = nil, user = nil, passwd = nil, db = nil, port = 0, sock = nil, flag = 0)
+        mysql = allocate
+        mysql.send :initialize 
+        mysql.real_connect( host, user, passwd, db, port, sock, flag )
+        mysql
+    end
+
+    # @return [Integer] the version of the client
+    def self.client_version
+        C::mysql_get_client_version
+    end
+
+    # @return [Integer] the version of the client
+    def client_version
+        Mysql.client_version
+    end
+
+    # @return [String] string containing the client's version
+    def self.client_info
+        C::mysql_get_client_info
+    end
+    
+    # Escape special character in MySQL.
+    # === Note
+    # In Ruby 1.8, this is not safe for multibyte charset such as 'SJIS'.
+    # You should use place-holder in prepared-statement.
+    def self.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
+    
+    class << self
+        alias :real_connect :new
+        alias :connect :new
+        alias :get_client_version :client_version
+        alias :get_client_info :client_info
+        alias quote escape_string
+    end
+
+    
+    # if true (the default), query return the first result
+    attr_accessor :query_with_result
+
+    # Creates a new connection to a MySQL server.
+    #
+    # @param (see Mysql#real_connect)
+    def initialize
+        @mysql_free = [true]
+        @mysql = C::mysql_init( nil )
+        @connected = false
+        @query_with_result = true
+    end
+
+    # internal finalizer 
+    def self.finalizer(mysql, mysql_free)
+        Proc.new do |*args|
+            unless mysql_free[0]
+                C::mysql_close(mysql) 
+            end
+        end
+    end
+    
+    # Opens a new connection to a MySQL server.
+    #
+    # @param [String] host the MySQL server
+    # @param [String] user the username to login
+    # @param [String] passwd the user's password
+    # @param [String] db the name of the database to use
+    # @param [Integer] port the port of the server to use
+    # @param [Integer] flag connection flags
+    def real_connect( host = nil, user = nil, passwd = nil, db = nil, port = 0, sock = nil, flag = 0)
+        raise Error, "Already connected to a MySQL server" if @connected
+
+        ObjectSpace.define_finalizer( self, Mysql.finalizer(@mysql, @mysql_free))
+        
+        if C::mysql_real_connect( @mysql, host, user, passwd, db, port, sock, flag ).null?
+            raise Mysql::Error, error_msg
+        end
+        
+        @connected = true
+        self
+    end
+    alias :connect :real_connect
+
+    # Closes the connection to the server.
+    def close
+        C::mysql_close(@mysql)
+        @mysql = nil
+        @mysql_free[0] = true
+        @connected = false
+    end
+
+    # @return [Integer] the version of the server
+    def server_version
+        C::mysql_get_server_version(@mysql)
+    end
+    alias get_server_version server_version
+
+    # @return [String] string containing the server's version
+    def server_info
+        C::mysql_get_server_info(@mysql)
+    end
+    alias get_server_info server_info
+
+    # @return [String] the SQLSTATE error code for the most recent statement
+    def sqlstate
+        C::mysql_sqlstate(@mysql)
+    end
+    
+    
+    # Sets extra connection options.
+    #
+    # @param [Integer] option the option to set
+    # @param [String,Integer,true,false,nil] the value of the option to set
+    def options( arg, value = nil )
+        result = if value.nil?
+                     C::mysql_options( @mysql, arg, nil )
+                 elsif value.kind_of? Integer
+                     C::mysql_options( @mysql, arg, FFI::MemoryPointer.new(:uint).write_int(value) )
+                 elsif value.kind_of? String
+                     C::mysql_options( @mysql, arg, FFI::MemoryPointer.from_string(value) )
+                 elsif value == true
+                     C::mysql_options( @mysql, arg, FFI::MemoryPointer.new(:uint).write_int(1) )
+                 elsif value == false
+                     C::mysql_options( @mysql, arg, FFI::MemoryPointer.new(:uint).write_int(0) )
+                 else
+                     raise ArgumentError, "value must one of [String, Integer, nil, true, false]"
+                 end
+        raise Error, error_msg if result != 0
+        self
+    end
+
+    # Enables or disables an options for the connection.
+    #
+    # @param [Integer] option server option
+    def set_server_option( option )
+        if C::mysql_set_server_option( @mysql, option ) != 0
+            raise Error, error_msg
+        end
+        self
+    end
+
+    
+    # Execute a query statement.
+    #
+    # @param [String] sql the SQL statement
+    # @yield [optional, Result] calls block once per result set
+    #
+    # @return [Result,self] the first result set if no block is given, self otherwise
+    def query(sql)
+        raise Error, "Not connected" unless @connected
+        if C::mysql_real_query(@mysql, sql, sql.size) != 0
+            raise Error, error_msg
+        end
+
+        if block_given?
+            begin
+                result = store_result
+                yield result
+            ensure
+                result.free
+            end while next_result
+            self
+        elsif query_with_result
+            if field_count == 0
+                nil
+            else
+                store_result
+            end
+        else
+            self
+        end
+    end
+
+    # Stores the current result in a result set.
+    # @return [Result] the result set
+    def store_result
+        Result.new(@mysql, C::mysql_store_result(@mysql))
+    end
+
+    # Advances to the next result set.
+    # @return [true,false] true if there's another result set
+    def next_result
+        result = C::mysql_next_result(@mysql)
+        if result == 0
+            true
+        elsif result < 0
+            false
+        else
+            raise Error, error_msg
+        end
+    end
+
+    # @return [true,false] true if there's another result set
+    def more_results?
+        C::mysql_more_results(@mysql)
+    end
+    alias more_results more_results?
+
+    # @return [Integer] the number of affected rows by the last query
+    def affected_rows
+         C::mysql_affected_rows(@mysql)
+    end
+
+    # @return [Integer] the number of columns for the most recent query
+    def field_count
+        C::mysql_field_count(@mysql)
+    end
+
+    # @return [Stmt] a new statement
+    def stmt_init
+        Stmt.new( @mysql )
+    end
+
+    # Creates and prepares a new statement.
+    # @param [String] stmt the SQL statement
+    # @return [Stmt] the new prepared statement
+    def prepare( stmt )
+        stmt_init.prepare(stmt)
+    end
+
+    # Returns the current error message.
+    def error_msg
+        C::mysql_error(@mysql)
+    end
+    private :error_msg
+
+end

data/lib/mysql/result.rb

@@ -0,0 +1,168 @@
+class Mysql
+    
+    # Result set.
+    class Result
+        include Enumerable
+        
+        attr_reader :fields
+
+        # Create the next result object.
+        def initialize( mysql, result )
+            @mysql = mysql
+            @result = result
+            @num_rows = @num_fields = nil
+            raise ArgumentError, "Invalid result object" if @result.nil? or @result.null?
+            ObjectSpace.define_finalizer( self, Result.finalizer(@result) )
+        end
+
+        # Frees the result object.
+        def free
+            C::mysql_free_result(@result)
+            @result = nil
+            ObjectSpace.undefine_finalizer( self )
+        end
+
+        # @return [Integer] the number of rows in this result set
+        def num_rows
+            raise Error, "Result has been freed" unless @result
+            @num_rows ||= C::mysql_num_rows(@result)
+        end
+
+        # @return [Integer] the number of columns in this result set
+        def num_fields
+            raise Error, "Result has been freed" unless @result
+            @num_fields ||= C::mysql_num_fields(@result)
+        end
+
+        # @return [Array<Integer>] the array of number of chars for each column
+        def fetch_lengths
+            raise Error, "Result has been freed" unless @result
+            lengths = C::mysql_fetch_lengths(@result)
+            lengths.null? ? nil : lengths.read_array_of_long(num_fields)
+        end
+
+        # @return [Array<String>] Ary of elements of the next row.
+        def fetch_row
+            raise Error, "Result has been freed" unless @result
+            row = C::mysql_fetch_row(@result)
+            if row.null?
+                nil
+            else
+                lengths = fetch_lengths
+                row = row.read_array_of_pointer(lengths.size)
+                (0...lengths.size).map{|i|
+                    row[i].null? ? nil : row[i].read_string(lengths[i])
+                }
+            end
+        end
+
+        # Iterates over all rows in this result set.
+        # @yield [Array<String>] Called once for each row in this result set
+        # @see fetch_row
+        def each
+            while row = fetch_row
+                yield row
+            end
+        end
+
+        # @return [Integer] the current position of the row cursor
+        def row_tell
+            raise Error, "Result has been freed" unless @result
+            C::mysql_row_tell(@result)
+        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, "Result has been freed" unless @result
+            C::mysql_row_seek(@result, offset)
+        end
+
+        # @param [Boolean] with_table if true, fields are denoted with table "tablename.fieldname"
+        # @return [Hash] hash of elements "field" => "value"
+        def fetch_hash(with_table = false)
+            return nil unless row = fetch_row
+            keys = if with_table
+                       @tblcolnames ||= fetch_fields.map{|f| "#{f.table}.#{f.name}"}
+                   else
+                       @colnames ||= fetch_fields.map{|f| f.name}
+                   end
+            
+            hash = {}
+            row.each_with_index do |value, i|
+                hash[keys[i]] = value
+            end
+            hash
+        end
+
+        # Iterates over all rows in this result set.
+        # @param [Boolean] with_table if true, fields are denoted with table "tablename.fieldname"
+        # @yield [Hash] Called once for each row in this result set with a row-hash
+        # @see fetch_hash
+        def each_hash(with_table = false)
+            while row = fetch_hash(with_table)
+                yield row
+            end
+        end
+            
+        # @return [Integer] The position of the field cursor after the last fetch_field.
+        def field_tell
+            raise Error, "Result has been freed" unless @result
+            C::mysql_field_tell(@result)
+        end
+
+        # Sets the field cursor to the given offset.
+        # @param [Integer] the new field offset
+        # @return [Integer] the position of the previous field cursor
+        def field_seek(offset)
+            raise Error, "Result has been freed" unless @result
+            C::mysql_field_seek(@result, offset)
+        end
+
+        # @return [Field,nil] the information for the next Field or nil
+        def fetch_field
+            raise Error, "Result has been freed" unless @result
+            field_ptr = C::mysql_fetch_field(@result)
+            if field_ptr.null?
+                nil
+            else
+                Field.new(C::Field.new(field_ptr))
+            end
+        end
+
+        # @param [Integer] fieldnr column number
+        # @return [Field] the information for field of column fieldnr
+        def fetch_field_direct( fieldnr )
+            raise Error, "Result has been freed" unless @result
+            n = num_fields
+            raise Error, "#{fieldnr}: out of range (max: #{n})" if fieldnr < 0 or fieldnr >= n
+            field_ptr = C::mysql_fetch_field_direct(@result, fieldnr)
+            Field.new(C::Field.new(field_ptr))
+        end
+
+        # @return [Array<Field>] array of field-informations for each column in this result set
+        def fetch_fields
+            raise Error, "Result has been freed" unless @result
+            n = num_fields
+            (0...n).map{|i| fetch_field_direct(i)}
+        end
+
+        # Seeks to an arbitrary row in the result set.
+        # @param [Integer] row the number of row to use next
+        # @return [self]
+        def data_seek( row )
+            raise Error, "Result has been freed" unless @result
+            C::mysql_data_seek(@result, row)
+            self
+        end
+
+        # Internal finalizer, calls self.free.
+        def self.finalizer(result)
+            Proc.new do |*args|
+                C::mysql_free_result(result)
+            end
+        end
+    end
+    
+end