swift-db-postgres 0.1.0

data/ext/swift/db/postgres/adapter.h

@@ -0,0 +1,14 @@
+// vim:ts=4:sts=4:sw=4:expandtab
+
+// (c) Bharanee Rathna 2012
+
+#pragma once
+
+#include "common.h"
+
+typedef struct Adapter {
+    PGconn *connection;
+    int t_nesting;
+} Adapter;
+
+void init_swift_db_postgres_adapter();

data/ext/swift/db/postgres/common.c

@@ -0,0 +1,59 @@
+// vim:ts=4:sts=4:sw=4:expandtab
+
+// (c) Bharanee Rathna 2012
+
+#include "common.h"
+#include <uuid/uuid.h>
+
+VALUE rb_uuid_string() {
+    size_t n;
+    uuid_t uuid;
+    char uuid_hex[sizeof(uuid_t) * 2 + 1];
+
+    uuid_generate(uuid);
+    for (n = 0; n < sizeof(uuid_t); n++)
+        sprintf(uuid_hex + n * 2 + 1, "%02x", uuid[n]);
+
+    uuid_hex[0] = 'u';
+    return rb_str_new(uuid_hex, sizeof(uuid_t) * 2 + 1);
+}
+
+/* NOTE: very naive, no regex etc. */
+/* TODO: a better ragel based replace thingamajigy */
+VALUE db_postgres_normalized_sql(VALUE sql) {
+    int i = 0, j = 0, n = 1;
+    char normalized[RSTRING_LEN(sql) * 2], *ptr = RSTRING_PTR(sql);
+
+    while (i < RSTRING_LEN(sql)) {
+        if (*ptr == '?')
+            j += snprintf(normalized + j, 4, "$%d", n++);
+        else
+            normalized[j++] = *ptr;
+        ptr++;
+        i++;
+    }
+
+    return rb_str_new(normalized, j);
+}
+
+void db_postgres_check_result(PGresult *result) {
+    VALUE error;
+    switch (PQresultStatus(result)) {
+        case PGRES_TUPLES_OK:
+        case PGRES_COPY_OUT:
+        case PGRES_COPY_IN:
+        case PGRES_EMPTY_QUERY:
+        case PGRES_COMMAND_OK:
+            break;
+        case PGRES_BAD_RESPONSE:
+        case PGRES_FATAL_ERROR:
+        case PGRES_NONFATAL_ERROR:
+            error = rb_str_new2(PQresultErrorMessage(result));
+            PQclear(result);
+            rb_raise(strstr(CSTRING(error), "bind message") ? eSwiftArgumentError : eSwiftRuntimeError, "%s", CSTRING(error));
+            break;
+        default:
+            PQclear(result);
+            rb_raise(eSwiftRuntimeError, "unknown error, check logs");
+    }
+}

data/ext/swift/db/postgres/common.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#define DLL_PRIVATE __attribute__ ((visibility ("hidden")))
+#define CONST_GET(scope, constant) rb_funcall(scope, rb_intern("const_get"), 1, rb_str_new2(constant))
+#define TO_S(v)    rb_funcall(v, rb_intern("to_s"), 0)
+#define CSTRING(v) RSTRING_PTR(TO_S(v))
+
+#include <ruby/ruby.h>
+#include <ruby/encoding.h>
+
+#include <libpq-fe.h>
+#include <libpq/libpq-fs.h>
+
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+extern VALUE mSwift, mDB;
+extern VALUE cDPA, cDPS, cDPR;
+extern VALUE eSwiftError, eSwiftArgumentError, eSwiftRuntimeError, eSwiftConnectionError;
+extern VALUE cStringIO;
+
+DLL_PRIVATE VALUE rb_uuid_string();
+DLL_PRIVATE VALUE db_postgres_normalized_sql(VALUE);
+DLL_PRIVATE void  db_postgres_check_result(PGresult *);
+
+typedef struct Query {
+    PGconn *connection;
+    char *command;
+    int n_args;
+    char **data;
+    int *size, *format;
+} Query;

data/ext/swift/db/postgres/datetime.c

