downpour 0.0.2 → 0.0.5

data/ext/downpour/connection.c

@@ -1,6 +1,24 @@
 #include "downpour.h"
 
 #define SELF_TYPE drizzle_con_st
+#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)\
+{\
+  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)
 {
@@ -16,15 +34,52 @@ static VALUE query(VALUE self, VALUE query)
   return downpour_result_constructor(result, self);
 }
 
+static VALUE connection_close(VALUE self)
+{
+  read_self_ptr();
+  drizzle_con_close(self_ptr);
+  return Qnil;
+}
+
+attr_string(error);
+attr(errno, INT2NUM);
+attr(error_code, UINT2NUM);
+attr_string(sqlstate);
+attr_string(host);
+attr(port, UINT2NUM);
+prop(uds);
+attr_string(user);
+attr_string(password);
+prop(db);
+attr(protocol_version, UINT2NUM);
+attr_string(server_version);
+attr(server_version_number, UINT2NUM);
+attr(thread_id, UINT2NUM);
+attr(max_packet_size, UINT2NUM);
+
 VALUE downpour_connection_constructor(drizzle_con_st *self_ptr, VALUE status)
 {
-  VALUE ret = Data_Wrap_Struct(DrizzleConnection, NULL, drizzle_con_free, self_ptr);
-  rb_iv_set(ret, "@status", status);
-  return ret;
+  return to_ruby_object(self_ptr, DrizzleConnection, status, drizzle_con_free, drizzle_con_set_context);
 }
 
 void init_drizzle_connection()
 {
   DrizzleConnection = drizzle_gem_create_class_with_private_constructor("Connection", rb_cObject);
   rb_define_method(DrizzleConnection, "query", query, 1);
+  define_attr(error);
+  define_attr(errno);
+  define_attr(error_code);
+  define_attr(sqlstate);
+  define_attr(host);
+  define_attr(port);
+  define_prop(uds);
+  define_attr(user);
+  define_attr(password);
+  define_prop(db);
+  define_attr(protocol_version);
+  define_attr(server_version);
+  define_attr(server_version_number);
+  define_attr(thread_id);
+  define_attr(max_packet_size);
+  rb_define_method(DrizzleConnection, "close!", connection_close, 0);
 }

data/ext/downpour/downpour.c

@@ -4,11 +4,13 @@ VALUE DownpourModule;
 VALUE DrizzleStatus;
 VALUE DrizzleConnection;
 VALUE DrizzleResult;
+VALUE DrizzleQuery;
 
 void init_downpour_module();
 void init_drizzle_status();
 void init_drizzle_connection();
 void init_drizzle_result();
+void init_drizzle_query();
 
 void Init_downpour()
 {
@@ -16,4 +18,5 @@ void Init_downpour()
   init_drizzle_status();
   init_drizzle_connection();
   init_drizzle_result();
+  init_drizzle_query();
 }

data/ext/downpour/downpour.h

@@ -9,23 +9,32 @@ extern VALUE DownpourModule;
 extern VALUE DrizzleStatus;
 extern VALUE DrizzleConnection;
 extern VALUE DrizzleResult;
+extern VALUE DrizzleQuery;
+
+// All mark and release methods
+typedef void (*FREE_METHOD)(void* ptr);
+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);
 
 // All Constructors
 VALUE downpour_constructor(drizzle_st *self_ptr);
 VALUE downpour_connection_constructor(drizzle_con_st *self_ptr, VALUE status);
 VALUE downpour_result_constructor(drizzle_result_st *self_ptr, VALUE connection);
+VALUE downpour_query_constructor(drizzle_query_st *self_ptr, VALUE connection);
 
 VALUE drizzle_gem_create_class_with_private_constructor(const char *name, VALUE super);
 void drizzle_gem_assert_value_is_ok(drizzle_return_t value);
 VALUE drizzle_gem_to_string_array(char **array, long count);
 const char *drizzle_gem_read_string_with_default(VALUE string, const char *default_value);
 
-#define convert_to_struct(datatype, var_name, value) datatype *var_name; Data_Get_Struct(value, datatype, var_name)
+#define convert_to_struct(datatype, var_name, value) datatype *var_name; var_name = downpour_from_ruby_object(value)
 #define read_self_ptr() convert_to_struct(SELF_TYPE, self_ptr, self)
 #define CHECK_OK(value) drizzle_gem_assert_value_is_ok(value)
 #define rb_call(self, string) rb_funcall(self, rb_intern(string), 0)
 #define read_string(value, default_value) drizzle_gem_read_string_with_default(value, default_value)
 #define drizzle_alloc(type) ((type *) malloc(sizeof(type)))
