drizzle 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Padraig O'Sullivan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,7 @@
+= drizzle-ruby
+
+An interface to Drizzle using FFI and libdrizzle.
+
+== Copyright
+
+Copyright (c) 2010 Padraig O'Sullivan. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "drizzle"
+    gem.summary = "A ruby interface to Drizzle using libdrizzle"
+    gem.description = "An interface to Drizzle for Ruby that uses libdrizzle"
+    gem.email = "osullivan.padraig@gmail.com"
+    gem.homepage = "http://github.com/posulliv/drizzle-ruby"
+    gem.authors = ["Padraig O'Sullivan"]
+    gem.rubyforge_project = "drizzle-ruby"
+    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+    rubyforge.doc_task = "rdoc"
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+  exit(1)
+end
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "drizzle #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/drizzle.rb

@@ -0,0 +1,15 @@
+# rubygems
+require 'rubygems'
+
+# 3rd party
+require 'ffi'
+
+# internal requires
+require 'drizzle/ffidrizzle'
+require 'drizzle/drizzle'
+require 'drizzle/result'
+require 'drizzle/connection'
+require 'drizzle/exceptions'
+
+module Drizzle
+end

data/lib/drizzle/connection.rb

@@ -0,0 +1,207 @@
+require 'drizzle/ffidrizzle'
+require 'drizzle/exceptions'
+
+module Drizzle
+
+  class ConnectionPtr < FFI::AutoPointer
+    def self.release(ptr)
+      LibDrizzle.drizzle_con_free(ptr)
+    end
+  end
+
+  # 
+  # map of keywords that will be used with the SQL injection
+  # prevention plugin in drizzle
+  #
+  Keywords =
+  {
+    "add" => true,
+    "all" => true,
+    "alter" => true,
+    "analyze" => true,
+    "and" => true,
+    "any" => true,
+    "as" => true,
+    "asc" => true,
+    "before" => true,
+    "between" => true,
+    "by" => true,
+    "count" => true,
+    "distinct" => true,
+    "drop" => true,
+    "from" => true,
+    "having" => true,
+    "or" => true,
+    "select" => true,
+    "union" => true,
+    "where" => true
+  }
+
+
+  # 
+  # connection options
+  #
+  NONE = 0
+  ALLOCATED = 1
+  MYSQL = 2
+  RAW_PACKET = 4
+  RAW_SCRAMBLE = 8
+  READY = 16
+  NO_RESULT_READ = 32
+  INJECTION_PREVENTION = 64
+
+  # 
+  # A drizzle connection
+  #
+  class Connection
+
+    attr_accessor :host, :port, :db
+
+    #
+    # Creates a connection instance
+    #
+    #  == parameters
+    #   
+    #   * host        the hostname for the connection
+    #   * port        the port number for the connection
+    #   * db          the database name for the connection
+    #   * opts        connection options
+    #   * drizzle_ptr FFI pointer to a drizzle_st object
+    #
+    # Some examples :
+    #
+    #   c = Drizzle::Connection.new
+    #   c = Drizzle::Connection.new("my_host", 4427)
+    #   c = Drizzle::Connection.new("my_host", 4427, "my_db")
+    #   c = Drizzle::Connection.new("my_host", 4427, "my_db", [Drizzle::NONE])
+    #
+    def initialize(host = "localhost", port = 4427, db = nil, opts = [], drizzle_ptr = nil)
+      @host = host
+      @port = port
+      @db = db
+      @drizzle_handle = drizzle_ptr || DrizzlePtr.new(LibDrizzle.drizzle_create(nil))
+      @con_ptr = ConnectionPtr.new(LibDrizzle.drizzle_con_create(@drizzle_handle, nil))
+      @rand_key = ""
+
+      opts.each do |opt|
+        if opt == INJECTION_PREVENTION
+          @randomize_queries = true
+          next
+        end
+        LibDrizzle.drizzle_con_add_options(@con_ptr, LibDrizzle::ConnectionOptions[opt])
+      end
+      LibDrizzle.drizzle_con_set_tcp(@con_ptr, @host, @port) 
+      LibDrizzle.drizzle_con_set_db(@con_ptr, @db) if @db
+      @ret_ptr = FFI::MemoryPointer.new(:int)
+
+      # 
+      # if SQL injection prevention is enabled, we need to retrieve
+      # the key to use for randomization from the server
+      #
+      if @randomize_queries == true
+        query = "show variables like '%stad_key%'"
+        res = LibDrizzle.drizzle_query_str(@con_ptr, nil, query, @ret_ptr)
+        check_return_code
+        result = Result.new(res)
+        result.buffer_result
+        result.each do |row|
+          @rand_key = row[1]
+        end
+      end
+    end
+
+    # 
+    # set the host and port for the connection
+    #
+    def set_tcp(host, port)
+      @host = host
+      @port = port
+      LibDrizzle.drizzle_con_set_tcp(@con_ptr, @host, @port)
+    end
+
+    # 
+    # set the database name for the connection
+    #
+    def set_db(db_name)
+      @db = db_name
+      LibDrizzle.drizzle_con_set_db(@con_ptr, @db)
+    end
+
+    # 
+    # execute a query and construct a result object
+    #
+    def query(query)
+      res = LibDrizzle.drizzle_query_str(@con_ptr, nil, query, @ret_ptr)
+      check_return_code
+      Result.new(res)
+    end
+
+    # 
+    # tokenize the input query and append the randomization key to
+    # keywords
+    #
+    def randomize_query(query)
+      if @rand_key.empty?
+        return query
+      end
+      toks = query.split(" ")
+      new_query = ""
+      toks.each do |token|
+        if Keywords[token.downcase] == true
+          token << @rand_key
+        end
+        new_query << token << " "
+      end
+      new_query
+    end
+
+    def check_return_code()
+      case LibDrizzle::ReturnCode[@ret_ptr.get_int(0)]
+      when :DRIZZLE_RETURN_IO_WAIT
+        raise IoWait.new(LibDrizzle.drizzle_error(@drizzle_handle))
+      when :DRIZZLE_RETURN_PAUSE
+        raise Pause.new(LibDrizzle.drizzle_error(@drizzle_handle))
+      when :DRIZZLE_RETURN_ROW_BREAK
+        raise RowBreak.new(LibDrizzle.drizzle_error(@drizzle_handle))
+      when :DRIZZLE_RETURN_MEMORY
+        raise Memory.new(LibDrizzle.drizzle_error(@drizzle_handle))
+      when :DRIZZLE_RETURN_INTERNAL_ERROR
+        raise InternalError.new(LibDrizzle.drizzle_error(@drizzle_handle))
+      when :DRIZZLE_RETURN_NOT_READY
+        raise NotReady.new(LibDrizzle.drizzle_error(@drizzle_handle))
+      when :DRIZZLE_RETURN_BAD_PACKET_NUMBER
+        raise BadPacketNumber.new(LibDrizzle.drizzle_error(@drizzle_handle))
+      when :DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET
+        raise BadHandshake.new(LibDrizzle.drizzle_error(@drizzle_handle))
+      when :DRIZZLE_RETURN_BAD_PACKET
+        raise BadPacket.new(LibDrizzle.drizzle_error(@drizzle_handle))
+      when :DRIZZLE_RETURN_PROTOCOL_NOT_SUPPORTED
+        raise ProtocolNotSupported.new(LibDrizzle.drizzle_error(@drizzle_handle))
+      when :DRIZZLE_RETURN_UNEXPECTED_DATA
+        raise UnexpectedData.new(LibDrizzle.drizzle_error(@drizzle_handle))
+      when :DRIZZLE_RETURN_NO_SCRAMBLE
+        raise NoScramble.new(LibDrizzle.drizzle_error(@drizzle_handle))
+      when :DRIZZLE_RETURN_AUTH_FAILED
+        raise AuthFailed.new(LibDrizzle.drizzle_error(@drizzle_handle))
+      when :DRIZZLE_RETURN_NULL_SIZE
+        raise NullSize.new(LibDrizzle.drizzle_error(@drizzle_handle))
+      when :DRIZZLE_RETURN_TOO_MANY_COLUMNS
+        raise TooManyColumns.new(LibDrizzle.drizzle_error(@drizzle_handle))
+      when :DRIZZLE_RETURN_ROW_END
+        raise RowEnd.new(LibDrizzle.drizzle_error(@drizzle_handle))
+      when :DRIZZLE_RETURN_LOST_CONNECTION
+        raise LostConnection.new(LibDrizzle.drizzle_error(@drizzle_handle))
+      when :DRIZZLE_RETURN_COULD_NOT_CONNECT
+        raise CouldNotConnect.new(LibDrizzle.drizzle_error(@drizzle_handle))
+      when :DRIZZLE_RETURN_NO_ACTIVE_CONNECTIONS
+        raise NoActiveConnections.new(LibDrizzle.drizzle_error(@drizzle_handle))
+      when :DRIZZLE_RETURN_HANDSHAKE_FAILED
+        raise HandshakeFailed.new(LibDrizzle.drizzle_error(@drizzle_handle))
+      when :DRIZZLE_RETURN_TIMEOUT
+        raise ReturnTimeout.new(LibDrizzle.drizzle_error(@drizzle_handle))
+      end
+    end
+
+  end
+
+end