@@ -0,0 +1,99 @@
+#include "datetime.h"
+#include <ctype.h>
+
+extern VALUE dtformat;
+
+VALUE cSwiftDateTime, day_seconds;
+ID fcivil, fparse, fstrptime;
+
+// NOTE: only parses '%F %T.%N %z' format and falls back to the built-in DateTime#parse
+//       and is almost 2x faster than doing:
+//
+//       rb_funcall(klass, fstrptime, 2, rb_str_new(data, size), dtformat);
+//
+VALUE datetime_parse(VALUE klass, const char *data, size_t size) {
+  struct tm tm;
+  double seconds;
+  const char *ptr;
+  char tzsign = 0, fraction[32];
+  int  tzhour = 0, tzmin = 0, lastmatch = -1, offset = 0, idx;
+
+  memset(&tm, 0, sizeof(struct tm));
+  sscanf(data, "%04d-%02d-%02d %02d:%02d:%02d%n",
+      &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec, &lastmatch);
+
+  // fallback to default datetime parser, this is more expensive.
+  if (tm.tm_mday == 0)
+    return Qnil;
+
+  seconds = tm.tm_sec;
+
+  // parse millisecs if any -- tad faster than using %lf in sscanf above.
+  if (lastmatch > 0 && lastmatch < (int)size && *(data + lastmatch) == '.') {
+      idx = 0;
+      ptr = data + ++lastmatch;
+      while (*ptr && isdigit(*ptr) && idx < 31) {
+        lastmatch++;
+        fraction[idx++] = *ptr++;
+      }
+
+      fraction[idx] = 0;
+      seconds += (double)atoll(fraction) / pow(10, idx);
+  }
+
+  // parse timezone offsets if any - matches +HH:MM +HH MM +HHMM
+  if (lastmatch > 0 && lastmatch < (int)size) {
+    const char *ptr = data + lastmatch;
+    while(*ptr && *ptr != '+' && *ptr != '-') ptr++;
+    tzsign = *ptr++;
+    if (*ptr && isdigit(*ptr)) {
+      tzhour = *ptr++ - '0';
+      if (*ptr && isdigit(*ptr)) tzhour = tzhour * 10 + *ptr++ - '0';
+      while(*ptr && !isdigit(*ptr)) ptr++;
+      if (*ptr) {
+        tzmin = *ptr++ - '0';
+        if (*ptr && isdigit(*ptr)) tzmin = tzmin * 10 + *ptr++ - '0';
+      }
+    }
+  }
+
+  if (tzsign) {
+    offset = tzsign == '+'
+      ? (time_t)tzhour *  3600 + (time_t)tzmin *  60
+      : (time_t)tzhour * -3600 + (time_t)tzmin * -60;
+  }
+
+  return rb_funcall(klass, fcivil, 7,
+    INT2FIX(tm.tm_year), INT2FIX(tm.tm_mon), INT2FIX(tm.tm_mday),
+    INT2FIX(tm.tm_hour), INT2FIX(tm.tm_min), DBL2NUM(seconds),
+    offset == 0 ? INT2FIX(0) : rb_Rational(INT2FIX(offset), day_seconds)
+  );
+}
+
+VALUE rb_datetime_parse(VALUE self, VALUE string) {
+  VALUE datetime;
+  const char *data = CSTRING(string);
+  size_t size = TYPE(string) == T_STRING ? (size_t)RSTRING_LEN(string) : strlen(data);
+
+  if (NIL_P(string))
+    return Qnil;
+
+  datetime = datetime_parse(self, data, size);
+  return NIL_P(datetime) ? rb_call_super(1, &string) : datetime;
+}
+
+void init_swift_datetime() {
+  VALUE mSwift, cDateTime;
+
+  rb_require("date");
+  mSwift          = rb_define_module("Swift");
+  cDateTime       = CONST_GET(rb_mKernel, "DateTime");
+  cSwiftDateTime  = rb_define_class_under(mSwift, "DateTime", cDateTime);
+  fcivil          = rb_intern("civil");
+  fparse          = rb_intern("parse");
+  fstrptime       = rb_intern("strptime");
+  day_seconds     = INT2FIX(86400);
+
+  rb_global_variable(&day_seconds);
+  rb_define_singleton_method(cSwiftDateTime, "parse", RUBY_METHOD_FUNC(rb_datetime_parse), 1);
+}

data/ext/swift/db/postgres/datetime.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include "common.h"
+#include <math.h>
+
+DLL_PRIVATE extern VALUE cSwiftDateTime;
+DLL_PRIVATE void init_swift_datetime();
+DLL_PRIVATE VALUE datetime_parse(VALUE klass, const char *data, size_t size);

