yakischloba-drizzle-ffi 0.0.2

data/README.rdoc

@@ -0,0 +1,42 @@
+Currently a simple client-oriented hookup to libdrizzle with ffi, for querying drizzle and mysql servers.
+
+Not really sure where I'm going with this. Ping me if you have input.
+
+== Synopsis
+
+=== Normal synchronous query
+
+ irb(main):001:0> require 'rubygems'
+ => true
+ irb(main):002:0> require 'lib/drizzle'
+ => true
+ irb(main):003:0> c = Drizzle::Connection.new("127.0.0.1", "root", "password", nil, :DRIZZLE_CON_MYSQL)
+ => #<Native Pointer address=0x0>
+ irb(main):004:0> r = c.query("select now()")
+ => #<Drizzle::Result:0x12f4dc8 @rows=[["2009-05-21 07:41:26"]], @columns=[:"now()"], @affected_rows=0, @insert_id=0>
+ irb(main):005:0> r.each {|row| puts row[0] }
+ 2009-05-21 07:41:26
+ => [["2009-05-21 07:41:26"]]
+ irb(main):006:0> r.columns
+ => [:"now()"]
+
+=== Async query with EventMachine
+
+ irb(main):001:0> require 'rubygems'
+ => true
+ irb(main):002:0> require 'lib/drizzle'
+ r=> true
+ irb(main):003:0> require 'eventmachine'
+ => true
+ irb(main):004:0> c = Drizzle::Connection.new("127.0.0.1", "root", "password", "mysql", :DRIZZLE_CON_MYSQL)
+ => #<Native Pointer address=0x0>
+ irb(main):005:0> EM.run {
+ irb(main):006:1*   c.em_query("show tables") do |result|
+ irb(main):007:2*     p result.columns
+ irb(main):008:2>     p result.rows
+ irb(main):009:2>   end
+ irb(main):010:1> }
+
+ [:Tables_in_mysql]
+
+ [["columns_priv"], ["db"], ["func"], ["help_category"], ["help_keyword"], ["help_relation"], ["help_topic"], ["host"], ["proc"], ["procs_priv"], ["tables_priv"], ["time_zone"], ["time_zone_leap_second"], ["time_zone_name"], ["time_zone_transition"], ["time_zone_transition_type"], ["user"], ["user_info"]]

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake' unless defined?(Rake)
+
+task :default => [:test]
+
+task :test do
+  require 'rubygems'
+  require 'lib/drizzle'
+  require 'bacon'
+  Bacon.summary_on_exit
+  load "tests/basic.rb"
+end

data/drizzle.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |s|
+  s.name = "drizzle-ffi"
+  s.version = "0.0.2"
+  s.date = "2009-08-07"
+  s.authors = ["Jake Douglas"]
+  s.email = "jakecdouglas@gmail.com"
+  s.has_rdoc = false
+  s.add_dependency('ffi')
+  s.add_dependency('bacon')
+  s.summary = "libdrizzle ffi"
+  s.homepage = "http://www.github.com/yakischloba/libdrizzle-ruby-ffi"
+  s.description = "libdrizzle ffi"
+  s.files =
+    ["drizzle.gemspec",
+    "README.rdoc",
+    "Rakefile",
+    "lib/drizzle.rb",
+    "lib/drizzle/drizzle.rb",
+    "tests/basic.rb"]
+end

data/lib/drizzle/drizzle.rb

