downpour 0.0.7 → 0.0.12

data/README.rdoc

@@ -5,6 +5,6 @@ Downpour is a gem to connect and query a Drizzle or MySql database using the lib
 == 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
+* Get column type and do stuff. 
 * Create a rails plugin
 * Result, Column does not have a context. Memory Leak?

data/ext/downpour/buffered_result.c

@@ -0,0 +1,45 @@
+#include "downpour.h"
+#include "result.h"
+
+#define SELF_TYPE drizzle_result_st
+#define RUBY_CLASS DrizzleBufferedResult
+
+#define attr(foo, conversion) static VALUE attr_##foo(VALUE self)\
+{\
+  read_self_ptr();\
+  return conversion(drizzle_result_##foo(self_ptr));\
+}
+
+static void buffer_if_needed(drizzle_result_st *self_ptr)
+{
+  // Only buffer once
+  if(downpour_is_buffered(self_ptr))
+    return;
+
+  CHECK_OK(drizzle_result_buffer(self_ptr));
+}
+
+static VALUE next_row(VALUE self)
+{
+  read_self_ptr();
+
+  drizzle_row_t result = drizzle_row_next(self_ptr);
+  return downpour_wrap_row(self, self_ptr, result);
+}
+
+attr(row_count, UINT2NUM);
+
+VALUE downpour_buffered_result_constructor(drizzle_result_st *self_ptr, VALUE connection)
+{
+  buffer_if_needed(self_ptr);
+  VALUE ret = to_ruby_object(self_ptr, DrizzleBufferedResult, connection, drizzle_result_free, NULL);
+  return downpour_include_result_module(self_ptr, ret);
+}
+
+void init_drizzle_buffered_result()
+{
+  DrizzleBufferedResult = drizzle_gem_create_class_with_private_constructor("BufferedResult", rb_cObject);
+  rb_include_module(DrizzleBufferedResult, DrizzleResult);
+  rb_define_method(DrizzleBufferedResult, "next_row", next_row, 0);
+  define_attr(row_count);
+}

data/ext/downpour/column.c

@@ -0,0 +1,50 @@
+#include "downpour.h"
+
+#define SELF_TYPE drizzle_column_st
+#define RUBY_CLASS DrizzleColumn
+
+#define attr(foo, conversion) static VALUE attr_##foo(VALUE self)\
+{\
+  read_self_ptr();\
+  return conversion(drizzle_column_##foo(self_ptr));\
+}
+
+attr_string(catalog);
+attr_string(db);
+attr_string(table);
+attr_string(orig_table);
+attr_string(name);
+attr_string(orig_name);
+// charset
+attr(size, UINT2NUM);
+attr(max_size, INT2NUM);
+//column type
+//column_type_drizzle
+//flags
+attr(decimals, UINT2NUM);
+//default_value
+
+VALUE downpour_column_constructor(drizzle_column_st *self_ptr, VALUE result)
+{
+  // Column object is owned by the result. Thus we let the result free it, and the free_method is null
+  return to_ruby_object(self_ptr, DrizzleColumn, result, NULL, NULL);
+}
+
+void init_drizzle_column()
+{
+  DrizzleColumn = drizzle_gem_create_class_with_private_constructor("Column", rb_cObject);
+  define_attr(catalog);
+  define_attr(db);
+  define_attr(table);
+  define_attr(orig_table);
+  define_attr(name);
+  define_attr(orig_name);
+  // charset
+  define_attr(size);
+  define_attr(max_size);
+  //column type
+  //column_type_drizzle
+  //flags
+  define_attr(decimals);
+  //default_value
+}

data/ext/downpour/connection.c

@@ -16,7 +16,7 @@
   return newValue;\
 }
 
-static VALUE query(VALUE self, VALUE query)
+static drizzle_result_st *create_query(VALUE self, VALUE query)
 {
   read_self_ptr();
 
@@ -27,7 +27,17 @@ static VALUE query(VALUE self, VALUE query)
 
   CHECK_OK(retptr);
 
-  return downpour_result_constructor(result, self);
+  return result;
+}
+
+static VALUE query(VALUE self, VALUE query)
+{
+  return downpour_buffered_result_constructor(create_query(self, query), self);
+}
+
+static VALUE unbuffered_query(VALUE self, VALUE query)
+{
+  return downpour_unbuffered_result_constructor(create_query(self, query), self);
 }
 
 static VALUE connection_close(VALUE self)
@@ -63,6 +73,7 @@ void init_drizzle_connection()
 {
   DrizzleConnection = drizzle_gem_create_class_with_private_constructor("Connection", rb_cObject);
   rb_define_method(DrizzleConnection, "query", query, 1);
+  rb_define_method(DrizzleConnection, "unbuffered_query", unbuffered_query, 1);
   define_attr(options);
   define_attr(error);
   define_attr(errno);

data/ext/downpour/downpour.c

@@ -4,13 +4,19 @@ VALUE DownpourModule;
 VALUE DrizzleStatus;
 VALUE DrizzleConnection;
 VALUE DrizzleResult;
+VALUE DrizzleBufferedResult;
+VALUE DrizzleUnBufferedResult;
 VALUE DrizzleQuery;
+VALUE DrizzleColumn;
 
 void init_downpour_module();
 void init_drizzle_status();
 void init_drizzle_connection();
 void init_drizzle_result();
+void init_drizzle_buffered_result();
+void init_drizzle_unbuffered_result();
 void init_drizzle_query();
+void init_drizzle_column();
 
 void Init_downpour()
 {
@@ -18,5 +24,8 @@ void Init_downpour()
   init_drizzle_status();
   init_drizzle_connection();
   init_drizzle_result();
+  init_drizzle_buffered_result();
+  init_drizzle_unbuffered_result();
   init_drizzle_query();
+  init_drizzle_column();
 }

data/ext/downpour/downpour.h

@@ -9,7 +9,10 @@ extern VALUE DownpourModule;
 extern VALUE DrizzleStatus;
 extern VALUE DrizzleConnection;
 extern VALUE DrizzleResult;
+extern VALUE DrizzleBufferedResult;
+extern VALUE DrizzleUnBufferedResult;
 extern VALUE DrizzleQuery;
+extern VALUE DrizzleColumn;
 
 // All mark and release methods
 typedef void (*FREE_METHOD)(void* ptr);
@@ -18,25 +21,30 @@ 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);
+void downpour_set_extra_pointer(VALUE self, void *extra_pointer, FREE_METHOD free_extra_pointer);
+void *downpour_get_extra_pointer(VALUE self);
 
 // 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_buffered_result_constructor(drizzle_result_st *self_ptr, VALUE connection);
+VALUE downpour_unbuffered_result_constructor(drizzle_result_st *self_ptr, VALUE connection);
 VALUE downpour_query_constructor(drizzle_query_st *self_ptr, VALUE connection);
+VALUE downpour_column_constructor(drizzle_column_st *self_ptr, VALUE result);
+VALUE downpour_include_result_module(drizzle_result_st *self_ptr, VALUE self);
 
 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; var_name = downpour_from_ruby_object(value)
+#define convert_to_struct(datatype, var_name, value) datatype *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 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))
+#define set_extra_pointer(value, ptr, free_method) downpour_set_extra_pointer(value, ptr, (FREE_METHOD) free_method)
 
 // Property Macros -> define attr(foo, conversion) and settr_string to use them
 #define attr_string(foo) attr(foo, rb_str_new2)

data/ext/downpour/helpers.c

@@ -5,17 +5,6 @@ static VALUE do_not_use_this_constructor(VALUE self)
   rb_raise(rb_eNameError, "private method `new' called for %s:Class.", rb_class2name(CLASS_OF(self)));
 }
 
