swift-db-mysql 0.1.0

data/ext/swift/db/mysql/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_mysql_result();

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

@@ -0,0 +1,145 @@
+// vim:ts=4:sts=4:sw=4:expandtab
+
+// (c) Bharanee Rathna 2012
+
+#include "statement.h"
+#include "adapter.h"
+#include "typecast.h"
+
+/* declaration */
+
+VALUE cDMS;
+
+VALUE    db_mysql_result_allocate(VALUE);
+VALUE    db_mysql_result_from_statement(VALUE, VALUE);
+Adapter* db_mysql_adapter_handle_safe(VALUE);
+
+/* definition */
+
+Statement* db_mysql_statement_handle(VALUE self) {
+    Statement *s;
+    Data_Get_Struct(self, Statement, s);
+    if (!s)
+        rb_raise(eSwiftRuntimeError, "Invalid mysql statement");
+    return s;
+}
+
+Statement* db_mysql_statement_handle_safe(VALUE self) {
+    Statement *s = db_mysql_statement_handle(self);
+    if (!s->statement)
+        rb_raise(eSwiftRuntimeError, "statement already closed or released");
+    return s;
+}
+
+void db_mysql_statement_mark(Statement *s) {
+    if (s && s->adapter)
+        rb_gc_mark_maybe(s->adapter);
+}
+
+VALUE db_mysql_statement_deallocate(Statement *s) {
+    if (s) {
+        if (s->statement)
+            mysql_stmt_close(s->statement);
+        free(s);
+    }
+}
+
+VALUE db_mysql_statement_allocate(VALUE klass) {
+    Statement *s = (Statement*)malloc(sizeof(Statement));
+    memset(s, 0, sizeof(Statement));
+    return Data_Wrap_Struct(klass, db_mysql_statement_mark, db_mysql_statement_deallocate, s);
+}
+
+VALUE db_mysql_statement_initialize(VALUE self, VALUE adapter, VALUE sql) {
+    MYSQL *connection;
+    Statement *s = db_mysql_statement_handle(self);
+
+    s->adapter = adapter;
+    rb_gc_mark(s->adapter);
+
+    connection   = db_mysql_adapter_handle_safe(adapter)->connection;
+    s->statement = mysql_stmt_init(connection);
+    sql          = TO_S(sql);
+
+    if (mysql_stmt_prepare(s->statement, RSTRING_PTR(sql), RSTRING_LEN(sql)) != 0)
+        rb_raise(eSwiftRuntimeError, "%s", mysql_stmt_error(s->statement));
+
+    return self;
+}
+
+VALUE nogvl_mysql_statement_execute(void *ptr) {
+    return (VALUE)mysql_stmt_execute((MYSQL_STMT *)ptr);
+}
+
+VALUE db_mysql_statement_execute(int argc, VALUE *argv, VALUE self) {
+    int n, error;
+    VALUE bind, data, result;
+    MYSQL_BIND *mysql_bind;
+    char MYSQL_BOOL_TRUE = 1, MYSQL_BOOL_FALSE = 0;
+
+    Statement *s = db_mysql_statement_handle_safe(self);
+
+    rb_scan_args(argc, argv, "00*", &bind);
+
+    mysql_stmt_free_result(s->statement);
+    if (RARRAY_LEN(bind) > 0) {
+        n = mysql_stmt_param_count(s->statement);
+        if (RARRAY_LEN(bind) != n)
+            rb_raise(eSwiftArgumentError, "expected %d bind arguments got %d instead", n, RARRAY_LEN(bind));
+        mysql_bind = (MYSQL_BIND *)malloc(sizeof(MYSQL_BIND) * RARRAY_LEN(bind));
+        memset(mysql_bind, 0, sizeof(MYSQL_BIND) * RARRAY_LEN(bind));
+
+        for (n = 0; n < RARRAY_LEN(bind); n++) {
+            data = rb_ary_entry(bind, n);
+            if (NIL_P(data)) {
+                mysql_bind[n].is_null     = &MYSQL_BOOL_TRUE;
+                mysql_bind[n].buffer_type = MYSQL_TYPE_NULL;
+            }
+            else {
+                data = typecast_to_string(data);
+                mysql_bind[n].is_null       = &MYSQL_BOOL_FALSE;
+                mysql_bind[n].buffer_type   = MYSQL_TYPE_STRING;
+                mysql_bind[n].buffer        = RSTRING_PTR(data);
+                mysql_bind[n].buffer_length = RSTRING_LEN(data);
+            }
+        }
+
+        if (mysql_stmt_bind_param(s->statement, mysql_bind) != 0) {
+            free(mysql_bind);
+            rb_raise(eSwiftRuntimeError, mysql_stmt_error(s->statement));
+        }
+
+        error = (int)rb_thread_blocking_region(nogvl_mysql_statement_execute, s->statement, RUBY_UBF_IO, 0);
+        free(mysql_bind);
+    }
+    else {
+        if ((n = mysql_stmt_param_count(s->statement)) > 0)
+            rb_raise(eSwiftArgumentError, "expected %d bind arguments got 0 instead", n);
+        error = (int)rb_thread_blocking_region(nogvl_mysql_statement_execute, s->statement, RUBY_UBF_IO, 0);
+    }
+
+    if (error)
+        rb_raise(eSwiftRuntimeError, mysql_stmt_error(s->statement));
+
+    result = db_mysql_result_allocate(cDMR);
+    return db_mysql_result_from_statement(result, self);
+}
+
+VALUE db_mysql_statement_release(VALUE self) {
+    Statement *s = db_mysql_statement_handle(self);
+    if (s->statement) {
+        mysql_stmt_free_result(s->statement);
+        mysql_stmt_close(s->statement);
+        s->statement = 0;
+        return Qtrue;
+    }
+    return Qfalse;
+}
+
+void init_swift_db_mysql_statement() {
+    cDMS = rb_define_class_under(cDMA, "Statement", rb_cObject);
+    rb_define_alloc_func(cDMS, db_mysql_statement_allocate);
+    rb_define_method(cDMS, "initialize", db_mysql_statement_initialize, 2);
+    rb_define_method(cDMS, "execute",    db_mysql_statement_execute,   -1);
+    rb_define_method(cDMS, "release",    db_mysql_statement_release,    0);
+}

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

