downpour 0.0.1

data/README.rdoc

@@ -0,0 +1,9 @@
+= Downpour 0.0.1
+
+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

data/downpour.gemspec

@@ -0,0 +1,25 @@
+require File.expand_path('../lib/downpour/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = %q{downpour}
+  s.version = Downpour::VERSION
+  s.authors = ["Tejas Dinkar"]
+  s.date = Time.now.utc.strftime("%Y-%m-%d")
+  s.email = %q{tejas@gja.in}
+  s.extensions = ["ext/downpour/extconf.rb"]
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = `git ls-files ext lib downpour.gemspec`.split("\n")
+  s.homepage = %q{http://github.com/gja/downpour}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib", "ext"]
+  s.rubygems_version = %q{1.4.2}
+  s.summary = %q{A simple, fast Mysql and Drizzle library for Ruby, binding to libdrizzle}
+  s.description = %q{A simple, fast Mysql and Drizzle library for Ruby, binding to libdrizzle. Still in early alpha}
+  s.test_files = `git ls-files spec examples`.split("\n")
+
+  # tests
+  s.add_development_dependency 'rake-compiler', "~> 0.7.1"
+  s.add_development_dependency 'rspec'
+end

data/ext/downpour/connection.c

@@ -0,0 +1,23 @@
+#include "drizzle.h"
+
+#define SELF_TYPE drizzle_con_st
+
+static VALUE query(VALUE self, VALUE query)
+{
+  read_self_ptr();
+
+  Check_Type(query, T_STRING);
+  
+  drizzle_return_t retptr;
+  drizzle_result_st *result = drizzle_query(self_ptr, NULL, RSTRING_PTR(query), RSTRING_LEN(query), &retptr);
+
+  CHECK_OK(retptr);
+
+  return Data_Wrap_Struct(DrizzleResult, NULL, NULL, result);
+}
+
+void init_drizzle_connection()
+{
+  DrizzleConnection = drizzle_gem_create_class_with_private_constructor("Connection", rb_cObject);
+  rb_define_method(DrizzleConnection, "query", query, 1);
+}

data/ext/downpour/drizzle.c

@@ -0,0 +1,19 @@
+#include "drizzle.h"
+
+VALUE DrizzleModule;
+VALUE DrizzleStatus;
+VALUE DrizzleConnection;
+VALUE DrizzleResult;
+
+void init_drizzle_module();
+void init_drizzle_status();
+void init_drizzle_connection();
+void init_drizzle_result();
+
+void Init_downpour()
+{
+  init_drizzle_module();
+  init_drizzle_status();
+  init_drizzle_connection();
+  init_drizzle_result();
+}

data/ext/downpour/drizzle.h

@@ -0,0 +1,24 @@
+#ifndef DRIZZLE_H
+#define DRIZZLE_H
+
+#include "ruby.h"
+#include <libdrizzle/drizzle.h>
+#include <libdrizzle/drizzle_client.h>
+
+extern VALUE DrizzleModule;
+extern VALUE DrizzleStatus;
+extern VALUE DrizzleConnection;
+extern VALUE DrizzleResult;
+
+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 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)
+
+#endif

data/ext/downpour/extconf.rb

@@ -0,0 +1,9 @@
+require 'mkmf'
+
+extension_name = 'downpour'
+dir_config(extension_name)
+
+have_library("drizzle")
+$CFLAGS += " -I/usr/local/include/libdrizzle-1.0 -I/usr/include/libdrizzle-1.0"
+
+create_makefile(extension_name)

data/ext/downpour/helpers.c

@@ -0,0 +1,39 @@
+#include "drizzle.h"
+
+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(DrizzleModule, name, super);
+  rb_define_method(ret, "initialize", do_not_use_this_constructor, 0);
+  return ret;
+}
+
+void drizzle_gem_assert_value_is_ok(drizzle_return_t ret)
+{
+  if(ret != DRIZZLE_RETURN_OK)
+    rb_raise(rb_eIOError, "Action Failed with error code: %d. Please check the error string on status object for more information", ret);
+}
+
+const char *drizzle_gem_read_string_with_default(VALUE string, const char *default_value)
+{
+  if(string == Qnil)
+    return default_value;
+
+  Check_Type(string, T_STRING);
+  return RSTRING_PTR(string);
+}

