swift-db-postgres 0.1.0

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

@@ -0,0 +1,10 @@
+// vim:ts=4:sts=4:sw=4:expandtab
+
+// (c) Bharanee Rathna 2012
+
+#pragma once
+
+#include "common.h"
+#include "typecast.h"
+
+void init_swift_db_postgres_result();

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

@@ -0,0 +1,169 @@
+// vim:ts=4:sts=4:sw=4:expandtab
+
+// (c) Bharanee Rathna 2012
+
+#include "statement.h"
+#include "adapter.h"
+#include "typecast.h"
+
+/* declaration */
+
+VALUE cDPS;
+
+VALUE    db_postgres_result_allocate(VALUE);
+VALUE    db_postgres_result_load(VALUE, PGresult*);
+Adapter* db_postgres_adapter_handle_safe(VALUE);
+
+typedef struct Statement {
+    char id[64];
+    VALUE adapter;
+} Statement;
+
+/* definition */
+
+Statement* db_postgres_statement_handle(VALUE self) {
+    Statement *s;
+    Data_Get_Struct(self, Statement, s);
+    if (!s)
+        rb_raise(eSwiftRuntimeError, "Invalid postgres statement");
+    return s;
+}
+
+Statement* db_postgres_statement_handle_safe(VALUE self) {
+    Statement *s = db_postgres_statement_handle(self);
+    if (!s->adapter)
+        rb_raise(eSwiftRuntimeError, "Invalid postgres statement: no associated adapter");
+    return s;
+}
+
+void db_postgres_statement_mark(Statement *s) {
+    if (s && s->adapter)
+        rb_gc_mark_maybe(s->adapter);
+}
+
+VALUE db_postgres_statement_deallocate(Statement *s) {
+    if (s)
+        free(s);
+}
+
+VALUE db_postgres_statement_allocate(VALUE klass) {
+    Statement *s = (Statement*)malloc(sizeof(Statement));
+    memset(s, 0, sizeof(Statement));
+    return Data_Wrap_Struct(klass, db_postgres_statement_mark, db_postgres_statement_deallocate, s);
+}
+
+VALUE db_postgres_statement_initialize(VALUE self, VALUE adapter, VALUE sql) {
+    PGresult *result;
+    PGconn *connection;
+    Statement *s = db_postgres_statement_handle(self);
+
+    snprintf(s->id, 64, "s%s", CSTRING(rb_uuid_string()));
+    s->adapter = adapter;
+    rb_gc_mark(s->adapter);
+
+    connection = db_postgres_adapter_handle_safe(adapter)->connection;
+    result     = PQprepare(connection, s->id, CSTRING(db_postgres_normalized_sql(sql)), 0, 0);
+
+    db_postgres_check_result(result);
+    PQclear(result);
+    return self;
+}
+
+VALUE db_postgres_statement_release(VALUE self) {
+    char command[128];
+    PGresult *result;
+    PGconn *connection;
+
+    Statement *s = db_postgres_statement_handle_safe(self);
+    connection   = db_postgres_adapter_handle_safe(s->adapter)->connection;
+
+    if (connection && PQstatus(connection) == CONNECTION_OK) {
+        snprintf(command, 128, "deallocate %s", s->id);
+        result = PQexec(connection, command);
+        db_postgres_check_result(result);
+        PQclear(result);
+        return Qtrue;
+    }
+
+    return Qfalse;
+}
+
+VALUE nogvl_pq_exec_prepared(void *ptr) {
+    Query *q = (Query *)ptr;
+    return (VALUE)PQexecPrepared(q->connection, q->command, q->n_args, (const char * const *)q->data, q->size, q->format, 0);
+}
+
+VALUE db_postgres_statement_execute(int argc, VALUE *argv, VALUE self) {
+    PGresult *result;
+    PGconn *connection;
+    char **bind_args_data = 0;
+    int n, *bind_args_size = 0, *bind_args_fmt = 0;
+    VALUE bind, data;
+
+    Statement *s = db_postgres_statement_handle_safe(self);
+    connection   = db_postgres_adapter_handle_safe(s->adapter)->connection;
+
+    rb_scan_args(argc, argv, "00*", &bind);
+
+    if (RARRAY_LEN(bind) > 0) {
+        bind_args_size = (int   *) malloc(sizeof(int)    * RARRAY_LEN(bind));
+        bind_args_fmt  = (int   *) malloc(sizeof(int)    * RARRAY_LEN(bind));
+        bind_args_data = (char **) malloc(sizeof(char *) * RARRAY_LEN(bind));
+
+        for (n = 0; n < RARRAY_LEN(bind); n++) {
+            data = rb_ary_entry(bind, n);
+            if (NIL_P(data)) {
+                bind_args_size[n] = 0;
+                bind_args_data[n] = 0;
+                bind_args_fmt[n]  = 0;
+            }
+            else {
+                if (rb_obj_is_kind_of(data, rb_cIO) || rb_obj_is_kind_of(data, cStringIO))
+                    bind_args_fmt[n] = 1;
+                else
+                    bind_args_fmt[n] = 0;
+                data = typecast_to_string(data);
+                bind_args_size[n] = RSTRING_LEN(data);
+                bind_args_data[n] = RSTRING_PTR(data);
+            }
+        }
+
+        Query q = {
+            .connection = connection,
+            .command    = s->id,
+            .n_args     = RARRAY_LEN(bind),
+            .data       = bind_args_data,
+            .size       = bind_args_size,
+            .format     = bind_args_fmt
+        };
+
+        result = (PGresult *)rb_thread_blocking_region(nogvl_pq_exec_prepared, &q, RUBY_UBF_IO, 0);
+        free(bind_args_fmt);
+        free(bind_args_size);
+        free(bind_args_data);
+    }
+    else {
+        Query q = {
+            .connection = connection,
+            .command    = s->id,
+            .n_args     = 0,
+            .data       = 0,
+            .size       = 0,
+            .format     = 0
+        };
+        result = (PGresult *)rb_thread_blocking_region(nogvl_pq_exec_prepared, &q, RUBY_UBF_IO, 0);
+    }
+
+    db_postgres_check_result(result);
+    return db_postgres_result_load(db_postgres_result_allocate(cDPR), result);
+}
+
+void init_swift_db_postgres_statement() {
+    cDPS = rb_define_class_under(cDPA, "Statement", rb_cObject);
+    rb_define_alloc_func(cDPS, db_postgres_statement_allocate);
+    rb_define_method(cDPS, "initialize", db_postgres_statement_initialize, 2);
+    rb_define_method(cDPS, "execute",    db_postgres_statement_execute,   -1);
+    rb_define_method(cDPS, "release",    db_postgres_statement_release,    0);
+}
+
+

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