data/lib/drizzle/drizzle.rb

@@ -0,0 +1,58 @@
+require 'drizzle/ffidrizzle'
+
+module Drizzle
+
+  class DrizzlePtr < FFI::AutoPointer
+    def self.release(ptr)
+      LibDrizzle.drizzle_free(ptr)
+    end
+  end
+
+  # 
+  # A Drizzle instance
+  #
+  class Drizzle
+
+    # 
+    # creates a drizzle instance
+    #
+    def initialize()
+      @handle = DrizzlePtr.new(LibDrizzle.drizzle_create(nil))
+    end
+
+    # 
+    # create a client connection
+    #
+    def create_client_connection(host, port, db)
+      Connection.new(host, port, db, @handle)
+    end
+
+    # 
+    # return the libdrizzle API version
+    #
+    def version()
+      LibDrizzle.drizzle_version
+    end
+
+    # 
+    # return the bug report URL to file libdrizzle bugs at
+    #
+    def bug_report_url()
+      LibDrizzle.drizzle_bugreport
+    end
+
+    #
+    # add a query to be run concurrently
+    #
+    def add_query(conn, query, query_num, opts = [])
+    end
+
+    # 
+    # execute all queries concurrently
+    #
+    def run_all()
+    end
+
+  end
+
+end

data/lib/drizzle/exceptions.rb

