swift 0.4.3 → 0.5.0

data/ext/pool.cc

@@ -0,0 +1,89 @@
+#include "pool.h"
+
+VALUE cSwiftPool;
+
+static void pool_free(dbi::ConnectionPool *self) {
+  if (self) delete self;
+}
+
+VALUE pool_alloc(VALUE klass) {
+  dbi::ConnectionPool *pool = 0;
+  return Data_Wrap_Struct(klass, 0, pool_free, pool);
+}
+
+static dbi::ConnectionPool* pool_handle(VALUE self) {
+  dbi::ConnectionPool *pool;
+  Data_Get_Struct(self, dbi::ConnectionPool, pool);
+  if (!pool) rb_raise(eSwiftRuntimeError, "Invalid object, did you forget to call #super ?");
+  return pool;
+}
+
+// TODO: Remove unnecessary assignments. See Adapter.
+VALUE pool_init(VALUE self, VALUE n, VALUE options) {
+  VALUE db       = rb_hash_aref(options, ID2SYM(rb_intern("db")));
+  VALUE host     = rb_hash_aref(options, ID2SYM(rb_intern("host")));
+  VALUE port     = rb_hash_aref(options, ID2SYM(rb_intern("port")));
+  VALUE user     = rb_hash_aref(options, ID2SYM(rb_intern("user")));
+  VALUE driver   = rb_hash_aref(options, ID2SYM(rb_intern("driver")));
+  VALUE password = rb_hash_aref(options, ID2SYM(rb_intern("password")));
+  VALUE zone     = rb_hash_aref(options, ID2SYM(rb_intern("timezone")));
+
+  if (NIL_P(db))     rb_raise(eSwiftArgumentError, "Pool#new called without :db");
+  if (NIL_P(driver)) rb_raise(eSwiftArgumentError, "#new called without :driver");
+
+  user = NIL_P(user) ? rb_str_new2(getlogin()) : user;
+  if (NUM2INT(n) < 1) rb_raise(eSwiftArgumentError, "Pool#new called with invalid pool size.");
+
+  try {
+    DATA_PTR(self) = new dbi::ConnectionPool(
+      NUM2INT(n),
+      CSTRING(driver),
+      CSTRING(user),
+      CSTRING(password),
+      CSTRING(db),
+      CSTRING(host),
+      CSTRING(port)
+    );
+  }
+  CATCH_DBI_EXCEPTIONS();
+  return Qnil;
+}
+
+void pool_callback(dbi::AbstractResultSet *result) {
+  VALUE callback = (VALUE)result->context;
+  // NOTE ResultSet will be free'd by the underlying connection pool dispatcher ib dbic++
+  if (!NIL_P(callback)) rb_proc_call(callback, rb_ary_new3(1, Data_Wrap_Struct(cSwiftResult, 0, 0, result)));
+}
+
+VALUE pool_execute(int argc, VALUE *argv, VALUE self) {
+  int n;
+  VALUE sql;
+  VALUE bind_values;
+  VALUE callback;
+  VALUE request = Qnil;
+
+  dbi::ConnectionPool *pool = pool_handle(self);
+  rb_scan_args(argc, argv, "1*&", &sql, &bind_values, &callback);
+
+  if (NIL_P(callback)) rb_raise(eSwiftArgumentError, "No block given in Pool#execute");
+
+  try {
+    Query query;
+    query_bind_values(&query, bind_values);
+    request = request_alloc(cSwiftRequest);
+    DATA_PTR(request) = pool->execute(CSTRING(sql), query.bind, pool_callback, (void*)callback);
+    return request;
+  }
+  CATCH_DBI_EXCEPTIONS();
+}
+
+void init_swift_pool() {
+  VALUE mSwift = rb_define_module("Swift");
+  VALUE mDB    = rb_define_module_under(mSwift, "DB");
+  cSwiftPool   = rb_define_class_under(mDB, "Pool", rb_cObject);
+
+  rb_define_alloc_func(cSwiftPool, pool_alloc);
+
+  rb_define_method(cSwiftPool, "initialize",  RUBY_METHOD_FUNC(pool_init),     2);
+  rb_define_method(cSwiftPool, "execute",     RUBY_METHOD_FUNC(pool_execute), -1);
+}