-VALUE drizzle_gem_to_string_array(char **array, long count)
-{
-  VALUE ary = rb_ary_new2(count);
-
-  long i;
-  for(i = 0; i < count; i++)
-    rb_ary_push(ary, rb_str_new2(array[i]));
-
-  return ary;
-}
-
 VALUE drizzle_gem_create_class_with_private_constructor(const char *name, VALUE super)
 {
   VALUE ret = rb_define_class_under(DownpourModule, name, super);

data/ext/downpour/memory_allocation.c

@@ -6,6 +6,8 @@ typedef struct DownpourWrapper {
   struct DownpourWrapper *parent;
   FREE_METHOD free_method;
   VALUE rb_object;
+  void *extra_pointer;
+  FREE_METHOD free_extra_pointer_method;
 } DownpourWrapper;
 
 static void downpour_mark(DownpourWrapper *wrapper)
@@ -16,6 +18,23 @@ static void downpour_mark(DownpourWrapper *wrapper)
   wrapper->reference_count++;
 }
 
+static void exec_free_method(void *ptr, FREE_METHOD free_method)
+{
+  if(ptr == NULL || free_method == NULL)
+    return;
+  free_method(ptr);
+}
+
+static void free_extra_pointer(DownpourWrapper *wrapper)
+{
+  exec_free_method(wrapper->extra_pointer, wrapper->free_extra_pointer_method);
+}
+
+static void free_pointer(DownpourWrapper *wrapper)
+{
+  exec_free_method(wrapper->ptr, wrapper->free_method);
+}
+
 static void downpour_release(DownpourWrapper *wrapper)
 {
   if(wrapper == NULL)
@@ -24,7 +43,8 @@ static void downpour_release(DownpourWrapper *wrapper)
   wrapper->reference_count--;
 
   if(wrapper->reference_count == 0) {
-    wrapper->free_method(wrapper->ptr);
+    free_extra_pointer(wrapper);
+    free_pointer(wrapper);
     downpour_release(wrapper->parent);
     free(wrapper);
   }
@@ -37,6 +57,8 @@ static DownpourWrapper *downpour_wrap_pointer(void *ptr, DownpourWrapper *parent
   wrapper->parent = parent;
   wrapper->free_method = free_method;
   wrapper->reference_count = 0;
+  wrapper->extra_pointer = NULL;
+  wrapper->free_extra_pointer_method = NULL;
 
   downpour_mark(parent);
   downpour_mark(wrapper);
@@ -101,3 +123,17 @@ VALUE downpour_get_parent(VALUE self)
 
   return wrapper->parent->rb_object;
 }
+
+void downpour_set_extra_pointer(VALUE self, void *extra_pointer, FREE_METHOD free_extra_pointer_method)
+{
+  DownpourWrapper *wrapper = get_wrapper_from_object(self);
+  free_extra_pointer(wrapper);
+  wrapper->extra_pointer = extra_pointer;
+  wrapper->free_extra_pointer_method = free_extra_pointer_method;
+}
+
+void *downpour_get_extra_pointer(VALUE self)
+{
+  DownpourWrapper *wrapper = get_wrapper_from_object(self);
+  return wrapper->extra_pointer;
+}

data/ext/downpour/query.c

@@ -2,18 +2,13 @@
 
 #define SELF_TYPE drizzle_query_st
 
-static VALUE get_result(VALUE self)
+static VALUE create_results(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 connection = downpour_get_parent(self);
-  VALUE ret = rb_iv_set(self, "@result", downpour_result_constructor(result, connection));
-  return ret;
+  return downpour_buffered_result_constructor(result, connection);
 }
 
 VALUE downpour_query_constructor(drizzle_query_st *self_ptr, VALUE connection)
@@ -24,5 +19,5 @@ VALUE downpour_query_constructor(drizzle_query_st *self_ptr, VALUE connection)
 void init_drizzle_query()
 {
   DrizzleQuery = drizzle_gem_create_class_with_private_constructor("Query", rb_cObject);
-  rb_define_method(DrizzleQuery, "result", get_result, 0);
+  rb_define_private_method(DrizzleQuery, "create_results", create_results, 0);
 }

data/ext/downpour/result.c

@@ -1,4 +1,5 @@
 #include "downpour.h"
+#include "result.h"
 
 #define SELF_TYPE drizzle_result_st
 #define RUBY_CLASS DrizzleResult
@@ -9,67 +10,93 @@
   return conversion(drizzle_result_##foo(self_ptr));\
 }
 
-static uint64_t do_column_count(drizzle_result_st *self_ptr)
-{
-  return drizzle_result_column_count(self_ptr);
-}
+typedef struct ResultExtraInfo {
+  drizzle_column_st **columns;
+} ResultExtraInfo;
 
-static bool is_buffered_bool(VALUE self)
+static VALUE to_rb_value(char *str, drizzle_column_st *column)
 {
-  read_self_ptr();
-  return self_ptr->options & (DRIZZLE_RESULT_BUFFER_ROW);
-}
+  if(str == NULL)
+    return Qnil;
 
-static VALUE is_buffered(VALUE self)
+#define not_implemented rb_str_new2(str)
+
+  switch(drizzle_column_type(column)) {
+    case DRIZZLE_COLUMN_TYPE_DECIMAL:
+      return not_implemented;
+
+    case DRIZZLE_COLUMN_TYPE_TINY:
+    case DRIZZLE_COLUMN_TYPE_SHORT:
+    case DRIZZLE_COLUMN_TYPE_LONG:
+      return INT2NUM(strtol(str, NULL, 10));
+
+    case DRIZZLE_COLUMN_TYPE_FLOAT:
+    case DRIZZLE_COLUMN_TYPE_DOUBLE:
+      return rb_float_new(strtod(str, NULL));
+
+    case DRIZZLE_COLUMN_TYPE_NULL:
+    case DRIZZLE_COLUMN_TYPE_TIMESTAMP:
+    case DRIZZLE_COLUMN_TYPE_LONGLONG:
+    case DRIZZLE_COLUMN_TYPE_INT24:
+    case DRIZZLE_COLUMN_TYPE_DATE:
+    case DRIZZLE_COLUMN_TYPE_TIME:
+    case DRIZZLE_COLUMN_TYPE_DATETIME:
+    case DRIZZLE_COLUMN_TYPE_YEAR:
+    case DRIZZLE_COLUMN_TYPE_NEWDATE:
+      return not_implemented;
+
+    case DRIZZLE_COLUMN_TYPE_VARCHAR:
+      return rb_str_new2(str);
+
+    case DRIZZLE_COLUMN_TYPE_BIT:
+    case DRIZZLE_COLUMN_TYPE_NEWDECIMAL:
+    case DRIZZLE_COLUMN_TYPE_ENUM:
+    case DRIZZLE_COLUMN_TYPE_SET:
+    case DRIZZLE_COLUMN_TYPE_TINY_BLOB:
+    case DRIZZLE_COLUMN_TYPE_MEDIUM_BLOB:
+    case DRIZZLE_COLUMN_TYPE_LONG_BLOB:
+    case DRIZZLE_COLUMN_TYPE_BLOB:
+    case DRIZZLE_COLUMN_TYPE_VAR_STRING:
+    case DRIZZLE_COLUMN_TYPE_STRING:
+    case DRIZZLE_COLUMN_TYPE_GEOMETRY:
+
+    default:
+      return not_implemented;
+  }
+}
+
+static VALUE to_results_array(char **array, long count, drizzle_column_st **columns)
 {
-  return is_buffered_bool(self) ? Qtrue : Qfalse;
-}
+  VALUE ary = rb_ary_new2(count);
 