-#define unset_option(value, bit) if(value->options & bit) value->options ^= bit
+#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))
 
 #endif

data/ext/downpour/memory_allocation.c

@@ -0,0 +1,93 @@
+#include "downpour.h"
+
+typedef struct DownpourWrapper {
+  int reference_count;
+  void *ptr;
+  struct DownpourWrapper *parent;
+  FREE_METHOD free_method;
+  VALUE rb_object;
+} DownpourWrapper;
+
+static void downpour_mark(DownpourWrapper *wrapper)
+{
+  if(wrapper == NULL)
+    return;
+
+  wrapper->reference_count++;
+}
+
+static void downpour_release(DownpourWrapper *wrapper)
+{
+  if(wrapper == NULL)
+    return;
+
+  wrapper->reference_count--;
+
+  if(wrapper->reference_count == 0) {
+    wrapper->free_method(wrapper->ptr);
+    downpour_release(wrapper->parent);
+    free(wrapper);
+  }
+}
+
+static DownpourWrapper *downpour_wrap_pointer(void *ptr, DownpourWrapper *parent, FREE_METHOD free_method)
+{
+  DownpourWrapper *wrapper = drizzle_alloc(DownpourWrapper);
+  wrapper->ptr = ptr;
+  wrapper->parent = parent;
+  wrapper->free_method = free_method;
+  wrapper->reference_count = 0;
+
+  downpour_mark(parent);
+  downpour_mark(wrapper);
+  return wrapper;
+}
+
+static void mark_for_ruby_gc(DownpourWrapper *wrapper)
+{
+  if(wrapper == NULL)
+    return;
+
+  rb_gc_mark(wrapper->rb_object);
+
+  mark_for_ruby_gc(wrapper->parent);
+}
+
+static DownpourWrapper *get_wrapper_from_object(VALUE value)
+{
+  if(value == Qnil)
+    return NULL;
+
+  DownpourWrapper *wrapper = NULL;
+  Data_Get_Struct(value, DownpourWrapper, wrapper);
+  return wrapper;
+}
+
+VALUE downpour_get_ruby_object(void *ptr)
+{
+  if(ptr == NULL)
+    return Qnil;
+
+  DownpourWrapper *wrapper = (DownpourWrapper *)ptr;
+  return wrapper->rb_object;
+}
+
+void *downpour_from_ruby_object(VALUE value)
+{
+  DownpourWrapper *wrapper;
+  wrapper = get_wrapper_from_object(value);
+  return wrapper == NULL? NULL : wrapper->ptr;
+}
+
+VALUE downpour_to_ruby_object(void *ptr, VALUE klass, VALUE parent, FREE_METHOD free_method, SET_CONTEXT set_context)
+{
+  if(ptr == NULL)
+    return Qnil;
+
+  DownpourWrapper *wrapper = downpour_wrap_pointer(ptr, get_wrapper_from_object(parent), free_method);
+
+  if(set_context != NULL)
+    set_context(ptr, wrapper);
+
+  return wrapper->rb_object = Data_Wrap_Struct(klass, mark_for_ruby_gc, downpour_release, wrapper);
+}

data/ext/downpour/module.c

@@ -8,7 +8,7 @@ static VALUE version(VALUE self)
 static VALUE create(VALUE self)
 {
   drizzle_st *ptr = drizzle_create(NULL);
-  unset_option(ptr, DRIZZLE_FREE_OBJECTS);
+  drizzle_remove_options(ptr, DRIZZLE_FREE_OBJECTS);
   return downpour_constructor(ptr);
 }
 

data/ext/downpour/query.c

@@ -0,0 +1,27 @@
+#include "downpour.h"
+
+#define SELF_TYPE drizzle_query_st
+
+static VALUE get_result(VALUE self)
+{
+  read_self_ptr();
+
+  VALUE cached_result = rb_iv_get(self, "@result");
+  if(cached_result != Qnil)
+    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")));
+  return ret;
+}
+
+VALUE downpour_query_constructor(drizzle_query_st *self_ptr, VALUE connection)
+{
+  return to_ruby_object(self_ptr, DrizzleQuery, connection, drizzle_query_free, drizzle_query_set_context);
+}
+
+void init_drizzle_query()
+{
+  DrizzleQuery = drizzle_gem_create_class_with_private_constructor("Query", rb_cObject);
+  rb_define_method(DrizzleQuery, "result", get_result, 0);
+}

data/ext/downpour/result.c

@@ -7,19 +7,15 @@ static uint64_t do_column_count(drizzle_result_st *self_ptr)
   return drizzle_result_column_count(self_ptr);
 }
 