@@ -0,0 +1,28 @@
+require 'drizzle/ffidrizzle'
+
+module Drizzle
+
+  class IoWait < RuntimeError; end
+  class Pause < RuntimeError; end
+  class RowBreak < RuntimeError; end
+  class Memory < RuntimeError; end
+  class InternalError < RuntimeError; end
+  class NotReady < RuntimeError; end
+  class BadPacketNumber < RuntimeError; end
+  class BadHandshake < RuntimeError; end
+  class BadPacket < RuntimeError; end
+  class ProtocolNotSupported < RuntimeError; end
+  class UnexpectedData < RuntimeError; end
+  class NoScramble < RuntimeError; end
+  class AuthFailed < RuntimeError; end
+  class NullSize < RuntimeError; end
+  class TooManyColumns < RuntimeError; end
+  class RowEnd < RuntimeError; end
+  class LostConnection < RuntimeError; end
+  class CouldNotConnect < RuntimeError; end
+  class NoActiveConnections < RuntimeError; end
+  class HandshakeFailed < RuntimeError; end
+  class Timeout < RuntimeError; end
+  class GeneralError < RuntimeError; end
+
+end

data/lib/drizzle/ffidrizzle.rb

@@ -0,0 +1,130 @@
+require 'rubygems'
+require 'ffi'
+
+module LibDrizzle
+  extend FFI::Library
+  ffi_lib 'drizzle'
+
+  # constants
+  MAX_ERROR_SIZE = 2048
+  MAX_USER_SIZE = 64
+  MAX_PASSWORD_SIZE = 32
+  MAX_DB_SIZE = 64
+  MAX_INFO_SIZE = 2048
+  MAX_SQLSTATE_SIZE = 5
+  MAX_CATALOG_SIZE = 128
+  MAX_TABLE_SIZE = 128
+
+  # return codes
+  ReturnCode = enum( :DRIZZLE_RETURN_OK, 0,
+                     :DRIZZLE_RETURN_IO_WAIT,
+                     :DRIZZLE_RETURN_PAUSE,
+                     :DRIZZLE_RETURN_ROW_BREAK,
+                     :DRIZZLE_RETURN_MEMORY,
+                     :DRIZZLE_RETURN_ERRNO,
+                     :DRIZZLE_RETURN_INTERNAL_ERROR,
+                     :DRIZZLE_RETURN_GETADDRINFO,
+                     :DRIZZLE_RETURN_NOT_READY,
+                     :DRIZZLE_RETURN_BAD_PACKET_NUMBER,
+                     :DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET,
+                     :DRIZZLE_RETURN_BAD_PACKET,
+                     :DRIZZLE_RETURN_PROTOCOL_NOT_SUPPORTED,
+                     :DRIZZLE_RETURN_UNEXPECTED_DATA,
+                     :DRIZZLE_RETURN_NO_SCRAMBLE,
+                     :DRIZZLE_RETURN_AUTH_FAILED,
+                     :DRIZZLE_RETURN_NULL_SIZE,
+                     :DRIZZLE_RETURN_ERROR_CODE,
+                     :DRIZZLE_RETURN_TOO_MANY_COLUMNS,
+                     :DRIZZLE_RETURN_ROW_END,
+                     :DRIZZLE_RETURN_LOST_CONNECTION,
+                     :DRIZZLE_RETURN_COULD_NOT_CONNECT,
+                     :DRIZZLE_RETURN_NO_ACTIVE_CONNECTIONS,
+                     :DRIZZLE_RETURN_HANDSHAKE_FAILED,
+                     :DRIZZLE_RETURN_TIMEOUT,
+                     :DRIZZLE_RETURN_MAX )
+  
+  # verbosity levels
+  VerbosityLevel = enum( :DRIZZLE_VERBOSE_NEVER, 0,
+                         :DRIZZLE_VERBOSE_FATAL,
+                         :DRIZZLE_VERBOSE_ERROR,
+                         :DRIZZLE_VERBOSE_INFO,
+                         :DRIZZLE_VERBOSE_DEBUG,
+                         :DRIZZLE_VERBOSE_CRAZY,
+                         :DRIZZLE_VERBOSE_MAX )
+
+  # options for the Drizzle protocol functions.
+  CommandTypes = enum( :DRIZZLE_COMMAND_DRIZZLE_SLEEP, 0,
+                       :DRIZZLE_COMMAND_DRIZZLE_QUIT,
+                       :DRIZZLE_COMMAND_DRIZZLE_INIT_DB,
+                       :DRIZZLE_COMMAND_DRIZZLE_QUERY,
+                       :DRIZZLE_COMMAND_DRIZZLE_SHUTDOWN,
+                       :DRIZZLE_COMMAND_DRIZZLE_CONNECT,
+                       :DRIZZLE_COMMAND_DRIZZLE_PING,
+                       :DRIZZLE_COMMAND_DRIZZLE_END )
+
+  # Status flags for a drizzle connection
+  ConnectionStatus = enum( :DRIZZLE_CON_STATUS_NONE, 0,
+                           :DRIZZLE_CON_STATUS_IN_TRANS, (1 << 0),
+                           :DRIZZLE_CON_STATUS_AUTOCOMMIT, (1 << 1),
+                           :DRIZZLE_CON_STATUS_MORE_RESULTS_EXIST, (1 << 3),
+                           :DRIZZLE_CON_STATUS_QUERY_NO_GOOD_INDEX_USED, (1 << 4),
+                           :DRIZZLE_CON_STATUS_QUERY_NO_INDEX_USED, (1 << 5),
+                           :DRIZZLE_CON_STATUS_CURSOR_EXISTS, (1 << 6),
+                           :DRIZZLE_CON_STATUS_LAST_ROW_SENT, (1 << 7),
+                           :DRIZZLE_CON_STATUS_DB_DROPPED, (1 << 8),
+                           :DRIZZLE_CON_STATUS_NO_BACKSLASH_ESCAPES, (1 << 9),
+                           :DRIZZLE_CON_STATUS_QUERY_WAS_SLOW, (1 << 10) )
+
+  # Options for connections
+  ConnectionOptions = enum( :DRIZZLE_CON_NONE, 0,
+                            :DRIZZLE_CON_ALLOCATED, (1 << 0),
+                            :DRIZZLE_CON_MYSQL, (1 << 1),
+                            :DRIZZLE_CON_RAW_PACKET, (1 << 2),
+                            :DRIZZLE_CON_RAW_SCRAMBLE, (1 << 3),
+                            :DRIZZLE_CON_READY, (1 << 4),
+                            :DRIZZLE_CON_NO_RESULT_READ, (1 << 5) )
+
+  # query options
+  QueryOptions = enum( :DRIZZLE_QUERY_ALLOCATED, (1 << 0) )
+
+  # options for main drizzle structure
+  Options = enum( :DRIZZLE_NONE, 0,
+                  :DRIZZLE_ALLOCATED, (1 << 0),
+                  :DRIZZLE_NON_BLOCKING, (1 << 1),
+                  :DRIZZLE_FREE_OBJECTS, (1 << 2),
+                  :DRIZZLE_ASSERT_DANGLING, (1 << 3) )
+
+  attach_function :drizzle_create, [ :pointer ], :pointer
+  attach_function :drizzle_free, [ :pointer ], :void
+  attach_function :drizzle_set_verbose, [ :pointer, VerbosityLevel ], :void
+
+  # connection related functions
+  attach_function :drizzle_con_create, [ :pointer, :pointer ], :pointer
+  attach_function :drizzle_con_free, [ :pointer ], :void
+  attach_function :drizzle_con_set_tcp, [ :pointer, :string, :int ], :void
+  attach_function :drizzle_con_set_db, [ :pointer, :string ], :void
+  attach_function :drizzle_con_add_options, [ :pointer, ConnectionOptions ], :void
+  attach_function :drizzle_con_fd, [ :pointer ], :int
+
+  # query related functions
+  attach_function :drizzle_query_str, [ :pointer, :pointer, :string, :pointer ], :pointer
+  attach_function :drizzle_query_add, [ :pointer, :pointer, :pointer, :pointer, :string, :size_t, QueryOptions, :pointer ], :pointer
+  attach_function :drizzle_result_read, [ :pointer, :pointer, :pointer ], :pointer
+  attach_function :drizzle_row_buffer, [ :pointer, :pointer ], :pointer
+  attach_function :drizzle_row_free, [ :pointer ], :void
+  attach_function :drizzle_result_buffer, [ :pointer ], ReturnCode
+  attach_function :drizzle_result_free, [ :pointer ], :void
+  attach_function :drizzle_row_next, [ :pointer ], :pointer
+  attach_function :drizzle_column_next, [ :pointer ], :pointer
+  attach_function :drizzle_column_name, [ :pointer ], :string
+  attach_function :drizzle_column_buffer, [ :pointer ], ReturnCode
+  attach_function :drizzle_result_column_count, [ :pointer ], :uint16
+  attach_function :drizzle_result_affected_rows, [ :pointer ], :uint64
+  attach_function :drizzle_result_insert_id, [ :pointer ], :uint64
+
+  # miscellaneous functions
+  attach_function :drizzle_version, [], :string
+  attach_function :drizzle_bugreport, [], :string
+  attach_function :drizzle_error, [ :pointer ], :string
+
+end