@@ -0,0 +1,229 @@
+module Drizzle
+  extend FFI::Library
+  ffi_lib "libdrizzle"
+
+  class DrizzleException < RuntimeError; end
+
+  enum :drizzle_return_t, [
+    :DRIZZLE_RETURN_OK,
+    :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_EOF,
+    :DRIZZLE_RETURN_COULD_NOT_CONNECT,
+    :DRIZZLE_RETURN_NO_ACTIVE_CONNECTIONS,
+    :DRIZZLE_RETURN_SERVER_GONE,
+    :DRIZZLE_RETURN_MAX
+  ]
+
+  enum :drizzle_con_options_t, [
+    :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)
+  ]
+
+  enum :drizzle_options_t, [
+    :DRIZZLE_NONE,         0,
+    :DRIZZLE_ALLOCATED,    (1 << 0),
+    :DRIZZLE_NON_BLOCKING, (1 << 1)
+  ]
+
+  def self.options
+    enum_type(:drizzle_options_t)
+  end
+
+  def self.return_codes
+    enum_type(:drizzle_return_t)
+  end
+
+  def self.con_options
+    enum_type(:drizzle_con_options_t)
+  end
+
+  # Misc
+  attach_function :version,               :drizzle_version,                   [],                                       :string
+
+  # Drizzle objects
+  attach_function :create,                :drizzle_create,                    [:pointer],                               :pointer
+  attach_function :free,                  :drizzle_free,                      [:pointer],                               :void
+  attach_function :error,                 :drizzle_error,                     [:pointer],                               :string
+  attach_function :add_options,           :drizzle_add_options,               [:pointer, :drizzle_options_t],           :void
+  callback        :event_watch_callback,  [:pointer, :short, :pointer],       :drizzle_return_t
+
+  attach_function :set_event_watch,       :drizzle_set_event_watch,           [:pointer, :event_watch_callback, :pointer],        :void
+
+  # Connection objects
+  attach_function :con_create,            :drizzle_con_create,                [:pointer, :pointer],                     :pointer
+  attach_function :con_free,              :drizzle_con_free,                  [:pointer],                               :void
+  attach_function :con_set_db,            :drizzle_con_set_db,                [:pointer, :string],                      :void
+  attach_function :con_set_auth,          :drizzle_con_set_auth,              [:pointer, :string, :string],             :void
+  attach_function :con_add_options,       :drizzle_con_add_options,           [:pointer, :drizzle_con_options_t],       :void
+  attach_function :con_status,            :drizzle_con_status,                [:pointer],                               :int
+  attach_function :con_fd,                :drizzle_con_fd,                    [:pointer],                               :int
+  attach_function :con_clone,             :drizzle_con_clone,                 [:pointer, :pointer, :pointer],           :pointer
+  attach_function :con_set_revents,       :drizzle_con_set_revents,           [:pointer, :short],                       :void
+
+  # Querying
+  attach_function :query_str,             :drizzle_query_str,                 [:pointer, :pointer, :string, :pointer],  :pointer
+
+  # Results
+  attach_function :result_create,         :drizzle_result_create,             [:pointer, :pointer],                     :pointer
+  attach_function :result_buffer,         :drizzle_result_buffer,             [:pointer],                               :int
+  attach_function :result_free,           :drizzle_result_free,               [:pointer],                               :drizzle_return_t
+  attach_function :result_affected_rows,  :drizzle_result_affected_rows,      [:pointer],                               :uint64  
+  attach_function :result_insert_id,      :drizzle_result_insert_id,          [:pointer],                               :uint64
+  attach_function :row_next,              :drizzle_row_next,                  [:pointer],                               :pointer
+  attach_function :result_read,           :drizzle_result_read,               [:pointer, :pointer, :pointer],           :pointer
+
+  # Columns
+  attach_function :column_next,           :drizzle_column_next,               [:pointer],                               :pointer
+  attach_function :column_name,           :drizzle_column_name,               [:pointer],                               :string
+
+  class Result
+    attr_reader :columns, :affected_rows, :insert_id, :rows
+
+    def initialize(ptr)
+      @columns, @rows = [], []
+
+      @insert_id = Drizzle.result_insert_id(ptr)
+      @affected_rows = Drizzle.result_affected_rows(ptr)
+
+      # Get columns
+      until (column = Drizzle.column_next(ptr)).null?
+        @columns << Drizzle.column_name(column).to_sym
+      end
+
+      # Get rows
+      until (row = Drizzle.row_next(ptr)).null?
+        @rows << row.get_array_of_string(0, @columns.size)
+      end
+
+      # Free the underlying buffers since we just copied it all to Ruby
+      Drizzle.result_free(ptr)
+    end
+
+    def each
+      @rows.each do |row|
+        yield row if block_given?
+      end
+    end
+  end
+  
+  class Drizzleptr < FFI::AutoPointer
+    def self.release(ptr)
+      Drizzle.free(ptr)
+    end
+  end
+  
+  class Connptr < FFI::AutoPointer
+    def self.release(ptr)
+      Drizzle.conn_free(ptr)
+    end
+  end
+
+  class Connection
+    attr_accessor :host, :user, :pass, :db, :opts, :fd
+
+    def initialize(host, user, pass, db=nil, opts=[], drizzle=nil)
+      opts = opts.is_a?(Array) ? opts : [opts]
+      @host, @user, @pass, @db, @opts = host, user, pass, db, opts
+      @from_pool = true if drizzle
+      @drizzle = drizzle || Drizzleptr.new(Drizzle.create(nil))
+      @conn = Connptr.new(Drizzle.con_create(@drizzle, nil))
+      Drizzle.con_add_options(@conn, opts.inject(0){|i,o| i | Drizzle.enum_value(o)} | Drizzle.enum_value(:DRIZZLE_CON_NO_RESULT_READ))
+      Drizzle.con_set_auth(@conn, @user, @pass)
+      Drizzle.con_set_db(@conn, @db) if @db
+      @retptr = FFI::MemoryPointer.new(:int)
+    end
+
+    # Indicates whether or not this connection was created using a drizzle_st object from somewhere else.
+    def from_pool?
+      @from_pool
+    end
+
+    # This executes a normal synchronous query. We simply call the async methods together.
+    def query(query, proc=nil, &blk)
+      proc ||= blk
+      async_query(query, proc)
+      async_result
+    end
+
+    # Sends off a query to the server. The return value is the file descriptor number of the socket used for this connection, for monitoring with an event loop etc.
+    def async_query(query, proc=nil, &blk)
+      proc ||= blk
+      Drizzle.query_str(@conn, nil, query, @retptr)
+      # Make sure it was successful
+      check_error
+      @callback = proc
+      # return fd to caller
+      @fd ||= Drizzle.con_fd(@conn)
+    end
+
+    # Do a blocking read for the result of an outstanding query. This results the Result object as well as fires a callback associated with it.
+    def async_result
+      # Do a partial blocking read into the the packet struct
+      result = Drizzle.result_read(@conn, nil, @retptr)
+
+      # See if the read was successful
+      check_error
+
+      # Buffer the result and check
+      ret = Drizzle.result_buffer(result)
+      if Drizzle.return_codes[ret] != :DRIZZLE_RETURN_OK
+        # Free the result struct if we fail.
+        Drizzle.result_free(result)
+        raise DrizzleException.new("Query failed: #{Drizzle.error(@drizzle)}")
+      end
+
+      # Fire and return
+      r = Result.new(result)
+      @callback.call(r) if @callback
+      @callback = nil
+      r
+    end
+
+    def em_query(query, proc=nil, &blk)
+      proc ||= blk
+      fd = async_query(query, proc)
+      EM.watch(fd, EMHandler, self) {|c| c.notify_readable = true}
+    end
+
+    def check_error
+      if Drizzle.return_codes[@retptr.get_int(0)] != :DRIZZLE_RETURN_OK
+        raise DrizzleException.new("Query failed: #{Drizzle.error(@drizzle)}")
+      end
+    end
+
+  end
+
+  module EMHandler
+    def initialize(conn)
+      @conn = conn
+    end
+    def notify_readable
+      detach
+      @conn.async_result
+    end
+  end
+
+end