-static void raise_if_buffering_is_not_allowed(VALUE self)
-{
-  if(RTEST(rb_iv_get(self, "@cannot_buffer")))
-      rb_raise(rb_eIOError, "cannot buffer after reading a row");
-}
+  long i;
+  for(i = 0; i < count; i++)
+    rb_ary_push(ary, to_rb_value(array[i], columns[i]));
 
-static void disallow_buffering(VALUE self)
-{
-  rb_iv_set(self, "@cannot_buffer", Qtrue);
+  return ary;
 }
 
-static VALUE buffer_if_needed(VALUE self)
+VALUE downpour_wrap_row(VALUE self, drizzle_result_st *self_ptr, drizzle_row_t row)
 {
-  read_self_ptr();
-
-  raise_if_buffering_is_not_allowed(self);
+  // No more rows to read :-)
+  if(row == NULL)
+    return Qnil;
 
-  // Only buffer once
-  if(is_buffered_bool(self))
-    return Qfalse;
+  ResultExtraInfo *extra_info = downpour_get_extra_pointer(self);
 
-  CHECK_OK(drizzle_result_buffer(self_ptr));
-  return Qtrue;
+  return to_results_array(row, drizzle_result_column_count(self_ptr), extra_info->columns);
 }
 
-static VALUE row_count(VALUE self)
+bool downpour_is_buffered(drizzle_result_st *self_ptr)
 {
-  rb_call(self, "buffer!");
-  read_self_ptr();
-  return UINT2NUM(drizzle_result_row_count(self_ptr));
+  return self_ptr->options & (DRIZZLE_RESULT_BUFFER_ROW);
 }
 