@@ -0,0 +1,9 @@
+// vim:ts=4:sts=4:sw=4:expandtab
+
+// (c) Bharanee Rathna 2012
+
+#pragma once
+
+#include "common.h"
+
+void init_swift_db_postgres_statement();

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

@@ -0,0 +1,112 @@
+// vim:ts=4:sts=4:sw=4:expandtab
+
+// (c) Bharanee Rathna 2012
+
+#include "common.h"
+#include "typecast.h"
+#include "datetime.h"
+
+#define date_parse(klass, data,len) rb_funcall(datetime_parse(klass, data, len), fto_date, 0)
+
+ID fnew, fto_date, fstrftime;
+VALUE cBigDecimal, cStringIO;
+VALUE dtformat;
+VALUE cDateTime;
+
+VALUE typecast_string(const char *data, size_t n) {
+    return rb_enc_str_new(data, n, rb_utf8_encoding());
+}
+
+VALUE typecast_detect(const char *data, size_t size, int type) {
+    VALUE value;
+    char *bytea;
+    size_t bytea_len;
+    switch (type) {
+        case SWIFT_TYPE_INT:
+            return rb_cstr2inum(data, 10);
+        case SWIFT_TYPE_FLOAT:
+            return rb_float_new(atof(data));
+        case SWIFT_TYPE_NUMERIC:
+            return rb_funcall(cBigDecimal, fnew, 1, rb_str_new(data, size));
+        case SWIFT_TYPE_BOOLEAN:
+            return (data && (data[0] =='t' || data[0] == '1')) ? Qtrue : Qfalse;
+        case SWIFT_TYPE_BLOB:
+            bytea = PQunescapeBytea(data, &bytea_len);
+            value = rb_str_new(bytea, bytea_len);
+            PQfreemem(bytea);
+            return rb_funcall(cStringIO, fnew, 1, value);
+        case SWIFT_TYPE_TIMESTAMP:
+            return datetime_parse(cSwiftDateTime, data, size);
+        case SWIFT_TYPE_DATE:
+            return date_parse(cSwiftDateTime, data, size);
+        default:
+            return rb_enc_str_new(data, size, rb_utf8_encoding());
+    }
+}
+
+#define TO_UTF8(value) rb_str_encode(value, rb_str_new2("UTF-8"), 0, Qnil)
+#define UTF8_STRING(value) strcmp(rb_enc_get(value)->name, "UTF-8") ? TO_UTF8(value) : value
+
+VALUE typecast_to_string(VALUE value) {
+    switch (TYPE(value)) {
+        case T_STRING:
+            return UTF8_STRING(value);
+        case T_TRUE:
+            return rb_str_new2("1");
+        case T_FALSE:
+            return rb_str_new2("0");
+        default:
+            if (rb_obj_is_kind_of(value, rb_cTime) || rb_obj_is_kind_of(value, cDateTime))
+                return rb_funcall(value, fstrftime, 1, dtformat);
+            else if (rb_obj_is_kind_of(value, rb_cIO) || rb_obj_is_kind_of(value, cStringIO))
+                return rb_funcall(value, rb_intern("read"), 0);
+            else
+                return UTF8_STRING(rb_funcall(value, rb_intern("to_s"), 0));
+    }
+}
+
+VALUE typecast_description(VALUE list) {
+    int n;
+    VALUE types = rb_ary_new();
+
+    for (n = 0; n < RARRAY_LEN(list); n++) {
+        switch (NUM2INT(rb_ary_entry(list, n))) {
+            case SWIFT_TYPE_INT:
+                rb_ary_push(types, rb_str_new2("integer")); break;
+            case SWIFT_TYPE_NUMERIC:
+                rb_ary_push(types, rb_str_new2("numeric")); break;
+            case SWIFT_TYPE_FLOAT:
+                rb_ary_push(types, rb_str_new2("float")); break;
+            case SWIFT_TYPE_BLOB:
+                rb_ary_push(types, rb_str_new2("blob")); break;
+            case SWIFT_TYPE_DATE:
+                rb_ary_push(types, rb_str_new2("date")); break;
+            case SWIFT_TYPE_TIME:
+                rb_ary_push(types, rb_str_new2("time")); break;
+            case SWIFT_TYPE_TIMESTAMP:
+                rb_ary_push(types, rb_str_new2("timestamp")); break;
+            case SWIFT_TYPE_BOOLEAN:
+                rb_ary_push(types, rb_str_new2("boolean")); break;
+            default:
+                rb_ary_push(types, rb_str_new2("text"));
+
+        }
+    }
+    return types;
+}
+
+void init_swift_db_postgres_typecast() {
+    rb_require("bigdecimal");
+    rb_require("stringio");
+    rb_require("date");
+
+    cStringIO   = CONST_GET(rb_mKernel, "StringIO");
+    cBigDecimal = CONST_GET(rb_mKernel, "BigDecimal");
+    cDateTime   = CONST_GET(rb_mKernel, "DateTime");
+    fnew        = rb_intern("new");
+    fto_date    = rb_intern("to_date");
+    fstrftime   = rb_intern("strftime");
+    dtformat    = rb_str_new2("%F %T.%N %z");
+
+    rb_global_variable(&dtformat);
+}

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