data/ext/swift/db/postgres/extconf.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+require 'mkmf'
+
+$CFLAGS = '-std=c99'
+
+inc_paths = %w(
+  /usr/include/postgresql
+  /usr/local/include/postgresql
+  /opt/local/include
+  /opt/local/include/postgresql90
+  /opt/local/include/postgresql85
+  /opt/local/include/postgresql84
+  /sw/include
+)
+
+lib_paths = %w(
+  /usr/lib
+  /usr/local/lib
+  /opt/lib
+  /opt/local/lib
+  /sw/lib
+)
+
+(inc_paths << ENV['SPG_INCLUDE_DIRS']).compact!
+(lib_paths << ENV['SPG_LIBRARY_DIRS']).compact!
+
+find_header('libpq-fe.h',  *inc_paths) or raise 'unable to locate postgresql headers set SPG_INCLUDE_DIRS'
+find_header('uuid/uuid.h', *inc_paths) or raise 'unable to locate uuid headers set SPG_INCLUDE_DIRS'
+
+find_library('pq',  'main', *lib_paths) or raise 'unable to locate postgresql lib set SPG_LIBRARY_DIRS'
+find_library('uuid','main', *lib_paths) or raise 'unable to locate uuid lib set SPG_LIBRARY_DIRS'
+create_makefile('swift_db_postgres_ext')

data/ext/swift/db/postgres/main.c

@@ -0,0 +1,28 @@
+// vim:ts=4:sts=4:sw=4:expandtab
+
+// (c) Bharanee Rathna 2012
+
+#include "common.h"
+#include "adapter.h"
+#include "statement.h"
+#include "result.h"
+#include "datetime.h"
+
+VALUE mSwift, mDB;
+VALUE eSwiftError, eSwiftArgumentError, eSwiftRuntimeError, eSwiftConnectionError;
+
+void Init_swift_db_postgres_ext() {
+    mSwift = rb_define_module("Swift");
+    mDB    = rb_define_module_under(mSwift, "DB");
+
+    eSwiftError           = rb_define_class_under(mSwift, "Error",           rb_eStandardError);
+    eSwiftArgumentError   = rb_define_class_under(mSwift, "ArgumentError",   eSwiftError);
+    eSwiftRuntimeError    = rb_define_class_under(mSwift, "RuntimeError",    eSwiftError);
+    eSwiftConnectionError = rb_define_class_under(mSwift, "ConnectionError", eSwiftError);
+
+    init_swift_db_postgres_adapter();
+    init_swift_db_postgres_statement();
+    init_swift_db_postgres_result();
+    init_swift_datetime();
+    init_swift_db_postgres_typecast();
+}

data/ext/swift/db/postgres/result.c