data/ext/downpour/module.c

@@ -0,0 +1,19 @@
+#include "drizzle.h"
+
+static VALUE version(VALUE self)
+{
+  return rb_str_new2(drizzle_version());
+}
+
+static VALUE create(VALUE self)
+{
+  drizzle_st *ptr = drizzle_create(NULL);
+  return Data_Wrap_Struct(DrizzleStatus, NULL, drizzle_free, ptr);
+}
+
+void init_drizzle_module()
+{
+  DrizzleModule = rb_define_module("Drizzle");
+  rb_define_singleton_method(DrizzleModule, "version", version, 0);
+  rb_define_singleton_method(DrizzleModule, "create", create, 0);
+}

data/ext/downpour/result.c

@@ -0,0 +1,92 @@
+#include "drizzle.h"
+
+#define SELF_TYPE drizzle_result_st
+
+static uint64_t do_column_count(drizzle_result_st *self_ptr)
+{
+  return drizzle_result_column_count(self_ptr);
+}
+
+static VALUE is_buffered(VALUE self)
+{
+  VALUE buffered = rb_iv_get(self, "@buffered");
+
+  if(buffered == Qnil || buffered == Qfalse)
+    return Qfalse;
+
+  return buffered;
+}
+
+static bool is_buffered_bool(VALUE self)
+{
+  return RTEST(rb_call(self, "buffered?"));
+}
+
+static VALUE buffer_if_needed(VALUE self)
+{
+  read_self_ptr();
+
+  // Only buffer once
+  if(is_buffered_bool(self))
+    return Qfalse;
+
+  CHECK_OK(drizzle_result_buffer(self_ptr));
+  rb_iv_set(self, "@buffered", Qtrue);
+  return Qtrue;
+}
+
+static VALUE row_count(VALUE self)
+{
+  rb_call(self, "buffer!");
+  read_self_ptr();
+  return UINT2NUM(drizzle_result_row_count(self_ptr));
+}
+
+static VALUE wrap_row(drizzle_result_st *self_ptr, drizzle_row_t row)
+{
+  // No more rows to read :-)
+  if(row == NULL)
+    return Qnil;
+
+  // TODO: wrap this in a Ruby Object. It should be freed
+  return drizzle_gem_to_string_array(row, do_column_count(self_ptr));
+}
+
+static VALUE next_row_buffered(drizzle_result_st *self_ptr)
+{
+  return wrap_row(self_ptr, drizzle_row_next(self_ptr));
+}
+
+static VALUE next_row_unbuffered(drizzle_result_st *self_ptr)
+{
+  drizzle_return_t ret;
+  drizzle_row_t result = drizzle_row_buffer(self_ptr, &ret);
+  CHECK_OK(ret);
+  return wrap_row(self_ptr, result);
+}
+
+static VALUE next_row(VALUE self)
+{
+  read_self_ptr();
+
+  if(is_buffered_bool(self))
+    return next_row_buffered(self_ptr);
+
+  return next_row_unbuffered(self_ptr);
+}
+
+static VALUE column_count(VALUE self)
+{
+  read_self_ptr();
+  return UINT2NUM(do_column_count(self_ptr));
+}
+
+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);
+}

data/ext/downpour/status.c