data/ext/pool.h

@@ -0,0 +1,8 @@
+#ifndef SWIFT_POOL_H
+#define SWIFT_POOL_H
+
+#include "swift.h"
+
+void init_swift_pool();
+
+#endif

data/ext/query.cc

@@ -0,0 +1,38 @@
+#include "query.h"
+
+VALUE query_execute(Query *query) {
+  return UINT2NUM(
+    query->bind.size() == 0
+      ? query->handle->conn()->execute(query->sql)
+      : query->handle->conn()->execute(query->sql, query->bind)
+  );
+}
+
+VALUE query_execute_statement(Query *query) {
+  return UINT2NUM(
+    query->bind.size() == 0
+      ? query->statement->execute()
+      : query->statement->execute(query->bind)
+  );
+}
+
+void query_bind_values(Query *query, VALUE bind_values) {
+  for (int i = 0; i < RARRAY_LEN(bind_values); i++) {
+    VALUE bind_value = rb_ary_entry(bind_values, i);
+
+    if (bind_value == Qnil) {
+      query->bind.push_back(dbi::PARAM(dbi::null()));
+    }
+    else if (rb_obj_is_kind_of(bind_value, rb_cIO) ==  Qtrue || rb_obj_is_kind_of(bind_value, cStringIO) ==  Qtrue) {
+      bind_value = rb_funcall(bind_value, rb_intern("read"), 0);
+      query->bind.push_back(dbi::PARAM_BINARY((unsigned char*)RSTRING_PTR(bind_value), RSTRING_LEN(bind_value)));
+    }
+    else {
+      bind_value = TO_S(bind_value);
+      if (strcmp(rb_enc_get(bind_value)->name, "UTF-8") != 0)
+        bind_value = rb_str_encode(bind_value, rb_str_new2("UTF-8"), 0, Qnil);
+      query->bind.push_back(dbi::PARAM((unsigned char*)RSTRING_PTR(bind_value), RSTRING_LEN(bind_value)));
+    }
+  }
+}
+

data/ext/query.h

@@ -0,0 +1,17 @@
+#ifndef SWIFT_QUERY_H
+#define SWIFT_QUERY_H
+
+#include "swift.h"
+
+struct Query {
+  char                   *sql;
+  dbi::Handle            *handle;
+  dbi::AbstractStatement *statement;
+  dbi::ResultRow         bind;
+};
+
+VALUE query_execute(Query*);
+VALUE query_execute_statement(Query*);
+void query_bind_values(Query*, VALUE);
+
+#endif

data/ext/request.cc

@@ -0,0 +1,44 @@
+#include "request.h"
+
+VALUE cSwiftRequest;
+
+static void request_free(dbi::Request *request) {
+  if(request) delete request;
+}
+
+VALUE request_alloc(VALUE klass) {
+  dbi::Request *request = 0;
+  return Data_Wrap_Struct(klass, 0, request_free, request);
+}
+
+static dbi::Request* request_handle(VALUE self) {
+  dbi::Request *request;
+  Data_Get_Struct(self, dbi::Request, request);
+  if (!request) rb_raise(eSwiftRuntimeError, "Invalid object, did you forget to call #super ?");
+  return request;
+}
+
+VALUE request_socket(VALUE self) {
+  dbi::Request *request = request_handle(self);
+  try {
+    return INT2NUM(request->socket());
+  }
+  CATCH_DBI_EXCEPTIONS();
+}
+
+VALUE request_process(VALUE self) {
+  dbi::Request *request = request_handle(self);
+  try {
+    return request->process() ? Qtrue : Qfalse;
+  }
+  CATCH_DBI_EXCEPTIONS();
+}
+
+void init_swift_request() {
+  VALUE mSwift  = rb_define_module("Swift");
+  cSwiftRequest = rb_define_class_under(mSwift, "Request", rb_cObject);
+
+  rb_define_alloc_func(cSwiftRequest, request_alloc);
+  rb_define_method(cSwiftRequest, "socket",  RUBY_METHOD_FUNC(request_socket),  0);
+  rb_define_method(cSwiftRequest, "process", RUBY_METHOD_FUNC(request_process), 0);
+}