-static VALUE wrap_row(drizzle_result_st *self_ptr, drizzle_row_t row)
+static VALUE is_buffered(VALUE self)
 {
-  // No more rows to read :-)
-  if(row == NULL)
-    return Qnil;
-
-  return drizzle_gem_to_string_array(row, do_column_count(self_ptr));
-}
+  read_self_ptr();
 
-static VALUE next_row_buffered(drizzle_result_st *self_ptr)
-{
-  drizzle_row_t result = drizzle_row_next(self_ptr);
-  return wrap_row(self_ptr, result);
+  return downpour_is_buffered(self_ptr) ? Qtrue : Qfalse;
 }
 
 static void buffer_column_if_needed(drizzle_result_st *self_ptr)
@@ -79,34 +106,45 @@ static void buffer_column_if_needed(drizzle_result_st *self_ptr)
   CHECK_OK(drizzle_column_buffer(self_ptr));
 }
 
-static drizzle_row_t do_drizzle_row_buffer(drizzle_result_st *self_ptr)
+static drizzle_column_st *next_column(drizzle_result_st *self_ptr)
 {
-  drizzle_return_t ret;
-  drizzle_row_t result = drizzle_row_buffer(self_ptr, &ret);
-  CHECK_OK(ret);
-  return result;
+  return drizzle_column_next(self_ptr);
 }
 