data/lib/drizzle.rb

@@ -0,0 +1,3 @@
+$:.unshift File.expand_path(File.dirname(File.expand_path(__FILE__)))
+require 'ffi'
+require 'drizzle/drizzle'

data/tests/basic.rb

@@ -0,0 +1,104 @@
+require 'set'
+begin
+  require 'eventmachine'
+rescue LoadError
+end
+
+HOST = "127.0.0.1"
+USER = "root"
+PASS = "password"
+
+describe "Basic libdrizzle operation" do
+
+  it "perform a simple synchronous query on a MySQL server" do
+    c = Drizzle::Connection.new(HOST, USER, PASS, "information_schema", :DRIZZLE_CON_MYSQL)
+    schemas, tables = Set.new, Set.new
+    result = c.query("SELECT table_schema,table_name FROM tables")
+    result.class.should.equal Drizzle::Result
+    result.affected_rows.should.equal 0
+    result.insert_id.should.equal 0
+    result.columns.size.should.equal 2
+    result.columns.should.include :table_schema
+    result.columns.should.include :table_name
+
+    result.each do |row|
+      schemas << row[0]
+      tables << row[1]
+    end
+
+    schemas.should.include "information_schema"
+    tables.should.include "COLUMNS"
+  end
+
+  it "send and receive a query asynchronously" do
+    c = Drizzle::Connection.new(HOST, USER, PASS, "information_schema", :DRIZZLE_CON_MYSQL)
+    fd = c.async_query("SELECT table_schema,table_name FROM tables")
+
+    schemas, tables = Set.new, Set.new
+    result = c.async_result
+    result.class.should.equal Drizzle::Result
+    result.affected_rows.should.equal 0
+    result.insert_id.should.equal 0
+
+    result.columns.size.should.equal 2
+    result.columns.should.include :table_schema
+    result.columns.should.include :table_name
+
+    result.each do |row|
+      schemas << row[0]
+      tables << row[1]
+    end
+
+    schemas.should.include "information_schema"
+    tables.should.include "COLUMNS"
+  end
+
+  it "send and receive a query asynchronously using a callback" do
+    c = Drizzle::Connection.new(HOST, USER, PASS, "information_schema", :DRIZZLE_CON_MYSQL)
+    schemas, tables = Set.new, Set.new
+    columns = []
+    fd = c.async_query("SELECT table_schema,table_name FROM tables") do |result|
+      result.columns.each {|col| columns << col}
+      result.each do |row|
+        schemas << row[0]
+        tables << row[1]
+      end
+    end
+
+    schemas.should.be.empty
+    tables.should.be.empty
+    columns.should.be.empty
+
+    c.async_result
+
+    schemas.should.include "information_schema"
+    tables.should.include "COLUMNS"
+    columns.size.should.equal 2
+    columns.should.include :table_schema
+    columns.should.include :table_name
+  end
+
+  if defined?(EventMachine)
+    it "perform an async query with evented receive using EventMachine" do
+      schemas, tables = Set.new, Set.new
+      columns = []
+      EM.run {
+        c = Drizzle::Connection.new(HOST, USER, PASS, "information_schema", :DRIZZLE_CON_MYSQL)
+        c.em_query("SELECT table_schema,table_name FROM tables") do |result|
+          result.columns.each {|col| columns << col}
+          result.each do |row|
+            schemas << row[0]
+            tables << row[1]
+          end
+          EM.stop
+        end
+      }
+      schemas.should.include "information_schema"
+      tables.should.include "COLUMNS"
+      columns.size.should.equal 2
+      columns.should.include :table_schema
+      columns.should.include :table_name
+    end
+  end
+
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: yakischloba-drizzle-ffi
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Jake Douglas
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-07 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ffi
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: bacon
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: libdrizzle ffi
+email: jakecdouglas@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- drizzle.gemspec
+- README.rdoc
+- Rakefile
+- lib/drizzle.rb
+- lib/drizzle/drizzle.rb
+- tests/basic.rb
+has_rdoc: false
+homepage: http://www.github.com/yakischloba/libdrizzle-ruby-ffi
+licenses: 
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: libdrizzle ffi
+test_files: []
+