@@ -0,0 +1,172 @@
+// vim:ts=4:sts=4:sw=4:expandtab
+
+// (c) Bharanee Rathna 2012
+
+#include "result.h"
+#include <stdlib.h>
+
+/* declaration */
+
+typedef struct Result {
+    PGresult *result;
+    VALUE fields;
+    VALUE types;
+    VALUE rows;
+    size_t selected;
+    size_t affected;
+    size_t insert_id;
+} Result;
+
+VALUE cDPR;
+
+/* definition */
+
+Result* db_postgres_result_handle(VALUE self) {
+    Result *r;
+    Data_Get_Struct(self, Result, r);
+    if (!r)
+        rb_raise(eSwiftRuntimeError, "Invalid postgres result");
+    return r;
+}
+
+void db_postgres_result_mark(Result *r) {
+    if (r) {
+        if (r->fields)
+            rb_gc_mark_maybe(r->fields);
+        if (r->types)
+            rb_gc_mark_maybe(r->types);
+        if (r->rows)
+            rb_gc_mark_maybe(r->rows);
+    }
+}
+
+VALUE db_postgres_result_deallocate(Result *r) {
+    if (r) {
+        if (r->result)
+            PQclear(r->result);
+        free(r);
+    }
+}
+
+VALUE db_postgres_result_allocate(VALUE klass) {
+    Result *r = (Result*)malloc(sizeof(Result));
+    memset(r, 0, sizeof(Result));
+    return Data_Wrap_Struct(klass, db_postgres_result_mark, db_postgres_result_deallocate, r);
+}
+
+VALUE db_postgres_result_load(VALUE self, PGresult *result) {
+    size_t n, rows, cols;
+    const char *type, *data;
+
+    Result *r    = db_postgres_result_handle(self);
+    r->fields    = rb_ary_new();
+    r->types     = rb_ary_new();
+    r->rows      = rb_ary_new();
+    r->result    = result;
+    r->affected  = atol(PQcmdTuples(result));
+    r->selected  = PQntuples(result);
+    r->insert_id = 0;
+
+    rows = PQntuples(result);
+    cols = PQnfields(result);
+    if (rows > 0)
+        r->insert_id = PQgetisnull(result, 0, 0) ? 0 : atol(PQgetvalue(result, 0, 0));
+
+    for (n = 0; n < cols; n++) {
+        /* this must be a command execution result without field information */
+        if (!(data = PQfname(result, n)))
+            break;
+        rb_ary_push(r->fields, ID2SYM(rb_intern(data)));
+
+        switch (PQftype(result, n)) {
+            case   16: rb_ary_push(r->types, INT2NUM(SWIFT_TYPE_BOOLEAN)); break;
+            case   17: rb_ary_push(r->types, INT2NUM(SWIFT_TYPE_BLOB)); break;
+            case   20:
+            case   21:
+            case   23: rb_ary_push(r->types, INT2NUM(SWIFT_TYPE_INT)); break;
+            case   25: rb_ary_push(r->types, INT2NUM(SWIFT_TYPE_TEXT)); break;
+            case  700:
+            case  701: rb_ary_push(r->types, INT2NUM(SWIFT_TYPE_FLOAT)); break;
+            case 1082: rb_ary_push(r->types, INT2NUM(SWIFT_TYPE_DATE)); break;
+            case 1114:
+            case 1184: rb_ary_push(r->types, INT2NUM(SWIFT_TYPE_TIMESTAMP)); break;
+            case 1700: rb_ary_push(r->types, INT2NUM(SWIFT_TYPE_NUMERIC)); break;
+            case 1083:
+            case 1266: rb_ary_push(r->types, INT2NUM(SWIFT_TYPE_TIME)); break;
+              default: rb_ary_push(r->types, INT2NUM(SWIFT_TYPE_TEXT));
+        }
+    }
+
+    return self;
+}
+
+VALUE db_postgres_result_each(VALUE self) {
+    int row, col;
+    Result *r = db_postgres_result_handle(self);
+
+    if (!r->result)
+        return Qnil;
+
+    for (row = 0; row < PQntuples(r->result); row++) {
+        VALUE tuple = rb_hash_new();
+        for (col = 0; col < PQnfields(r->result); col++) {
+            if (PQgetisnull(r->result, row, col))
+                rb_hash_aset(tuple, rb_ary_entry(r->fields, col), Qnil);
+            else {
+                rb_hash_aset(
+                    tuple,
+                    rb_ary_entry(r->fields, col),
+                    typecast_detect(
+                        PQgetvalue(r->result, row, col),
+                        PQgetlength(r->result, row, col),
+                        NUM2INT(rb_ary_entry(r->types, col))
+                    )
+                );
+            }
+        }
+        rb_yield(tuple);
+    }
+    return Qtrue;
+}
+
+VALUE db_postgres_result_selected_rows(VALUE self) {
+    Result *r = db_postgres_result_handle(self);
+    return SIZET2NUM(r->selected);
+}
+
+VALUE db_postgres_result_affected_rows(VALUE self) {
+    Result *r = db_postgres_result_handle(self);
+    return SIZET2NUM(r->selected > 0 ? 0 : r->affected);
+}
+
+VALUE db_postgres_result_fields(VALUE self) {
+    Result *r = db_postgres_result_handle(self);
+    return r->fields ? r->fields : rb_ary_new();
+}
+
+VALUE db_postgres_result_types(VALUE self) {
+    Result *r = db_postgres_result_handle(self);
+    return r->types ? typecast_description(r->types) : rb_ary_new();
+}
+
+VALUE db_postgres_result_insert_id(VALUE self) {
+    Result *r = db_postgres_result_handle(self);
+    return SIZET2NUM(r->insert_id);
+}
+
+void init_swift_db_postgres_result() {
+    rb_require("bigdecimal");
+    rb_require("stringio");
+    rb_require("date");
+
+    cDPR = rb_define_class_under(cDPA, "Result", rb_cObject);
+
+    rb_include_module(cDPR, rb_mEnumerable);
+    rb_define_alloc_func(cDPR, db_postgres_result_allocate);
+    rb_define_method(cDPR, "each",          db_postgres_result_each,          0);
+    rb_define_method(cDPR, "selected_rows", db_postgres_result_selected_rows, 0);
+    rb_define_method(cDPR, "affected_rows", db_postgres_result_affected_rows, 0);
+    rb_define_method(cDPR, "fields",        db_postgres_result_fields,        0);
+    rb_define_method(cDPR, "types",         db_postgres_result_types,         0);
+    rb_define_method(cDPR, "insert_id",     db_postgres_result_insert_id,     0);
+}