data/ext/request.h

@@ -0,0 +1,10 @@
+#ifndef SWIFT_REQUEST_H
+#define SWIFT_REQUEST_H
+
+#include "swift.h"
+
+extern VALUE cSwiftRequest;
+VALUE request_alloc(VALUE klass);
+void init_swift_request();
+
+#endif

data/ext/result.cc

@@ -0,0 +1,246 @@
+#include "result.h"
+
+VALUE cSwiftResult;
+VALUE cDateTime;
+VALUE cStringIO;
+VALUE cBigDecimal;
+
+VALUE fNew, fNewBang;
+
+uint64_t epoch_ajd_n, epoch_ajd_d;
+VALUE daysecs, sg;
+
+void result_free(dbi::AbstractResultSet *result) {
+  if (result) {
+    result->cleanup();
+    delete result;
+  }
+}
+
+VALUE result_alloc(VALUE klass) {
+  dbi::AbstractResultSet *result = 0;
+  return Data_Wrap_Struct(klass, 0, result_free, result);
+}
+
+// TODO:
+static VALUE result_clone(VALUE self) {
+  rb_raise(eSwiftRuntimeError, "clone is not allowed.");
+}
+
+// TODO:
+static VALUE result_dup(VALUE self) {
+  rb_raise(eSwiftRuntimeError, "dup is not allowed.");
+}
+
+VALUE result_each(VALUE self) {
+  uint64_t length;
+  const char *data;
+
+  dbi::AbstractResultSet *result = result_handle(self);
+  VALUE scheme = rb_iv_get(self, "@scheme");
+
+  try {
+    VALUE fields                      = rb_ary_new();
+    std::vector<string> result_fields = result->fields();
+    std::vector<int>    result_types  = result->types();
+    for (uint32_t i = 0; i < result_fields.size(); i++) {
+      rb_ary_push(fields, ID2SYM(rb_intern(result_fields[i].c_str())));
+    }
+
+    result->seek(0);
+    for (uint32_t row = 0; row < result->rows(); row++) {
+      VALUE tuple = rb_hash_new();
+      for (uint32_t column = 0; column < result->columns(); column++) {
+        data = (const char*)result->read(row, column, &length);
+        if (data) {
+          rb_hash_aset(
+            tuple,
+            rb_ary_entry(fields, column),
+            typecast_field(result_types[column], data, length)
+          );
+        }
+        else {
+          rb_hash_aset(tuple, rb_ary_entry(fields, column), Qnil);
+        }
+      } // column loop
+      NIL_P(scheme) ? rb_yield(tuple) : rb_yield(rb_funcall(scheme, rb_intern("load"), 1, tuple));
+    } // row loop
+  }
+  CATCH_DBI_EXCEPTIONS();
+
+  return Qnil;
+}
+
+dbi::AbstractResultSet* result_handle(VALUE self) {
+  dbi::AbstractResultSet *result;
+  Data_Get_Struct(self, dbi::AbstractResultSet, result);
+  if (!result) rb_raise(eSwiftRuntimeError, "Invalid object, did you forget to call #super?");
+
+  return result;
+}
+
+static VALUE result_finish(VALUE self) {
+  dbi::AbstractResultSet *result = result_handle(self);
+  try {
+    result->finish();
+  }
+  CATCH_DBI_EXCEPTIONS();
+}
+
+// Calculates local offset at a given time, including dst.
+size_t client_tzoffset(uint64_t local, int isdst) {
+  struct tm tm;
+  gmtime_r((const time_t*)&local, &tm);
+  return local + (isdst ? 3600 : 0) - mktime(&tm);
+}
+
+// pinched from do_postgres
+static void reduce(uint64_t *numerator, uint64_t *denominator) {
+  uint64_t a, b, c;
+  a = *numerator;
+  b = *denominator;
+  while (a) {
+    c = a; a = b % a; b = c;
+  }
+  *numerator   = *numerator   / b;
+  *denominator = *denominator / b;
+}
+
+VALUE typecast_datetime(const char *data, uint64_t len) {
+  struct tm tm;
+  uint64_t epoch, adjust, offset;
+
+  double usec = 0;
+  char tzsign = 0;
+  int tzhour  = 0, tzmin = 0;
+
+  memset(&tm, 0, sizeof(struct tm));
+  if (strchr(data, '.')) {
+    sscanf(data, "%04d-%02d-%02d %02d:%02d:%02d%lf%c%02d:%02d",
+      &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec,
+      &usec, &tzsign, &tzhour, &tzmin);
+  }
+  else {
+    sscanf(data, "%04d-%02d-%02d %02d:%02d:%02d%c%02d:%02d",
+      &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec,
+      &tzsign, &tzhour, &tzmin);
+  }
+
+  tm.tm_year  -= 1900;
+  tm.tm_mon   -= 1;
+  tm.tm_isdst = -1;
+  if (tm.tm_mday > 0) {
+    epoch  = mktime(&tm);
+    adjust = client_tzoffset(epoch, tm.tm_isdst);
+    offset = adjust;
+
+    if (tzsign == '+' || tzsign == '-') {
+      offset = tzsign == '+'
+        ? (time_t)tzhour *  3600 + (time_t)tzmin *  60
+        : (time_t)tzhour * -3600 + (time_t)tzmin * -60;
+    }
+
+    // 32bit platforms are for weenies
+    uint64_t ajd_n = (epoch + adjust - offset), ajd_d = 86400L;
+    reduce(&ajd_n, &ajd_d);
+    ajd_n = epoch_ajd_n*ajd_d  + ajd_n*epoch_ajd_d;
+    ajd_d = epoch_ajd_d*ajd_d;
+    reduce(&ajd_n, &ajd_d);
+
+    VALUE ajd = rb_rational_new(SIZET2NUM(ajd_n), SIZET2NUM(ajd_d));
+    return rb_funcall(cDateTime, fNewBang, 3, ajd, rb_rational_new(INT2FIX(offset), daysecs), sg);
+  }
+
+  // TODO: throw a warning ?
+  return rb_str_new(data, len);
+}
+
+VALUE typecast_field(int type, const char *data, uint64_t length) {
+  switch(type) {
+    case DBI_TYPE_BOOLEAN:
+      return strcmp(data, "t") == 0 || strcmp(data, "1") == 0 ? Qtrue : Qfalse;
+    case DBI_TYPE_INT:
+      return rb_cstr2inum(data, 10);
+    case DBI_TYPE_BLOB:
+      return rb_funcall(cStringIO, fNew, 1, rb_str_new(data, length));
+    case DBI_TYPE_TEXT:
+      return rb_enc_str_new(data, length, rb_utf8_encoding());
+    case DBI_TYPE_TIME:
+      return typecast_datetime(data, length);
+    case DBI_TYPE_NUMERIC:
+      return rb_funcall(cBigDecimal, fNew, 1, rb_str_new2(data));
+    case DBI_TYPE_FLOAT:
+      return rb_float_new(atof(data));
+  }
+}
+
+VALUE result_insert_id(VALUE self) {
+  dbi::AbstractResultSet *result = result_handle(self);
+  try {
+    return SIZET2NUM(result->lastInsertID());
+  }
+  CATCH_DBI_EXCEPTIONS();
+  return Qnil;
+}
+
+VALUE result_rows(VALUE self) {
+  dbi::AbstractResultSet *result = result_handle(self);
+  try {
+    return SIZET2NUM(result->rows());
+  }
+  CATCH_DBI_EXCEPTIONS();
+}
+
+VALUE result_columns(VALUE self) {
+  dbi::AbstractResultSet *result = result_handle(self);
+  try {
+    return SIZET2NUM(result->columns());
+  }
+  CATCH_DBI_EXCEPTIONS();
+}
+
+VALUE result_fields(VALUE self) {
+  dbi::AbstractResultSet *result = result_handle(self);
+  try {
+    std::vector<string> result_fields = result->fields();
+    VALUE fields = rb_ary_new();
+    for (int i = 0; i < result_fields.size(); i++)
+      rb_ary_push(fields, rb_str_new2(result_fields[i].c_str()));
+    return fields;
+  }
+  CATCH_DBI_EXCEPTIONS();
+}
+
+void init_swift_result() {
+  rb_require("bigdecimal");
+  rb_require("stringio");
+  rb_require("date");
+
+  VALUE mSwift = rb_define_module("Swift");
+  cSwiftResult = rb_define_class_under(mSwift, "Result", rb_cObject);
+  cDateTime    = CONST_GET(rb_mKernel, "DateTime");
+  cStringIO    = CONST_GET(rb_mKernel, "StringIO");
+  cBigDecimal  = CONST_GET(rb_mKernel, "BigDecimal");
+
+  fNew         = rb_intern("new");
+  fNewBang     = rb_intern("new!");
+
+  rb_define_alloc_func(cSwiftResult, result_alloc);
+  rb_include_module(cSwiftResult, CONST_GET(rb_mKernel, "Enumerable"));
+
+  rb_define_method(cSwiftResult, "clone",      RUBY_METHOD_FUNC(result_clone),     0);
+  rb_define_method(cSwiftResult, "dup",        RUBY_METHOD_FUNC(result_dup),       0);
+  rb_define_method(cSwiftResult, "each",       RUBY_METHOD_FUNC(result_each),      0);
+  rb_define_method(cSwiftResult, "finish",     RUBY_METHOD_FUNC(result_finish),    0);
+  rb_define_method(cSwiftResult, "insert_id",  RUBY_METHOD_FUNC(result_insert_id), 0);
+  rb_define_method(cSwiftResult, "rows",       RUBY_METHOD_FUNC(result_rows),      0);
+  rb_define_method(cSwiftResult, "columns",    RUBY_METHOD_FUNC(result_columns),   0);
+  rb_define_method(cSwiftResult, "fields",     RUBY_METHOD_FUNC(result_fields),    0);
+
+  // typecast_datetime setup.
+  epoch_ajd_d = 2;
+  epoch_ajd_n = 4881175L;            // 1970-01-01 00:00:00 is 2440587.5 in ajd
+  daysecs     = SIZET2NUM(86400L);
+  sg          = SIZET2NUM(2299161L); // day of calendar reform Date::ITALY
+}
+