data/lib/drizzle/result.rb

@@ -0,0 +1,95 @@
+require 'drizzle/ffidrizzle'
+
+module Drizzle
+
+  # 
+  # a result set from a drizzle query
+  #
+  class Result
+
+    attr_reader :columns, :rows, :affected_rows, :insert_id
+
+    # 
+    # creates a result set instance
+    # This result set does not buffer any results until instructed
+    # to do so. Results can be fully buffered or buffered at the
+    # row level.
+    #
+    # == parameters
+    #
+    #  * res_ptr   FFI memory pointer to a drizzle_result_t object
+    #
+    def initialize(res_ptr)
+      @columns, @rows = [], []
+      @res_ptr = res_ptr
+      @affected_rows = LibDrizzle.drizzle_result_affected_rows(@res_ptr)
+      @insert_id = LibDrizzle.drizzle_result_insert_id(@res_ptr)
+    end
+
+    # 
+    # buffer all rows and columns and copy them into ruby arrays
+    # Free the FFI pointer afterwards
+    #
+    def buffer_result()
+      ret = LibDrizzle.drizzle_result_buffer(@res_ptr)
+      if LibDrizzle::ReturnCode[ret] != LibDrizzle::ReturnCode[:DRIZZLE_RETURN_OK]
+        LibDrizzle.drizzle_result_free(@res_ptr)
+      end
+
+      loop do
+        col_ptr = LibDrizzle.drizzle_column_next(@res_ptr)
+        break if col_ptr.null?
+        @columns << LibDrizzle.drizzle_column_name(col_ptr).to_sym
+      end
+
+      loop do
+        row_ptr = LibDrizzle.drizzle_row_next(@res_ptr)
+        break if row_ptr.null?
+        @rows << row_ptr.get_array_of_string(0, @columns.size)
+      end
+
+      LibDrizzle.drizzle_result_free(@res_ptr)
+    end
+
+    # 
+    # buffer an individual row.
+    #
+    def buffer_row()
+      # if the columns have not been read for this result
+      # set yet, then we need to do that here. If this is not
+      # performed here, we will receive a bad packet error
+      read_columns if @columns.empty?
+      ret_ptr = FFI::MemoryPointer.new(:int)
+      row_ptr = LibDrizzle.drizzle_row_buffer(@res_ptr, ret_ptr)
+      if LibDrizzle::ReturnCode[ret_ptr.get_int(0)] != :DRIZZLE_RETURN_OK
+        LibDrizzle.drizzle_result_free(@res_ptr)
+      end
+      if row_ptr.null?
+        LibDrizzle.drizzle_result_free(@res_ptr)
+        return nil
+      end
+      num_of_cols = LibDrizzle.drizzle_result_column_count(@res_ptr)
+      row = row_ptr.get_array_of_string(0, @columns.size)
+    end
+
+    # 
+    # buffer all columns for this result set
+    #
+    def read_columns
+      ret = LibDrizzle.drizzle_column_buffer(@res_ptr)
+      loop do
+        col_ptr = LibDrizzle.drizzle_column_next(@res_ptr)
+        break if col_ptr.null?
+        @columns << LibDrizzle.drizzle_column_name(col_ptr).to_sym
+      end
+    end
+
+    def each
+      @rows.each do |row|
+        yield row if block_given?
+      end
+    end
+
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+
+require File.join(File.dirname(__FILE__), *%w[.. lib drizzle])
+
+require 'test/unit'
+require 'shoulda'
+require 'rr'
+
+include Drizzle
+
+PORT = 4427
+
+class Test::Unit::TestCase
+  include RR::Adapters::TestUnit
+
+  def dest_dir(*subdirs)
+    File.join(File.dirname(__FILE__), 'dest', *subdirs)
+  end
+
+  def source_dir(*subdirs)
+    File.join(File.dirname(__FILE__), 'source', *subdirs)
+  end
+
+  def clear_dest
+    FileUtils.rm_rf(dest_dir)
+  end
+
+end