-static VALUE is_buffered(VALUE self)
+static bool is_buffered_bool(VALUE self)
 {
-  VALUE buffered = rb_iv_get(self, "@buffered");
-
-  if(buffered == Qnil || buffered == Qfalse)
-    return Qfalse;
-
-  return buffered;
+  read_self_ptr();
+  return self_ptr->options & (DRIZZLE_RESULT_BUFFER_ROW);
 }
 
-static bool is_buffered_bool(VALUE self)
+static VALUE is_buffered(VALUE self)
 {
-  return RTEST(rb_call(self, "buffered?"));
+  return is_buffered_bool(self) ? Qtrue : Qfalse;
 }
 
 static VALUE buffer_if_needed(VALUE self)
@@ -31,7 +27,6 @@ static VALUE buffer_if_needed(VALUE self)
     return Qfalse;
 
   CHECK_OK(drizzle_result_buffer(self_ptr));
-  rb_iv_set(self, "@buffered", Qtrue);
   return Qtrue;
 }
 
@@ -105,11 +100,15 @@ static VALUE insert_id(VALUE self)
   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));
+}
+
 VALUE downpour_result_constructor(drizzle_result_st *self_ptr, VALUE connection)
 {
-  VALUE ret = Data_Wrap_Struct(DrizzleResult, NULL, drizzle_result_free, self_ptr);
-  rb_iv_set(ret, "@connection", connection);
-  return ret;
+  return to_ruby_object(self_ptr, DrizzleResult, connection, drizzle_result_free, NULL);
 }
 
 void init_drizzle_result()
@@ -121,4 +120,5 @@ void init_drizzle_result()
   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);
 }

data/ext/downpour/status.c

@@ -60,9 +60,41 @@ static VALUE verbose_name(VALUE self)
   return rb_str_new2(drizzle_verbose_name(drizzle_verbose(self_ptr)));
 }
 
+static VALUE add_query(VALUE self, VALUE connection, VALUE query)
+{
+  read_self_ptr();
+  convert_to_struct(drizzle_con_st, connection_ptr, connection);
+  Check_Type(query, T_STRING);
+
+  drizzle_query_st *query_ptr = drizzle_query_add(self_ptr, NULL, connection_ptr, NULL, 
+                                                    RSTRING_PTR(query), RSTRING_LEN(query), 0, NULL);
+
+  return downpour_query_constructor(query_ptr, connection);
+}
+
+static VALUE run_all(VALUE self)
+{
+  read_self_ptr();
+  CHECK_OK(drizzle_query_run_all(self_ptr));
+  return Qnil;
+}
+
+static VALUE run_one(VALUE self)
+{
+  read_self_ptr();
+  drizzle_return_t ret;
+  drizzle_query_st *query = drizzle_query_run(self_ptr, &ret);
+  CHECK_OK(ret);
+
+  if(query == NULL)
+    return Qnil;
+
+  return downpour_get_ruby_object(drizzle_query_context(query));
+}
+
 VALUE downpour_constructor(drizzle_st *self_ptr)
 {
-  return Data_Wrap_Struct(DrizzleStatus, NULL, drizzle_free, self_ptr);
+  return to_ruby_object(self_ptr, DrizzleStatus, Qnil, drizzle_free, drizzle_set_context);
 }
 
 void init_drizzle_status()
@@ -73,4 +105,7 @@ void init_drizzle_status()
   rb_define_method(DrizzleStatus, "verbose=", set_verbose, 1);
   rb_define_method(DrizzleStatus, "verbose", get_verbose, 0);
   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);
 }

data/lib/downpour/version.rb

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

data/spec/downpour/concurrent_spec.rb

@@ -0,0 +1,31 @@
+describe "a concurrent query" do
+
+  before(:each) do
+    @status = Downpour.create
+    @conn = create_connection(@status)
+    @conn2 = create_connection(@status)
+    @query1 = @status.add_query(@conn, "select * from Test1 where name like '%oo'");
+    @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
+
+  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 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
+  end
+end

data/spec/downpour/connect_type_spec.rb

@@ -0,0 +1,35 @@
+describe "Downpour connections" do
+
+  before(:each) do
+    @status = Downpour.create
+    @user = ENV["USER"]
+    @password = ""
+    @database = "test"
+  end
+
+  shared_examples_for "a working downpour connection" do
+    it "should count records" do
+      results = @connection.query "select * from Test1"
+      results.row_count.should == 3
+    end
+
+    it "should read a row" do
+      results = @connection.query "select * from Test1"
+      results.next_row.should == ["foo"]
+    end
+
+    it "should be used concurrently" do
+      query = @status.add_query(@connection, "select * from Test1")
+      @status.run_all!
+      query.result.next_row.should == ["foo"]
+    end
+  end
+
+  context "over drizzle tcp protocol" do
+    before(:each) do
+      @connection = @status.add_tcp_connection('localhost', @user, @password, @database)
+    end
+
+    it_should_behave_like "a working downpour connection"
+  end
+end