data/ext/result.h

@@ -0,0 +1,17 @@
+#ifndef SWIFT_RESULT_H
+#define SWIFT_RESULT_H
+
+#include "swift.h"
+
+extern VALUE cSwiftResult;
+extern VALUE cStringIO;
+
+void init_swift_result();
+void result_free(dbi::AbstractResultSet*);
+VALUE result_each(VALUE);
+dbi::AbstractResultSet* result_handle(VALUE);
+
+VALUE typecast_field(int, const char*, uint64_t);
+VALUE typecast_datetime(const char*, uint64_t);
+
+#endif

data/ext/statement.cc

@@ -0,0 +1,87 @@
+#include "statement.h"
+#include "adapter.h"
+#include "result.h"
+#include "query.h"
+
+VALUE cSwiftStatement;
+
+void statement_free(dbi::AbstractStatement *statement) {
+  if (statement) {
+    statement->cleanup();
+    delete statement;
+  }
+}
+
+VALUE statement_alloc(VALUE klass) {
+  dbi::AbstractStatement *statement = 0;
+  return Data_Wrap_Struct(klass, 0, statement_free, statement);
+}
+
+dbi::AbstractStatement* statement_handle(VALUE self) {
+  dbi::AbstractStatement *handle;
+  Data_Get_Struct(self, dbi::AbstractStatement, handle);
+  if (!handle) rb_raise(eSwiftRuntimeError, "Invalid object, did you forget to call #super?");
+
+  return handle;
+}
+
+// TODO: Change bind_values to an array in the interface? Avoid array -> splat -> array.
+static VALUE statement_execute(int argc, VALUE *argv, VALUE self) {
+  VALUE bind_values, block;
+  rb_scan_args(argc, argv, "0*&", &bind_values, &block);
+
+  dbi::AbstractStatement *statement = (dbi::AbstractStatement*)statement_handle(self);
+  try {
+    Query query;
+    query.statement = statement;
+    if (RARRAY_LEN(bind_values) > 0) query_bind_values(&query, bind_values);
+    if (dbi::_trace)                 dbi::logMessage(dbi::_trace_fd, dbi::formatParams(statement->command(), query.bind));
+
+    // TODO: http://redmine.ruby-lang.org/issues/show/3762
+    //       rb_thread_blocking_region and C++ exceptions don't mix in 1.9.2.
+    // rb_thread_blocking_region(((VALUE (*)(void*))query_execute_statement), &query, RUBY_UBF_IO, 0);
+    query_execute_statement(&query);
+  }
+  CATCH_DBI_EXCEPTIONS();
+
+  if (rb_block_given_p()) return result_each(self);
+  return self;
+}
+
+VALUE statement_initialize(VALUE self, VALUE adapter, VALUE sql) {
+  dbi::Handle *handle = adapter_handle(adapter);
+
+  if (NIL_P(adapter)) rb_raise(eSwiftArgumentError, "Statement#new called without an Adapter instance.");
+  if (NIL_P(sql))     rb_raise(eSwiftArgumentError, "Statement#new called without a command.");
+
+  try {
+    DATA_PTR(self) = handle->conn()->prepare(CSTRING(sql));
+  }
+  CATCH_DBI_EXCEPTIONS();
+
+  return Qnil;
+}
+
+void init_swift_statement() {
+  VALUE mSwift = rb_define_module("Swift");
+
+  /*
+    TODO Inheritance confusion.
+
+    dbic++ has this,
+    dbi::Statement < dbi::AbstractStatement
+    dbi::AbstractStatement < dbi::AbstractResult
+
+    Swift has this,
+    Statement < Result
+
+    Not sure if this hierarchy is correct or perfect. I reckon Statement should not
+    inherit Result and just return a Result on execute() - maybe cleaner but very
+    inefficient when doing tons on non-select style queries.
+  */
+
+  cSwiftStatement = rb_define_class_under(mSwift, "Statement", cSwiftResult);
+  rb_define_method(cSwiftStatement, "execute",    RUBY_METHOD_FUNC(statement_execute),   -1);
+  rb_define_method(cSwiftStatement, "initialize", RUBY_METHOD_FUNC(statement_initialize), 2);
+  rb_define_alloc_func(cSwiftStatement, statement_alloc);
+}

data/ext/statement.h

@@ -0,0 +1,12 @@
+#ifndef SWIFT_STATEMENT_H
+#define SWIFT_STATEMENT_H
+
+#include "swift.h"
+
+extern VALUE cSwiftStatement;
+
+void init_swift_statement();
+void statement_free(dbi::AbstractStatement*);
+
+#endif
+