data/test/test_basic.rb

@@ -0,0 +1,103 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestBasic < Test::Unit::TestCase
+
+  should "retrieve libdrizzle API version" do
+    drizzle = Drizzle::Drizzle.new
+    assert_equal "0.7", drizzle.version
+  end
+
+  should "retrieve libdrizzle bug report url" do
+    drizzle = Drizzle::Drizzle.new
+    assert_equal "https://launchpad.net/libdrizzle", drizzle.bug_report_url
+  end
+
+  should "connect to drizzle successfully" do
+    conn = Drizzle::Connection.new("localhost", PORT)
+    assert_equal conn.class, Drizzle::Connection
+  end
+
+  should "perform a simple query and buffer all results" do
+    conn = Drizzle::Connection.new("localhost", PORT, "data_dictionary")
+    res = conn.query("SELECT module_name, module_author FROM MODULES where module_name = 'SchemaEngine'")
+    assert_equal res.class, Drizzle::Result
+    res.buffer_result
+    assert_equal 2, res.columns.size
+    res.each do |row|
+      assert_equal "Brian Aker", row[1]
+    end
+  end
+
+  should "perform another simple query and buffer all results" do
+    conn = Drizzle::Connection.new("localhost", PORT, "information_schema", [Drizzle::NONE])
+    res = conn.query("SELECT table_schema, table_name FROM TABLES WHERE table_schema = 'DATA_DICTIONARY' AND table_name = 'GLOBAL_STATUS'")
+    assert_equal res.class, Drizzle::Result
+    res.buffer_result
+    assert_equal 2, res.columns.size
+    res.each do |row|
+      assert_equal "DATA_DICTIONARY", row[0]
+      assert_equal "GLOBAL_STATUS", row[1]
+    end
+  end
+
+  should "perform a simple query and buffer rows" do
+    conn = Drizzle::Connection.new("localhost", PORT, "information_schema")
+    res = conn.query("SELECT COUNT(*) FROM COLUMNS WHERE table_name = 'GLOBAL_STATUS'")
+    assert_equal res.class, Drizzle::Result
+    until (row = res.buffer_row).nil?
+      assert_equal "2", row[0]
+    end
+  end
+
+  should "create and drop a database" do
+    conn = Drizzle::Connection.new("localhost", PORT)
+    res = conn.query("CREATE DATABASE padraig")
+    res = conn.query("select table_schema from information_schema.tables where table_schema = 'padraig'")
+    assert_equal res.class, Drizzle::Result
+    res.buffer_result
+    assert_equal 1, res.columns.size 
+    res.each do |row|
+      assert_equal "padraig", row[0]
+    end
+    res = conn.query("DROP DATABASE padraig")
+    res = conn.query("select table_schema from information_schema.tables where table_schema = 'padraig'")
+    assert_equal res.class, Drizzle::Result
+    res.buffer_result
+    assert_equal 1, res.columns.size
+    assert_equal true, res.rows.empty?
+  end
+
+  should "use different connection options" do
+    conn = Drizzle::Connection.new("localhost", PORT, "information_schema", [Drizzle::NONE])
+    res = conn.query("SELECT COUNT(*) FROM COLUMNS WHERE table_name = 'GLOBAL_STATUS'")
+    assert_equal res.class, Drizzle::Result
+    until (row = res.buffer_row).nil?
+      assert_equal "2", row[0]
+    end
+    conn = Drizzle::Connection.new("localhost", PORT, "information_schema", [Drizzle::NONE, Drizzle::MYSQL])
+    res = conn.query("SELECT COUNT(*) FROM COLUMNS WHERE table_name = 'GLOBAL_STATUS'")
+    assert_equal res.class, Drizzle::Result
+    until (row = res.buffer_row).nil?
+      assert_equal "2", row[0]
+    end
+  end
+
+  should "perform a query with a code block" do
+    conn = Drizzle::Connection.new("localhost", PORT, "information_schema", [Drizzle::NONE])
+    conn.query("SELECT COUNT(*) FROM COLUMNS WHERE table_name = 'GLOBAL_STATUS'") do |res|
+      assert_equal res.class, Drizzle::Result
+      until (row = res.buffer_row).nil?
+        assert_equal "2", row[0]
+      end
+    end
+  end
+
+  should "perform a simple show variables command" do
+    conn = Drizzle::Connection.new("localhost", PORT, "information_schema", [Drizzle::NONE])
+    assert_equal conn.class, Drizzle::Connection
+    res = conn.query("show variables")
+    assert_equal res.class, Drizzle::Result
+    res.buffer_result
+  end
+
+end