data/spec/downpour/connection_spec.rb

@@ -0,0 +1,41 @@
+describe Downpour do
+  before(:each) do
+    @status = Downpour.create
+    @connection = create_connection(@status)
+  end
+
+  context "error handling" do
+
+    it "should catch errors" do
+      begin
+        query = @connection.query "this is invalid sql"
+        raise "should have failed here"
+      rescue IOError
+        @status.error.should == "You have an error in your SQL syntax; check the manual that corresponds to your Drizzle server version for the right syntax to use near 'this is invalid sql' at line 1"
+      end
+    end
+
+    it "should only accept a string as query" do
+      lambda {@connection.query 42}.should raise_error(TypeError)
+    end
+  end
+  
+  context "simple attributes" do
+    it "should change the database" do
+      @connection.db.should == "test"
+      @connection.db = "blah"
+      @connection.db.should == "blah"
+    end
+
+    it "should read simple attributes" do
+      @connection.port.should == 4427
+      @connection.user.should == ENV["USER"]
+      @connection.password.should == ""
+    end
+  end
+
+  it "should close the connection" do
+    @connection.close!
+    # TODO: Find a way to assert on this
+  end
+end

data/spec/downpour/insert_spec.rb

@@ -1,4 +1,4 @@
-describe "insert query" do
+describe "an insert query" do
 
   def count_of_test2
     @conn.query("select * from Test2").row_count

data/spec/downpour/select_spec.rb

@@ -1,4 +1,4 @@
-describe "select query" do
+describe "a select query" do
 
   before(:each) do
     @status = Downpour.create
@@ -22,15 +22,6 @@ describe "select query" do
     @results.buffer!.should be_false
   end
 
-  it "should count columns" do
-    @results.column_count.should == 1
-  end
-
-  it "should not buffer when reading a single row" do
-    @results.next_row
-    @results.should_not be_buffered
-  end
-
   shared_examples_for "a read query" do
     it "should read all rows" do
       @results.next_row.should == ["foo"]
@@ -38,10 +29,16 @@ describe "select query" do
       @results.next_row.should == ["baz"]
       @results.next_row.should be_nil
     end
+
+    it "should count columns" do
+      @results.column_count.should == 1
+    end
   end
 
   context "without buffering" do
     it_should_behave_like "a read query"
+
+    after(:each) {@results.should_not be_buffered}
   end
 
   context "with buffering" do

metadata

@@ -2,7 +2,7 @@
 name: downpour
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.2
+  version: 0.0.5
 platform: ruby
 authors: 
 - Tejas Dinkar
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-30 00:00:00 +05:30
+date: 2011-06-02 00:00:00 +05:30
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -50,15 +50,19 @@ files:
 - ext/downpour/downpour.h
 - ext/downpour/extconf.rb
 - ext/downpour/helpers.c
+- ext/downpour/memory_allocation.c
 - ext/downpour/module.c
+- ext/downpour/query.c
 - ext/downpour/result.c
 - ext/downpour/status.c
 - lib/downpour.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/module_spec.rb
-- spec/downpour/query_spec.rb
 - spec/downpour/select_spec.rb
 - spec/spec_helper.rb
 - README.rdoc
@@ -93,8 +97,10 @@ specification_version: 3
 summary: A simple, fast Mysql and Drizzle library for Ruby, binding to libdrizzle
 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/module_spec.rb
-- spec/downpour/query_spec.rb
 - spec/downpour/select_spec.rb
 - spec/spec_helper.rb

data/spec/downpour/query_spec.rb

@@ -1,27 +0,0 @@
-describe Downpour do
-  before(:each) do
-    @status = Downpour.create
-    @connection = create_connection(@status)
-  end
-
-  context "error handling" do
-
-    it "should be able to catch errors" do
-      begin
-        query = @connection.query "this is invalid sql"
-        raise "should have failed here"
-      rescue IOError
-        @status.error.should == "You have an error in your SQL syntax; check the manual that corresponds to your Drizzle server version for the right syntax to use near 'this is invalid sql' at line 1"
-      end
-    end
-
-    it "should only accept a string as query" do
-      begin
-        @connection.query 42
-        raise "should have failed here"
-      rescue TypeError
-      end
-    end
-
-  end
-end