@@ -0,0 +1,24 @@
+// vim:ts=4:sts=4:sw=4:expandtab
+
+// (c) Bharanee Rathna 2012
+
+#pragma once
+
+#include "common.h"
+
+#define SWIFT_TYPE_INT       0
+#define SWIFT_TYPE_FLOAT     1
+#define SWIFT_TYPE_NUMERIC   2
+#define SWIFT_TYPE_BOOLEAN   3
+#define SWIFT_TYPE_DATE      4
+#define SWIFT_TYPE_TIME      5
+#define SWIFT_TYPE_TIMESTAMP 6
+#define SWIFT_TYPE_TEXT      7
+#define SWIFT_TYPE_BLOB      8
+#define SWIFT_TYPE_UNKNOWN   9
+
+DLL_PRIVATE VALUE typecast_to_string(VALUE);
+DLL_PRIVATE VALUE typecast_string(const char *, size_t);
+DLL_PRIVATE VALUE typecast_detect(const char *, size_t, int);
+DLL_PRIVATE VALUE typecast_description(VALUE list);
+DLL_PRIVATE void  init_swift_db_postgres_typecast();

data/lib/swift-db-postgres.rb

@@ -0,0 +1 @@
+require 'swift/db/postgres'

data/lib/swift/db/postgres.rb

@@ -0,0 +1 @@
+require 'swift/db/postgres/swift_db_postgres_ext'

data/test/helper.rb

