downpour 0.0.5 → 0.0.6

data/README.rdoc

@@ -2,8 +2,9 @@
 
 Downpour is a gem to connect and query a Drizzle or MySql database using the libdrizzle library.
 
-== Test setup
-Run the following:
-$ echo "create database test;" | drizzle
-$ drizzle test < spec/bootstrap.sql
-$ rake
+== TODO
+* Do not maintain a list of pending queries and connections in ruby. Mark and sweep. Is this a good idea
+* Actually honor some options passed in to drizzle_con_create
+* Get column info and do stuff
+* Create a rails plugin
+* Result, Column does not have a context. Memory Leak?

data/ext/downpour/connection.c

@@ -1,24 +1,20 @@
 #include "downpour.h"
 
 #define SELF_TYPE drizzle_con_st
+#define RUBY_CLASS DrizzleConnection
+
 #define attr(foo, conversion) static VALUE attr_##foo(VALUE self)\
 {\
   read_self_ptr();\
   return conversion(drizzle_con_##foo(self_ptr));\
 }
-#define settr(foo) static VALUE settr_##foo(VALUE self, VALUE newValue)\
+#define settr_string(foo) static VALUE settr_##foo(VALUE self, VALUE newValue)\
 {\
   read_self_ptr();\
   Check_Type(newValue, T_STRING);\
   drizzle_con_set_##foo(self_ptr, RSTRING_PTR(newValue));\
   return newValue;\
 }
-#define attr_string(foo) attr(foo, rb_str_new2)
-#define prop(foo) attr_string(foo) settr(foo)
-
-#define define_attr(foo) rb_define_method(DrizzleConnection, #foo, attr_##foo, 0)
-#define define_settr(foo) rb_define_method(DrizzleConnection, #foo "=", settr_##foo, 1)
-#define define_prop(foo) define_attr(foo); define_settr(foo)
 
 static VALUE query(VALUE self, VALUE query)
 {
@@ -41,16 +37,17 @@ static VALUE connection_close(VALUE self)
   return Qnil;
 }
 
+attr(options, INT2NUM);
 attr_string(error);
 attr(errno, INT2NUM);
 attr(error_code, UINT2NUM);
 attr_string(sqlstate);
 attr_string(host);
 attr(port, UINT2NUM);
-prop(uds);
+prop_string(uds);
 attr_string(user);
 attr_string(password);
-prop(db);
+prop_string(db);
 attr(protocol_version, UINT2NUM);
 attr_string(server_version);
 attr(server_version_number, UINT2NUM);
@@ -66,6 +63,7 @@ void init_drizzle_connection()
 {
   DrizzleConnection = drizzle_gem_create_class_with_private_constructor("Connection", rb_cObject);
   rb_define_method(DrizzleConnection, "query", query, 1);
+  define_attr(options);
   define_attr(error);
   define_attr(errno);
   define_attr(error_code);

data/ext/downpour/downpour.h

@@ -17,6 +17,7 @@ typedef void (*SET_CONTEXT)(void* ptr, void *context);
 void *downpour_from_ruby_object(VALUE value);
 VALUE downpour_to_ruby_object(void *ptr, VALUE klass, VALUE parent, FREE_METHOD free_method, SET_CONTEXT set_context);
 VALUE downpour_get_ruby_object(void *ptr);
+VALUE downpour_get_parent(VALUE self);
 
 // All Constructors
 VALUE downpour_constructor(drizzle_st *self_ptr);
@@ -37,4 +38,13 @@ const char *drizzle_gem_read_string_with_default(VALUE string, const char *defau
 #define drizzle_alloc(type) ((type *) malloc(sizeof(type)))
 #define to_ruby_object(ptr, klass, parent, free_method, set_context) downpour_to_ruby_object(ptr, klass, parent, (FREE_METHOD) (free_method), (SET_CONTEXT) (set_context))
 
+// Property Macros -> define attr(foo, conversion) and settr_string to use them
+#define attr_string(foo) attr(foo, rb_str_new2)
+#define prop_string(foo) attr_string(foo) settr_string(foo)
+#define prop_int(foo, conversion) attr(foo, conversion) settr_int(foo)
+
+#define define_attr(foo) rb_define_method(RUBY_CLASS, #foo, attr_##foo, 0)
+#define define_settr(foo) rb_define_method(RUBY_CLASS, #foo "=", settr_##foo, 1)
+#define define_prop(foo) define_attr(foo); define_settr(foo)
+
 #endif

data/ext/downpour/memory_allocation.c

@@ -91,3 +91,13 @@ VALUE downpour_to_ruby_object(void *ptr, VALUE klass, VALUE parent, FREE_METHOD
 
   return wrapper->rb_object = Data_Wrap_Struct(klass, mark_for_ruby_gc, downpour_release, wrapper);
 }
+
+VALUE downpour_get_parent(VALUE self)
+{
+  DownpourWrapper *wrapper = get_wrapper_from_object(self);
+
+  if(wrapper == NULL || wrapper->parent == NULL)
+    return Qnil;
+
+  return wrapper->parent->rb_object;
+}

data/ext/downpour/query.c

@@ -11,7 +11,8 @@ static VALUE get_result(VALUE self)
     return cached_result;
 
   drizzle_result_st *result = drizzle_query_result(self_ptr);
-  VALUE ret = rb_iv_set(self, "@result", downpour_result_constructor(result, rb_iv_get(self, "@connection")));
+  VALUE connection = downpour_get_parent(self);
+  VALUE ret = rb_iv_set(self, "@result", downpour_result_constructor(result, connection));
   return ret;
 }
 

data/ext/downpour/result.c

@@ -1,6 +1,13 @@
 #include "downpour.h"
 
 #define SELF_TYPE drizzle_result_st
+#define RUBY_CLASS DrizzleResult
+
+#define attr(foo, conversion) static VALUE attr_##foo(VALUE self)\
+{\
+  read_self_ptr();\
+  return conversion(drizzle_result_##foo(self_ptr));\
+}
 
 static uint64_t do_column_count(drizzle_result_st *self_ptr)
 {
@@ -87,24 +94,14 @@ static VALUE next_row(VALUE self)
   return next_row_unbuffered(self_ptr);
 }
 
-static VALUE column_count(VALUE self)
-{
-  read_self_ptr();
-  return UINT2NUM(do_column_count(self_ptr));
-}
-
-static VALUE insert_id(VALUE self)
-{
-  read_self_ptr();
-
-  return UINT2NUM(drizzle_result_insert_id(self_ptr));
-}
-
-static VALUE error_code(VALUE self)
-{
-  read_self_ptr();
-  return UINT2NUM(drizzle_result_error_code(self_ptr));
-}
+attr(column_count, UINT2NUM);
+attr(insert_id, UINT2NUM);
+attr(error_code, UINT2NUM);
+attr(affected_rows, UINT2NUM);
+attr(warning_count, UINT2NUM);
+attr_string(sqlstate);
+attr_string(info);
+attr_string(error);
 
 VALUE downpour_result_constructor(drizzle_result_st *self_ptr, VALUE connection)
 {
@@ -115,10 +112,15 @@ void init_drizzle_result()
 {
   DrizzleResult = drizzle_gem_create_class_with_private_constructor("Result", rb_cObject);
   rb_define_method(DrizzleResult, "row_count", row_count, 0);
-  rb_define_method(DrizzleResult, "column_count", column_count, 0);
   rb_define_method(DrizzleResult, "buffer!", buffer_if_needed, 0);
   rb_define_method(DrizzleResult, "buffered?", is_buffered, 0);
   rb_define_method(DrizzleResult, "next_row", next_row, 0);
-  rb_define_method(DrizzleResult, "insert_id", insert_id, 0);
-  rb_define_method(DrizzleResult, "error_code", error_code, 0);
+  define_attr(column_count);
+  define_attr(insert_id);
+  define_attr(error_code);
+  define_attr(affected_rows);
+  define_attr(warning_count);
+  define_attr(sqlstate);
+  define_attr(info);
+  define_attr(error);
 }

data/ext/downpour/status.c

@@ -1,16 +1,30 @@
 #include "downpour.h"
 
 #define SELF_TYPE drizzle_st
+#define RUBY_CLASS DrizzleStatus
 
-static in_port_t get_port(VALUE port)
+#define attr(foo, conversion) static VALUE attr_##foo(VALUE self)\
+{\
+  read_self_ptr();\
+  return conversion(drizzle_##foo(self_ptr));\
+}
+
+#define settr_int(foo) static VALUE settr_##foo(VALUE self, VALUE newValue)\
+{\
+  read_self_ptr();\
+  drizzle_set_##foo(self_ptr, NUM2INT(newValue));\
+  return newValue;\
+}
+
+static in_port_t get_port(VALUE port, in_port_t default_port)
 {
   if(port == Qnil)
-    return DRIZZLE_DEFAULT_TCP_PORT;
+    return default_port;
   Check_Type(port, T_FIXNUM);
   return NUM2UINT(port);
 }
 
-static VALUE add_tcp_connection(int argc, VALUE *argv, VALUE self)
+static VALUE add_tcp_connection_with_defaults(int argc, VALUE *argv, VALUE self, in_port_t default_port, drizzle_con_options_t default_options)
 {
   read_self_ptr();
 
@@ -21,43 +35,22 @@ static VALUE add_tcp_connection(int argc, VALUE *argv, VALUE self)
 
   drizzle_con_st *connection = drizzle_con_add_tcp(self_ptr, NULL, 
                                                     read_string(host, "localhost"), 
-                                                    get_port(port),
+                                                    get_port(port, default_port),
                                                     read_string(user, ""),
                                                     read_string(passwd, ""),
                                                     read_string(db, "test"),
-                                                    DRIZZLE_CON_NONE);
+                                                    default_options);
   return downpour_connection_constructor(connection, self);
 }
 
-static VALUE error(VALUE self)
-{
-  read_self_ptr();
-
-  return rb_str_new2(drizzle_error(self_ptr));
-}
-
-static VALUE set_verbose(VALUE self, VALUE newVerbocity)
-{
-  read_self_ptr();
-
-  int verbocity = NUM2INT(newVerbocity);
-  drizzle_set_verbose(self_ptr, verbocity);
-
-  return newVerbocity;
-}
-
-static VALUE get_verbose(VALUE self)
+static VALUE add_tcp_connection(int argc, VALUE *argv, VALUE self)
 {
-  read_self_ptr();
-
-  return UINT2NUM(drizzle_verbose(self_ptr));
+  return add_tcp_connection_with_defaults(argc, argv, self, DRIZZLE_DEFAULT_TCP_PORT, DRIZZLE_CON_NONE);
 }
 
-static VALUE verbose_name(VALUE self)
+static VALUE add_mysql_tcp_connection(int argc, VALUE *argv, VALUE self)
 {
-  read_self_ptr();
-
-  return rb_str_new2(drizzle_verbose_name(drizzle_verbose(self_ptr)));
+  return add_tcp_connection_with_defaults(argc, argv, self, 3306, DRIZZLE_CON_MYSQL);
 }
 
 static VALUE add_query(VALUE self, VALUE connection, VALUE query)
@@ -92,6 +85,21 @@ static VALUE run_one(VALUE self)
   return downpour_get_ruby_object(drizzle_query_context(query));
 }
 
+static VALUE verbose_name(VALUE self)
+{
+  read_self_ptr();
+
+  return rb_str_new2(drizzle_verbose_name(drizzle_verbose(self_ptr)));
+}
+
+attr_string(error);
+attr(errno, INT2NUM);
+attr(error_code, INT2NUM);
+attr_string(sqlstate);
+attr(options, UINT2NUM);
+prop_int(timeout, INT2NUM);
+prop_int(verbose, UINT2NUM);
+
 VALUE downpour_constructor(drizzle_st *self_ptr)
 {
   return to_ruby_object(self_ptr, DrizzleStatus, Qnil, drizzle_free, drizzle_set_context);
@@ -101,11 +109,16 @@ void init_drizzle_status()
 {
   DrizzleStatus = drizzle_gem_create_class_with_private_constructor("Status", rb_cObject);
   rb_define_method(DrizzleStatus, "add_tcp_connection", add_tcp_connection, -1);
-  rb_define_method(DrizzleStatus, "error", error, 0);
-  rb_define_method(DrizzleStatus, "verbose=", set_verbose, 1);
-  rb_define_method(DrizzleStatus, "verbose", get_verbose, 0);
+  rb_define_method(DrizzleStatus, "add_mysql_tcp_connection", add_mysql_tcp_connection, -1);
   rb_define_method(DrizzleStatus, "verbose_name", verbose_name, 0);
-  rb_define_method(DrizzleStatus, "add_query", add_query, 2);
-  rb_define_method(DrizzleStatus, "run_all!", run_all, 0);
-  rb_define_method(DrizzleStatus, "run!", run_one, 0);
+  rb_define_private_method(DrizzleStatus, "_add_query", add_query, 2);
+  rb_define_private_method(DrizzleStatus, "_run_all!", run_all, 0);
+  rb_define_private_method(DrizzleStatus, "_run!", run_one, 0);
+  define_attr(error);
+  define_attr(errno);
+  define_attr(error_code);
+  define_attr(sqlstate);
+  define_attr(options);
+  define_prop(timeout);
+  define_prop(verbose);
 }

data/lib/downpour.rb

@@ -1,2 +1,3 @@
 require 'downpour/downpour'
+require 'downpour/status'
 require 'downpour/version'

data/lib/downpour/status.rb

@@ -0,0 +1,25 @@
+module Downpour
+  class Status
+    def add_query(connection, query)
+      new_query = _add_query(connection, query)
+      pending_queries << new_query
+      new_query
+    end
+
+    def run!
+      pending_queries.delete(_run!)
+    end
+
+    def run_all!
+      _run_all!
+      pending_queries.clear
+    end
+
+    def pending_queries
+      if(@pending_queries == nil)
+        @pending_queries = []
+      end
+      @pending_queries
+    end
+  end
+end

data/lib/downpour/version.rb

@@ -1,3 +1,3 @@
 module Downpour
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/spec/downpour/concurrent_spec.rb

@@ -8,24 +8,45 @@ describe "a concurrent query" do
     @query2 = @status.add_query(@conn2, "select name from Test1 where name like '%ar'");
   end
 
-  it "should buffer all queries" do
-    @status.run_all!
-    @query1.result.should be_buffered
-    @query2.result.should be_buffered
-  end
+  context "when running all" do
+    it "should buffer all queries" do
+      @status.run_all!
+      @query1.result.should be_buffered
+      @query2.result.should be_buffered
+    end
+
+    it "should run all queries" do
+      @status.run_all!
+      @query1.result.next_row.should == ["foo"]
+      @query2.result.next_row.should == ["bar"]
+    end
 
-  it "should run all queries" do
-    @status.run_all!
-    @query1.result.next_row.should == ["foo"]
-    @query2.result.next_row.should == ["bar"]
+    it "should clear all pending queries" do
+      @status.pending_queries.size.should == 2
+      @status.run_all!
+      @status.pending_queries.should be_empty
+    end
   end
 
-  it "should run a query" do
-    rows = []
-    rows << @status.run!.result.next_row
-    rows << @status.run!.result.next_row
-    rows.should include(["foo"])
-    rows.should include(["bar"])
-    @status.run!.should be_nil
+  context "when executing one at a time" do
+    it "should run all queries" do
+      rows = []
+      rows << @status.run!.result.next_row
+      rows << @status.run!.result.next_row
+      rows.should include(["foo"])
+      rows.should include(["bar"])
+    end
+
+    it "should return nil after all queries are executed" do
+      @status.run!
+      @status.run!
+      @status.run!.should be_nil
+    end
+
+    it "should release pending queries" do
+      query = @status.run!
+      @status.pending_queries.should_not include(query)
+      @status.pending_queries.size.should == 1
+    end
   end
 end

data/spec/downpour/connect_type_spec.rb

@@ -1,4 +1,4 @@
-describe "Downpour connections" do
+describe "downpour connections" do
 
   before(:each) do
     @status = Downpour.create
@@ -26,10 +26,33 @@ describe "Downpour connections" do
   end
 
   context "over drizzle tcp protocol" do
-    before(:each) do
-      @connection = @status.add_tcp_connection('localhost', @user, @password, @database)
+    it "should have default port set" do
+      connection = @status.add_tcp_connection('localhost', @user, @password, @database)
+      connection.port.should == 4427
     end
 
-    it_should_behave_like "a working downpour connection"
+    context "connection sanity" do
+      before(:each) do
+        @connection = @status.add_tcp_connection('localhost', @user, @password, @database)
+      end
+
+      it_should_behave_like "a working downpour connection"
+    end
+  end
+
+  context "over mysql tcp protocol" do
+    it "should have default port set" do
+      connection = @status.add_mysql_tcp_connection('localhost', @user, @password, @database)
+      connection.port.should == 3306
+    end
+
+    context "connection sanity" do
+      before(:each) do
+        # connect to drizzle over a mysql db
+        @connection = @status.add_mysql_tcp_connection('localhost', @user, @password, @database, 4427)
+      end
+
+      it_should_behave_like "a working downpour connection"
+    end
   end
 end

data/spec/downpour/connection_spec.rb

@@ -1,4 +1,4 @@
-describe Downpour do
+describe "downpour connections" do
   before(:each) do
     @status = Downpour.create
     @connection = create_connection(@status)

data/spec/downpour/insert_spec.rb

@@ -16,4 +16,8 @@ describe "an insert query" do
   it "should get id after inserting" do
     @conn.query("insert into Test2 (name) values ('foo')").insert_id.should == count_of_test2
   end
+
+  it "should get count of affected rows" do
+    @conn.query("insert into Test2 (name) values ('foo')").affected_rows.should == 1
+  end
 end

data/spec/downpour/memory_mgmt_spec.rb

@@ -0,0 +1,14 @@
+describe Downpour do
+
+  before(:each) do
+    @status = Downpour.create
+    @conn = create_connection(@status)
+    @query = @status.add_query(@conn, "select * from Test1 where name like '%oo'");
+  end
+
+  it "should not allow query to gc before running" do
+    @query = nil
+    GC.start
+    @status.run!.result.next_row.should include("foo")
+  end
+end

data/spec/spec_helper.rb

@@ -1,4 +1,4 @@
-require './lib/downpour/downpour'
+require './lib/downpour'
 
 def create_connection(status)
   status.add_tcp_connection "localhost", ENV["USER"], "", "test"

metadata

@@ -1,49 +1,48 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: downpour
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.0.6
   prerelease: 
-  version: 0.0.5
 platform: ruby
-authors: 
+authors:
 - Tejas Dinkar
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-06-02 00:00:00 +05:30
+date: 2011-06-03 00:00:00.000000000 +00:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rake-compiler
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &18332580 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
+      - !ruby/object:Gem::Version
         version: 0.7.1
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *18332580
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &18330100 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id002
-description: A simple, fast Mysql and Drizzle library for Ruby, binding to libdrizzle. Still in early alpha
+  prerelease: false
+  version_requirements: *18330100
+description: A simple, fast Mysql and Drizzle library for Ruby, binding to libdrizzle.
+  Still in early alpha
 email: tejas@gja.in
 executables: []
-
-extensions: 
+extensions:
 - ext/downpour/extconf.rb
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.rdoc
-files: 
+files:
 - downpour.gemspec
 - ext/downpour/connection.c
 - ext/downpour/downpour.c
@@ -56,12 +55,14 @@ files:
 - ext/downpour/result.c
 - ext/downpour/status.c
 - lib/downpour.rb
+- lib/downpour/status.rb
 - lib/downpour/version.rb
 - spec/bootstrap.sql
 - spec/downpour/concurrent_spec.rb
 - spec/downpour/connect_type_spec.rb
 - spec/downpour/connection_spec.rb
 - spec/downpour/insert_spec.rb
+- spec/downpour/memory_mgmt_spec.rb
 - spec/downpour/module_spec.rb
 - spec/downpour/select_spec.rb
 - spec/spec_helper.rb
@@ -69,38 +70,37 @@ files:
 has_rdoc: true
 homepage: http://github.com/gja/downpour
 licenses: []
-
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --charset=UTF-8
-require_paths: 
+require_paths:
 - lib
 - ext
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
 rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: A simple, fast Mysql and Drizzle library for Ruby, binding to libdrizzle
-test_files: 
+test_files:
 - spec/bootstrap.sql
 - spec/downpour/concurrent_spec.rb
 - spec/downpour/connect_type_spec.rb
 - spec/downpour/connection_spec.rb
 - spec/downpour/insert_spec.rb
+- spec/downpour/memory_mgmt_spec.rb
 - spec/downpour/module_spec.rb
 - spec/downpour/select_spec.rb
 - spec/spec_helper.rb