-static VALUE next_row_unbuffered(drizzle_result_st *self_ptr)
+static ResultExtraInfo *extra_info(drizzle_result_st *self_ptr)
 {
   buffer_column_if_needed(self_ptr);
-  drizzle_row_t result = do_drizzle_row_buffer(self_ptr);
-  VALUE parsed = wrap_row(self_ptr, result);
-  if(result)
-    drizzle_row_free(self_ptr, result);
-  return parsed;
+
+  ResultExtraInfo *result = drizzle_alloc(ResultExtraInfo);
+  int i, number_of_columns = drizzle_result_column_count(self_ptr);
+  result->columns = malloc(sizeof(drizzle_column_st *) * (number_of_columns + 1));
+
+  for (i = 0; i < number_of_columns; i++) {
+    result->columns[i] = next_column(self_ptr);
+  }
+  result->columns[number_of_columns] = NULL;
+  return result;
 }
 
-static VALUE next_row(VALUE self)
+static void free_extra_info(ResultExtraInfo *extra_info)
 {
-  read_self_ptr();
+  int i;
+  for (i = 0; extra_info->columns[i] != NULL; i++) {
+    drizzle_column_free(extra_info->columns[i]);
+  }
+  free(extra_info->columns);
+  free(extra_info);
+}
 
-  disallow_buffering(self);
+static VALUE get_columns_in_array(drizzle_result_st *self_ptr, VALUE self, ResultExtraInfo *extra_info)
+{
+  int i, number_of_columns = drizzle_result_column_count(self_ptr);
+  VALUE array = rb_ary_new2(number_of_columns);
 
-  if(is_buffered_bool(self))
-    return next_row_buffered(self_ptr);
+  for (i = 0; i < number_of_columns; i++)
+    rb_ary_push(array, downpour_column_constructor(extra_info->columns[i], self));
 
-  return next_row_unbuffered(self_ptr);
+  return array;
 }
 
 attr(column_count, UINT2NUM);
@@ -118,18 +156,18 @@ attr_string(sqlstate);
 attr_string(info);
 attr_string(error);
 