@@ -0,0 +1,8 @@
+require 'minitest/autorun'
+require 'swift/db/postgres'
+
+class MiniTest::Spec
+  def db
+    @db ||= Swift::DB::Postgres.new(db: 'swift_test')
+  end
+end

data/test/test_adapter.rb

@@ -0,0 +1,106 @@
+require 'helper'
+
+ describe 'postgres adapter' do
+  it 'should initialize' do
+    assert db
+  end
+
+  it 'should execute sql' do
+    assert db.execute("select * from pg_tables")
+  end
+
+  it 'should expect the correct number of bind args' do
+    assert_raises(Swift::ArgumentError) { db.execute("select * from pg_tables where tablename = ?", 1, 2) }
+  end
+
+  it 'should return result on #execute' do
+    now = Time.now
+    assert db.execute('drop table if exists users')
+    assert db.execute('create table users (id serial primary key, name text, age integer, created_at timestamp with time zone)')
+    assert db.execute('insert into users(name, age, created_at) values(?, ?, ?)', 'test', nil, now)
+
+    result = db.execute('select * from users')
+
+    assert_equal 1, result.selected_rows
+    assert_equal 0, result.affected_rows
+    assert_equal %w(id name age created_at).map(&:to_sym), result.fields
+    assert_equal %w(integer text integer timestamp), result.types
+
+    row = result.first
+    assert_equal 1,      row[:id]
+    assert_equal 'test', row[:name]
+    assert_equal nil,    row[:age]
+    assert_equal now.to_f.round(3), row[:created_at].to_time.to_f.round(3) # millisecs resolution on postgres
+
+    result = db.execute('delete from users where id = 0')
+    assert_equal 0, result.selected_rows
+    assert_equal 0, result.affected_rows
+
+    assert_equal 1, db.execute('select count(*) as count from users').first[:count]
+
+    result = db.execute('delete from users')
+    assert_equal 0, result.selected_rows
+    assert_equal 1, result.affected_rows
+
+    # empty result should have field & type information
+    result = db.execute('select * from users')
+    assert_equal %w(id name age created_at).map(&:to_sym), result.fields
+    assert_equal %w(integer text integer timestamp), result.types
+  end
+
+  it 'should close handle' do
+    assert !db.closed?
+    assert db.close
+    assert db.closed?
+
+    assert_raises(Swift::ConnectionError) { db.execute("select * from users") }
+  end
+
+  it 'should prepare & release statement' do
+    assert db.execute('drop table if exists users')
+    assert db.execute("create table users(id serial primary key, name text)")
+    assert db.execute("insert into users (name) values (?)", "test")
+    assert s = db.prepare("select * from users where id > ?")
+
+    assert_equal 1, s.execute(0).selected_rows
+    assert_equal 0, s.execute(1).selected_rows
+
+    assert s.release
+    assert_raises(Swift::RuntimeError) { s.execute(1) }
+  end
+
+  it 'should escape whatever' do
+    assert_equal "foo''bar", db.escape("foo'bar")
+  end
+
+  it 'should support #write and #read' do
+    assert db.execute('drop table if exists users')
+    assert db.execute("create table users(id serial primary key, name text)")
+
+    assert_equal 3, db.write('users', %w(name), "foo\nbar\nbaz\n").affected_rows
+    assert_equal 3, db.execute('select count(*) as count from users').first[:count]
+
+    assert db.execute('copy users(name) from stdin')
+    assert_equal 3, db.write("foo\nbar\nbaz\n").affected_rows
+    assert_equal 6, db.execute('select count(*) as count from users').first[:count]
+
+    assert_equal 3, db.write('users', StringIO.new("7\tfoo\n8\tbar\n9\tbaz\n")).affected_rows
+    assert_equal 9, db.execute('select count(*) as count from users').first[:count]
+
+    io = StringIO.new
+    db.execute('copy (select * from users order by id limit 1) to stdout with csv')
+    assert_equal 1, db.read(io).affected_rows
+
+    assert_match %r{1,foo\n}, io.tap(&:rewind).read
+
+    rows = []
+    db.read('users') {|row| rows << row}
+
+    expect = (%w(foo bar baz)*3).zip(1..9).map {|r| r.reverse.join("\t") + "\n"}
+    assert_equal expect, rows
+
+    assert_raises(Swift::RuntimeError) { db.write("foo") }
+    assert_raises(Swift::RuntimeError) { db.write("users", "bar") }
+    assert_raises(Swift::RuntimeError) { db.write("users", %w(name), "bar") }
+  end
+end