data/test/test_complex.rb

@@ -0,0 +1,133 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestBasic < Test::Unit::TestCase
+
+  def setup
+    conn = Drizzle::Connection.new("localhost", PORT)
+    res = conn.query("CREATE DATABASE drizzleruby")
+  end
+
+  def teardown
+    conn = Drizzle::Connection.new("localhost", PORT)
+    res = conn.query("DROP DATABASE drizzleruby")
+  end
+
+  should "create and drop a table" do
+    conn = Drizzle::Connection.new("localhost", PORT, "drizzleruby")
+    res = conn.query("select table_schema from information_schema.tables where table_schema = 'drizzleruby'")
+    assert_equal res.class, Drizzle::Result
+    res.buffer_result
+    assert_equal 1, res.columns.size
+    res.each do |row|
+      assert_equal "drizzleruby", row[0]
+    end
+    res = conn.query("create table t1(a int, b varchar(255))")
+    res = conn.query("select table_schema, table_name from information_schema.tables where table_schema = 'drizzleruby'")
+    res.buffer_result
+    assert_equal 2, res.columns.size
+    res.each do |row|
+      assert_equal "t1", row[1]
+    end
+    res = conn.query("DROP TABLE t1")
+    res = conn.query("select table_name from information_schema.tables where table_schema = 'drizzleruby'")
+    assert_equal res.class, Drizzle::Result
+    res.buffer_result
+    assert_equal 1, res.columns.size
+    assert_equal true, res.rows.empty?
+  end
+
+  should "update affected rows appropriately" do
+    conn = Drizzle::Connection.new("localhost", PORT, "drizzleruby")
+    res = conn.query("select table_schema from information_schema.tables where table_schema = 'drizzleruby'")
+    assert_equal res.class, Drizzle::Result
+    res.buffer_result
+    assert_equal 1, res.columns.size
+    res.each do |row|
+      assert_equal "drizzleruby", row[0]
+    end
+    res = conn.query("create table t1(a int, b varchar(255))")
+    res = conn.query("select table_schema, table_name from information_schema.tables where table_schema = 'drizzleruby'")
+    res.buffer_result
+    assert_equal 2, res.columns.size
+    res.each do |row|
+      assert_equal "t1", row[1]
+    end
+    res = conn.query("insert into t1 values (1, 'padraig')")
+    assert_equal 1, res.affected_rows
+    assert_equal 0, res.insert_id
+    res = conn.query("insert into t1 values (2, 'sarah')")
+    assert_equal 1, res.affected_rows
+    assert_equal 0, res.insert_id
+    res = conn.query("select * from t1 where a = 2")
+    res.buffer_result
+    assert_equal 2, res.columns.size
+    res.each do |row|
+      assert_equal "2", row[0]
+      assert_equal "sarah", row[1]
+    end
+    res = conn.query("DROP TABLE t1")
+    res = conn.query("select table_name from information_schema.tables where table_schema = 'drizzleruby'")
+    assert_equal res.class, Drizzle::Result
+    res.buffer_result
+    assert_equal 1, res.columns.size
+    assert_equal true, res.rows.empty?
+  end
+
+  should "perform a multi-insert statement correctly" do
+    conn = Drizzle::Connection.new("localhost", PORT, "drizzleruby")
+    res = conn.query("select table_schema from information_schema.tables where table_schema = 'drizzleruby'")
+    assert_equal res.class, Drizzle::Result
+    res.buffer_result
+    assert_equal 1, res.columns.size
+    res.each do |row|
+      assert_equal "drizzleruby", row[0]
+    end
+    res = conn.query("create table t1(a int, b varchar(255))")
+    res = conn.query("select table_schema, table_name from information_schema.tables where table_schema = 'drizzleruby'")
+    res.buffer_result
+    assert_equal 2, res.columns.size
+    res.each do |row|
+      assert_equal "t1", row[1]
+    end
+    res = conn.query("insert into t1 values (1, 'padraig'), (2, 'sarah'), (3, 'tomas')")
+    assert_equal 3, res.affected_rows
+    res = conn.query("select * from t1 where a = 2")
+    res.buffer_result
+    assert_equal 2, res.columns.size
+    res.each do |row|
+      assert_equal "2", row[0]
+      assert_equal "sarah", row[1]
+    end
+    res = conn.query("DROP TABLE t1")
+    res = conn.query("select table_name from information_schema.tables where table_schema = 'drizzleruby'")
+    assert_equal res.class, Drizzle::Result
+    res.buffer_result
+    assert_equal 1, res.columns.size
+    assert_equal true, res.rows.empty?
+  end
+
+  should "insert and fetch a blob value correctly" do
+    conn = Drizzle::Connection.new("localhost", PORT, "drizzleruby")
+    res = conn.query("create table t1(a int, b blob)")
+    res = conn.query("insert into t1 values (1, 'padraig'), (2, 'sarah'), (3, 'tomas')")
+    assert_equal 3, res.affected_rows
+    res = conn.query("insert into t1 values (4, null), (5, 'blahblahblah'), (6, 'southy')")
+    assert_equal 3, res.affected_rows
+    res = conn.query("select * from t1 where a = 2")
+    res.buffer_result
+    assert_equal 2, res.columns.size
+    res.each do |row|
+      assert_equal "2", row[0]
+      assert_equal "sarah", row[1]
+    end
+    res = conn.query("select * from t1 where a = 4")
+    res.buffer_result
+    assert_equal 2, res.columns.size
+    res.each do |row|
+      assert_equal "4", row[0]
+      assert_equal nil, row[1]
+    end
+    res = conn.query("DROP TABLE t1")
+  end
+
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: drizzle
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Padraig O'Sullivan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-13 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: An interface to Drizzle for Ruby that uses libdrizzle
+email: osullivan.padraig@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/drizzle.rb
+- lib/drizzle/connection.rb
+- lib/drizzle/drizzle.rb
+- lib/drizzle/exceptions.rb
+- lib/drizzle/ffidrizzle.rb
+- lib/drizzle/result.rb
+- test/helper.rb
+- test/test_basic.rb
+- test/test_complex.rb
+has_rdoc: true
+homepage: http://github.com/posulliv/drizzle-ruby
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: drizzle-ruby
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A ruby interface to Drizzle using libdrizzle
+test_files: 
+- test/helper.rb
+- test/test_basic.rb
+- test/test_complex.rb