-VALUE downpour_result_constructor(drizzle_result_st *self_ptr, VALUE connection)
+VALUE downpour_include_result_module(drizzle_result_st *self_ptr, VALUE result)
 {
-  return to_ruby_object(self_ptr, DrizzleResult, connection, drizzle_result_free, NULL);
+  ResultExtraInfo *info = extra_info(self_ptr);
+  set_extra_pointer(result, info, free_extra_info);
+  rb_iv_set(result, "@columns", get_columns_in_array(self_ptr, result, info));
+  return result;
 }
 
 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, "buffer!", buffer_if_needed, 0);
+  DrizzleResult = rb_define_module_under(DownpourModule, "Result");
   rb_define_method(DrizzleResult, "buffered?", is_buffered, 0);
-  rb_define_method(DrizzleResult, "next_row", next_row, 0);
   define_attr(column_count);
   define_attr(insert_id);
   define_attr(error_code);

data/ext/downpour/result.h

@@ -0,0 +1,9 @@
+#ifndef RESULTS_H
+#define RESULTS_H
+
+#include "downpour.h"
+
+bool downpour_is_buffered(drizzle_result_st *self_ptr);
+VALUE downpour_wrap_row(VALUE self, drizzle_result_st *self_ptr, drizzle_row_t row);
+
+#endif

data/ext/downpour/unbuffered_result.c