@@ -0,0 +1,67 @@
+#include "drizzle.h"
+
+#define SELF_TYPE drizzle_st
+
+static VALUE clone_status(VALUE self)
+{
+  read_self_ptr();
+  drizzle_st *cloned = drizzle_clone(NULL, self_ptr);
+  return Data_Wrap_Struct(DrizzleStatus, NULL, drizzle_free, cloned);
+}
+
+static in_port_t get_port(VALUE port)
+{
+  if(port == Qnil)
+    return DRIZZLE_DEFAULT_TCP_PORT;
+  Check_Type(port, T_FIXNUM);
+  return NUM2UINT(port);
+}
+
+
+static VALUE add_tcp_connection(int argc, VALUE *argv, VALUE self)
+{
+  read_self_ptr();
+
+  VALUE host, port, user, passwd, db, options;
+
+  //TODO: We ignore options
+  rb_scan_args(argc, argv, "06", &host, &user, &passwd, &db, &port, &options);
+
+  drizzle_con_st *connection = drizzle_con_add_tcp(self_ptr, NULL, 
+                                                    read_string(host, "localhost"), 
+                                                    get_port(port),
+                                                    read_string(user, ""),
+                                                    read_string(passwd, ""),
+                                                    read_string(db, "test"),
+                                                    DRIZZLE_CON_NONE);
+
+  VALUE val = Data_Wrap_Struct(DrizzleConnection, NULL, NULL, connection);
+  rb_iv_set(val, "@status", self);
+  return val;
+}
+
+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;
+}
+
+void init_drizzle_status()
+{
+  DrizzleStatus = drizzle_gem_create_class_with_private_constructor("Status", rb_cObject);
+  rb_define_method(DrizzleStatus, "clone", clone_status, 0);
+  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);
+}

data/lib/downpour/version.rb

@@ -0,0 +1,3 @@
+module Downpour
+  VERSION = "0.0.1"
+end

data/lib/downpour.rb

@@ -0,0 +1,2 @@
+require 'downpour/downpour'
+require 'downpour/version'

data/spec/bootstrap.sql

@@ -0,0 +1,7 @@
+drop table if exists Test1;
+create table Test1 (
+  name varchar(20)
+);
+insert into Test1 values ('foo');
+insert into Test1 values ('bar');
+insert into Test1 values ('baz');

data/spec/module_spec.rb

@@ -0,0 +1,5 @@
+describe Drizzle do
+  it "should have the version number set" do
+    Drizzle.version.should == "7"
+  end
+end

data/spec/query_spec.rb

@@ -0,0 +1,27 @@
+describe Drizzle do
+  before(:each) do
+    @status = Drizzle.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

data/spec/smoke_spec.rb

@@ -0,0 +1,61 @@
+describe Drizzle do
+
+  before(:each) do
+    @status = Drizzle.create
+    @conn = create_connection(@status)
+  end
+
+  context "select query" do
+    before(:each) do
+      @results = @conn.query "select * from Test1"
+    end
+
+    it "should count records" do
+      @results.row_count.should == 3
+      @results.should be_buffered
+    end
+
+    it "should buffer records" do
+      @results.should_not be_buffered
+      @results.buffer!
+      @results.should be_buffered
+    end
+
+    it "should only buffer records once" do
+      @results.buffer!.should be_true
+      @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"]
+        @results.next_row.should == ["bar"]
+        @results.next_row.should == ["baz"]
+        @results.next_row.should be_nil
+      end
+    end
+
+    context "without buffering" do
+      it_should_behave_like "a read query"
+    end
+
+    context "with buffering" do
+      before(:each) { @results.buffer! }
+
+      it_should_behave_like "a read query"
+    end
+  end
+
+  after(:each) do
+    #puts @status.error
+  end
+end

data/spec/spec_helper.rb

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

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification 
+name: downpour
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Tejas Dinkar
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-25 00:00:00 +05:30
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake-compiler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !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 
+    none: false
+    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
+email: tejas@gja.in
+executables: []
+
+extensions: 
+- ext/downpour/extconf.rb
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- downpour.gemspec
+- ext/downpour/connection.c
+- ext/downpour/drizzle.c
+- ext/downpour/drizzle.h
+- ext/downpour/extconf.rb
+- ext/downpour/helpers.c
+- ext/downpour/module.c
+- ext/downpour/result.c
+- ext/downpour/status.c
+- lib/downpour.rb
+- lib/downpour/version.rb
+- README.rdoc
+- spec/bootstrap.sql
+- spec/module_spec.rb
+- spec/query_spec.rb
+- spec/smoke_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/gja/downpour
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  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: 
+- spec/bootstrap.sql
+- spec/module_spec.rb
+- spec/query_spec.rb
+- spec/smoke_spec.rb
+- spec/spec_helper.rb