@@ -0,0 +1,14 @@
+// vim:ts=4:sts=4:sw=4:expandtab
+
+// (c) Bharanee Rathna 2012
+
+#pragma once
+
+#include "common.h"
+
+typedef struct Statement {
+    MYSQL_STMT *statement;
+    VALUE adapter;
+} Statement;
+
+void init_swift_db_mysql_statement();

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

@@ -0,0 +1,105 @@
+// 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) {
+    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:
+            return rb_funcall(cStringIO, fnew, 1, rb_str_new(data, size));
+        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_mysql_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/mysql/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_mysql_typecast();

data/lib/swift-db-mysql.rb

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

data/lib/swift/db/mysql.rb

@@ -0,0 +1 @@
+require 'swift/db/mysql/swift_db_mysql_ext'

data/test/helper.rb

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

data/test/test_adapter.rb

@@ -0,0 +1,81 @@
+require 'helper'
+
+describe 'mysql adapter' do
+   it 'should initialize' do
+     assert db
+   end
+
+   it 'should execute sql' do
+     assert db.execute("select * from information_schema.tables limit 1")
+   end
+
+   it 'should expect the correct number of bind args' do
+     assert_raises(Swift::ArgumentError) { db.execute("select * from information_schema.tables where table_name = ?", 1, 2) }
+   end
+
+   it 'should return result on #execute' do
+     now = Time.now.utc
+     assert db.execute('drop table if exists users')
+     assert db.execute('create table users (id int auto_increment primary key, name text, age integer, created_at datetime)')
+     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_i, row[:created_at].to_time.to_i
+
+     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
+   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 int auto_increment primary key, name text, created_at datetime)")
+    assert db.execute("insert into users (name, created_at) values (?, ?)", "test", Time.now)
+    assert s = db.prepare("select * from users where id > ? and created_at <= ?")
+
+    assert_equal 0, s.execute(1, Time.now).selected_rows
+    assert_equal 1, s.execute(0, Time.now).selected_rows
+
+    assert s.release
+    assert_raises(Swift::RuntimeError) { s.execute(1, Time.now) }
+  end
+
+  it 'should escape whatever' do
+    assert_equal "foo\\'bar", db.escape("foo'bar")
+  end
+
+  it 'should support #write' do
+    assert db.execute('drop table if exists users')
+    assert db.execute("create table users(id int auto_increment 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_equal 3, db.write('users', StringIO.new("7\tfoo\n8\tbar\n9\tbaz\n")).affected_rows
+    assert_equal 6, db.execute('select count(*) as count from users').first[:count]
+  end
+end

data/test/test_async.rb

@@ -0,0 +1,36 @@
+require 'helper'
+
+describe 'async operations' do
+  it 'can query async and call block with result when ready' do
+    rows = []
+    pool = 3.times.map {Swift::DB::Mysql.new(db: 'swift_test')}
+
+    3.times do |n|
+      Thread.new do
+        pool[n].query("select sleep(#{(3 - n) / 10.0}), #{n + 1} as query_id") {|row| rows << row[:query_id]}
+      end
+    end
+
+    Thread.list.reject {|thread| Thread.current == thread}.each(&:join)
+    assert_equal [3, 2, 1], rows
+  end
+
+  it 'returns and allows IO poll on connection file descriptor' do
+
+    rows = []
+    pool = 3.times.map {Swift::DB::Mysql.new(db: 'swift_test')}
+
+    3.times do |n|
+      Thread.new do
+        pool[n].query("select sleep(#{(3 - n) / 10.0}), #{n + 1} as query_id")
+        IO.select([IO.for_fd(pool[n].fileno)], [], [])
+        rows << pool[n].result.first[:query_id]
+      end
+    end
+
+    Thread.list.reject {|thread| Thread.current == thread}.each(&:join)
+    assert_equal [3, 2, 1], rows
+  end
+end
+
+

data/test/test_encoding.rb

@@ -0,0 +1,32 @@
+require 'helper'
+
+describe 'utf-8 encoding' do
+  before do
+    assert db.execute('drop table if exists users')
+    assert db.execute('create table users (name text)')
+    assert db.execute('alter table users default character set utf8')
+    assert db.execute('alter table users change name name text charset utf8')
+
+    @text = ["King of \u2665s", "\xA1\xB8".force_encoding('euc-jp')]
+  end
+
+  it 'should store and retrieve utf8 characters with Statement#execute' do
+    @text.each do |name|
+      db.prepare('insert into users (name) values(?)').execute(name)
+      value = db.prepare('select * from users limit 1').execute.first[:name]
+      assert_equal Encoding::UTF_8, value.encoding
+      assert_equal name.encode('utf-8'), value
+      db.execute('delete from users')
+    end
+  end
+
+  it 'should store and retrieve utf8 characters Adapter#execute' do
+    @text.each do |name|
+      db.execute('insert into users (name) values(?)', name)
+      value = db.execute('select * from users limit 1').first[:name]
+      assert_equal Encoding::UTF_8, value.encoding
+      assert_equal name.encode('utf-8'), value
+      db.execute('delete from users')
+    end
+  end
+end