@@ -0,0 +1,53 @@
+#include "downpour.h"
+#include "result.h"
+
+#define SELF_TYPE drizzle_result_st
+#define RUBY_CLASS DrizzleUnBufferedResult
+
+#define attr(foo, conversion) static VALUE attr_##foo(VALUE self)\
+{\
+  read_self_ptr();\
+  return conversion(drizzle_result_##foo(self_ptr));\
+}
+
+static drizzle_row_t do_drizzle_row_buffer(drizzle_result_st *self_ptr)
+{
+  drizzle_return_t ret;
+  drizzle_row_t result = drizzle_row_buffer(self_ptr, &ret);
+  CHECK_OK(ret);
+  return result;
+}
+
+static VALUE next_row(VALUE self)
+{
+  read_self_ptr();
+
+  drizzle_row_t result = do_drizzle_row_buffer(self_ptr);
+  VALUE parsed = downpour_wrap_row(self, self_ptr, result);
+  if(result)
+    drizzle_row_free(self_ptr, result);
+  return parsed;
+}
+
+// Improve this method
+static VALUE end_result(VALUE self)
+{
+  read_self_ptr();
+  while(do_drizzle_row_buffer(self_ptr) != NULL)
+    ; // Do Nothing
+  return Qnil;
+}
+
+VALUE downpour_unbuffered_result_constructor(drizzle_result_st *self_ptr, VALUE connection)
+{
+  VALUE ret = to_ruby_object(self_ptr, DrizzleUnBufferedResult, connection, drizzle_result_free, NULL);
+  return downpour_include_result_module(self_ptr, ret);
+}
+
+void init_drizzle_unbuffered_result()
+{
+  DrizzleUnBufferedResult = drizzle_gem_create_class_with_private_constructor("UnBufferedResult", rb_cObject);
+  rb_include_module(DrizzleUnBufferedResult, DrizzleResult);
+  rb_define_method(DrizzleUnBufferedResult, "next_row", next_row, 0);
+  rb_define_method(DrizzleUnBufferedResult, "close!", end_result, 0);
+}

data/lib/downpour.rb

@@ -1,3 +1,5 @@
 require 'downpour/downpour'
 require 'downpour/status'
 require 'downpour/version'
+require 'downpour/query'
+require 'downpour/result'

data/lib/downpour/query.rb

@@ -0,0 +1,8 @@
+module Downpour
+  class Query
+    def result
+      return @result if @result
+      @result = create_results
+    end
+  end
+end

data/lib/downpour/result.rb

@@ -0,0 +1,5 @@
+module Downpour
+  module Result
+    attr_reader :columns
+  end
+end

data/lib/downpour/version.rb

@@ -1,3 +1,3 @@
 module Downpour
-  VERSION = "0.0.7"
+  VERSION = "0.0.12"
 end

data/spec/bootstrap.sql

@@ -11,3 +11,12 @@ create table Test2 (
   id int auto_increment primary key,
   name varchar(20)
 );
+
+drop table if exists TestFieldTypes;
+create table TestFieldTypes (
+  null_field int,
+  string_field varchar(20),
+  int_field int,
+  double_field float
+);
+insert into TestFieldTypes values(NULL, 'foo', 42, 8.5);

data/spec/downpour/buffered_spec.rb

@@ -0,0 +1,20 @@
+describe "a buffered query" do
+
+  before(:each) do
+    @status = Downpour.create
+    @conn = create_connection(@status)
+    @results = @conn.query "select * from Test1"
+  end
+
+  it "should count records" do
+    @results.row_count.should == 3
+  end
+
+  it "should be able to run a second query" do
+    @conn.query "select * from Test2"
+  end
+
+  it "should be buffered" do
+    @results.should be_buffered
+  end
+end

data/spec/downpour/column_spec.rb

@@ -0,0 +1,33 @@
+describe "a drizzle result" do
+
+  before(:each) do
+    @status = Downpour.create
+    @conn = create_connection(@status)
+    @results = @conn.query "select id, name as newName from Test2"
+  end
+
+  it "should fetch all columns" do
+    @results.columns.size.should == 2
+  end
+
+  it "should count columns" do
+    @results.column_count.should == 2
+  end
+
+  it "should fetch column name" do
+    @results.columns[0].name.should == "id"
+    @results.columns[1].name.should == "newName"
+  end
+
+  it "should fetch the original name from table" do
+    @results.columns[1].orig_name.should == "name"
+  end
+
+  it "should have table name set on column" do
+    @results.columns[0].table.should == "Test2"
+  end
+
+  it "should return the same column each time" do
+    @results.columns[0].should == @results.columns[0]
+  end
+end

data/spec/downpour/concurrent_spec.rb

@@ -9,12 +9,6 @@ describe "a concurrent query" do
   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"]
@@ -43,6 +37,10 @@ describe "a concurrent query" do
       @status.run!.should be_nil
     end
 
+    it "should have buffered the results" do
+      @status.run!.result.should be_buffered
+    end
+
     it "should release pending queries" do
       query = @status.run!
       @status.pending_queries.should_not include(query)

data/spec/downpour/connection_spec.rb

@@ -18,14 +18,6 @@ describe "downpour connections" do
     it "should only accept a string as query" do
       lambda {@connection.query 42}.should raise_error(TypeError)
     end
-
-    it "should throw error if you try to read a row then buffer" do
-      lambda do
-        q = @connection.query "select * from Test1"
-        q.next_row
-        q.buffer!
-      end.should raise_error(IOError)
-    end
   end
   
   context "simple attributes" do

data/spec/downpour/select_spec.rb

@@ -1,49 +1,57 @@
-describe "a select query" do
+describe "select queries" do
 
   before(:each) do
     @status = Downpour.create
     @conn = create_connection(@status)
-    @results = @conn.query "select * from Test1"
   end
 
-  it "should count records" do
-    @results.row_count.should == 3
-    @results.should be_buffered
-  end
+  shared_examples_for "a select query" do
+    it "should read all rows" do
+      results = @create_results.call "select * from Test1"
+      results.next_row.should == ["foo"]
+      results.next_row.should == ["bar"]
+      results.next_row.should == ["baz"]
+      results.next_row.should be_nil
+    end
 
-  it "should buffer records" do
-    @results.should_not be_buffered
-    @results.buffer!
-    @results.should be_buffered
-  end
+    context "with different data types" do
+      before(:each) { @row = @create_results.call("select * from TestFieldTypes").next_row }
 
-  it "should only buffer records once" do
-    @results.buffer!.should be_true
-    @results.buffer!.should be_false
-  end
+      it "should read nil when there is null in the db" do
+        @row[0].should be_nil
+      end
 
-  shared_examples_for "a read query" do
-    it "should read all rows" do
-      @results.next_row.should == ["foo"]
-      @results.next_row.should == ["bar"]
-      @results.next_row.should == ["baz"]
-      @results.next_row.should be_nil
-    end
+      it "should read a string" do
+        @row[1].should == "foo"
+      end
+
+      it "should read an integer" do
+        @row[2].should == 42
+      end
 
-    it "should count columns" do
-      @results.column_count.should == 1
+      it "should read a floating point" do
+        @row[3].should == 8.5
+      end
     end
   end
 
-  context "without buffering" do
-    it_should_behave_like "a read query"
-
-    after(:each) {@results.should_not be_buffered}
+  context "an buffered select query" do
+    before(:each) { @create_results = lambda { |query| @conn.query query }}
+    it_should_behave_like "a select query"
   end
 
-  context "with buffering" do
-    before(:each) { @results.buffer! }
+  context "an unbuffered select query" do
+    before(:each) { @create_results = lambda { |query| @conn.unbuffered_query query }}
+    it_should_behave_like "a select query"
+  end
 
-    it_should_behave_like "a read query"
+  context "a concurrent select query" do
+    before(:each) do
+      @create_results = lambda do |query|
+        @status.add_query @conn, query
+        @status.run!.result
+      end
+    end
+    it_should_behave_like "a select query"
   end
 end

data/spec/downpour/unbuffered_spec.rb

@@ -0,0 +1,26 @@
+describe "an unbuffered select query" do
+
+  before(:each) do
+    @status = Downpour.create
+    @conn = create_connection(@status)
+    @results = @conn.unbuffered_query "select * from Test1"
+  end
+
+  it "should be able to run a second query after all rows are read" do
+    4.times { @results.next_row }
+    @conn.query "select * from Test2"
+  end
+
+  it "should be able to run another query after closing the query" do
+    @results.close!
+    @conn.query "select * from Test2"
+  end
+
+  it "should be unbuffered" do
+    @results.should_not be_buffered
+  end
+
+  it "should get column count" do
+    @results.column_count.should == 1
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: downpour
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.7
+  version: 0.0.12
 platform: ruby
 authors: 
 - Tejas Dinkar
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-03 00:00:00 +05:30
+date: 2011-06-12 00:00:00 +05:30
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -45,6 +45,8 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - downpour.gemspec
+- ext/downpour/buffered_result.c
+- ext/downpour/column.c
 - ext/downpour/connection.c
 - ext/downpour/downpour.c
 - ext/downpour/downpour.h
@@ -54,11 +56,17 @@ files:
 - ext/downpour/module.c
 - ext/downpour/query.c
 - ext/downpour/result.c
+- ext/downpour/result.h
 - ext/downpour/status.c
+- ext/downpour/unbuffered_result.c
 - lib/downpour.rb
+- lib/downpour/query.rb
+- lib/downpour/result.rb
 - lib/downpour/status.rb
 - lib/downpour/version.rb
 - spec/bootstrap.sql
+- spec/downpour/buffered_spec.rb
+- spec/downpour/column_spec.rb
 - spec/downpour/concurrent_spec.rb
 - spec/downpour/connect_type_spec.rb
 - spec/downpour/connection_spec.rb
@@ -66,6 +74,7 @@ files:
 - spec/downpour/memory_mgmt_spec.rb
 - spec/downpour/module_spec.rb
 - spec/downpour/select_spec.rb
+- spec/downpour/unbuffered_spec.rb
 - spec/spec_helper.rb
 - README.rdoc
 has_rdoc: true
@@ -99,6 +108,8 @@ specification_version: 3
 summary: A simple, fast Mysql and Drizzle library for Ruby, binding to libdrizzle
 test_files: 
 - spec/bootstrap.sql
+- spec/downpour/buffered_spec.rb
+- spec/downpour/column_spec.rb
 - spec/downpour/concurrent_spec.rb
 - spec/downpour/connect_type_spec.rb
 - spec/downpour/connection_spec.rb
@@ -106,4 +117,5 @@ test_files:
 - spec/downpour/memory_mgmt_spec.rb
 - spec/downpour/module_spec.rb
 - spec/downpour/select_spec.rb
+- spec/downpour/unbuffered_spec.rb
 - spec/spec_helper.rb