mysql_blob_streaming 1.1.3 → 2.0.0

data/README.markdown

@@ -1,6 +1,6 @@
-# A blob streaming extension for the native Ruby-MySQL adaptor.
+# A blob streaming extension for the native Ruby-MySQL2 adaptor.
 
-It provides the module MysqlBlobStreaming, which gives the adaptor the ability
+It provides the module MysqlBlobStreaming, which gives the mysql2 adaptor the ability
 of streaming blobs right out of the MySQL database.
 
 (c) 2008-2012 Infopark AG. See MIT-LICENSE for licensing details.
@@ -9,7 +9,7 @@ of streaming blobs right out of the MySQL database.
 
   * Ruby-headers
   * MySQL-headers
-  * [Native Ruby-MySQL adaptor](http://www.tmtm.org/en/mysql/ruby)
+  * [mysql2 Gem](https://rubygems.org/gems/mysql2)
 
 ## Building
 

data/ext/mysql_blob_streaming/mysql_blob_streaming.c

@@ -4,60 +4,143 @@
 #include <mysql.h>
 #include <errmsg.h>
 
-struct mysql_stmt {
-    MYSQL_STMT *stmt;
-    char closed;
-    struct {
-        int n;
-        MYSQL_BIND *bind;
-        unsigned long *length;
-        MYSQL_TIME *buffer;
-    } param;
-    struct {
-        int n;
-        MYSQL_BIND *bind;
-        my_bool *is_null;
-        unsigned long *length;
-    } result;
-    MYSQL_RES *res;
-};
-
-
-static void store_buffer(struct mysql_stmt *s, int offset_index, VALUE obj)
+
+typedef struct {
+  VALUE encoding;
+  int active;
+  int reconnect_enabled;
+  int closed;
+  MYSQL *client;
+} mysql_client_wrapper;
+
+
+static MYSQL * mysql_connection(VALUE rb_mysql2_client)
+{
+    mysql_client_wrapper *wrapper;
+    Data_Get_Struct(rb_mysql2_client, mysql_client_wrapper, wrapper);
+    return wrapper->client;
+}
+
+
+static MYSQL_STMT * prepare_and_execute_stmt_with_query(MYSQL *conn, char *query)
 {
-    int status = mysql_stmt_fetch_column(s->stmt, s->result.bind, 0, offset_index);
+    MYSQL_STMT *stmt = mysql_stmt_init(conn);
+    if (stmt == NULL) {
+        rb_raise(rb_eRuntimeError, "Could not initialize prepared statement!");
+    }
+
+    int prepare_error = mysql_stmt_prepare(stmt, query, strlen(query));
+    if (prepare_error) {
+        rb_raise(rb_eRuntimeError, "Could not prepare statement! Error Code: %d", prepare_error);
+    }
+
+    long nr_params = mysql_stmt_param_count(stmt);
+    if (nr_params) {
+        rb_raise(rb_eRuntimeError, "Query contains %lu placeholders. 0 are allowed!", nr_params);
+    }
+
+    int exec_code = mysql_stmt_execute(stmt);
+    if (exec_code) {
+        rb_raise(rb_eRuntimeError, "Could not execute statement. MySQL error code: %d", exec_code);
+    }
+
+    return stmt;
+}
+
+
+static void store_buffer(MYSQL_STMT *stmt, int offset_index, MYSQL_BIND *bind, int chunk_length, VALUE block, VALUE obj)
+{
+    int status = mysql_stmt_fetch_column(stmt, bind, 0, offset_index);
     if (status != 0) {
         rb_raise(rb_eRuntimeError, "Fetching column failed");
     }
-    if (!s->result.is_null[0]) {
-        if (s->result.bind[0].buffer_type == MYSQL_TYPE_BLOB) {
-            rb_funcall(obj, rb_intern("handle_data"), 1, rb_str_new(s->result.bind[0].buffer,
-                    s->result.bind[0].buffer_length));
+    if (!*bind->is_null) {
+        if (bind->buffer_type == MYSQL_TYPE_BLOB) {
+            if(RTEST(block)) {
+                rb_funcall(block, rb_intern("call"), 1, rb_str_new(bind->buffer, chunk_length));
+            } else {
+                rb_raise(rb_eArgError, "a block is required");
+            }
         } else {
             rb_raise(rb_eRuntimeError, "wrong buffer_type (must be: MYSQL_TYPE_BLOB): %d",
-                    s->result.bind[0].buffer_type);
+                    bind->buffer_type);
         }
     }
 }
 
 
-static int determine_blob_length(struct mysql_stmt *s)
+static int determine_blob_length(MYSQL_STMT *stmt, MYSQL_BIND *bind)
 {
-    s->result.bind[0].buffer_length = 0;
-    if (mysql_stmt_bind_result(s->stmt, s->result.bind) != 0) {
-        rb_raise(rb_eRuntimeError, "Could not determine the blob length: bind failed");
+    int original_buffer_length = bind->buffer_length;
+    bind->buffer_length = 0;
+
+    if (mysql_stmt_bind_result(stmt, bind) != 0) {
+        rb_raise(rb_eRuntimeError, "determine_blob_length2 Could not determine the blob length: bind failed");
     }
-    int status = mysql_stmt_fetch(s->stmt);
+    int status = mysql_stmt_fetch(stmt);
     // MYSQL_DATA_TRUNCATED is returned if MYSQL_REPORT_DATA_TRUNCATION connection option is set
     if (status != 0 && status != MYSQL_DATA_TRUNCATED) {
-        rb_raise(rb_eRuntimeError, "Could not determine the blob length: fetch failed");
+        rb_raise(rb_eRuntimeError, "determine_blob_length2 Could not determine the blob length: fetch failed");
+    }
+
+    bind->buffer_length = original_buffer_length;
+    return *bind->length;
+}
+
+
+static void loop_store_buffer(MYSQL_STMT *stmt, MYSQL_BIND *bind, int total_blob_length, VALUE block, VALUE obj)
+{
+    long loops = abs(total_blob_length / bind->buffer_length);
+    long i;
+    for (i = 0; i < loops; ++i) {
+        store_buffer(stmt, i * bind->buffer_length, bind, bind->buffer_length, block, obj);
+    }
+    int new_bufflen = total_blob_length % bind->buffer_length;
+    if (new_bufflen) {
+        store_buffer(stmt, loops * bind->buffer_length, bind, new_bufflen, block, obj);
+    }
+}
+
+
+static MYSQL_BIND * build_result_bind(MYSQL_STMT *stmt, int buffer_length)
+{
+    MYSQL_BIND *bind = (MYSQL_BIND *)calloc(1, sizeof(MYSQL_BIND));
+    bind->length = (unsigned long *)calloc(1, sizeof(unsigned long));
+    bind->is_null = (my_bool *)calloc(1, sizeof(my_bool));
+    bind->buffer_length = buffer_length;
+    bind->buffer = malloc(buffer_length);
+
+    MYSQL_RES *result_set = mysql_stmt_result_metadata(stmt);
+    if ((result_set != NULL) && (mysql_num_fields(result_set) >= 1)) {
+        MYSQL_FIELD *columns = mysql_fetch_fields(result_set);
+        bind->buffer_type = columns->type;
     }
-    return *s->result.bind[0].length;
+
+    return bind;
 }
 
 
-static VALUE stmt_fetch_and_write(VALUE obj, VALUE rb_buffer_length)
+static void free_result_bind(MYSQL_BIND *bind)
 {
+    if (bind != NULL) {
+        free(bind->buffer);
+        free(bind->length);
+        free(bind->is_null);
+        free(bind);
+    }
+}
+
+
+// ruby interface:
+// MysqlBlobStreaming.stream(mysql2_client, query, buffer_length, &block)
+static VALUE stmt_fetch_and_write(int argc, VALUE *argv, VALUE self)
+{
+    VALUE rb_mysql2_client;
+    VALUE rb_query;
+    VALUE rb_buffer_length;
+    VALUE rb_block;
+    rb_scan_args(argc, argv, "3&", &rb_mysql2_client, &rb_query, &rb_buffer_length, &rb_block);
+
     int buffer_length = FIX2INT(rb_buffer_length);
 
     if (buffer_length == 0) {
@@ -67,32 +150,23 @@ static VALUE stmt_fetch_and_write(VALUE obj, VALUE rb_buffer_length)
         rb_raise(rb_eRuntimeError, "buffer size must be integer >= 0");
     }
 
-    struct mysql_stmt *s = DATA_PTR(obj);
-    int blob_length = determine_blob_length(s);
-
-    s->result.bind[0].buffer_length = buffer_length;
-    if (blob_length <= s->result.bind[0].buffer_length) {
-        s->result.bind[0].buffer_length = blob_length;
-        store_buffer(s, 0, obj);
-    } else {
-        long loops = abs(blob_length / s->result.bind[0].buffer_length);
-        long i;
-        for (i = 0; i < loops; ++i) {
-            store_buffer(s, i * s->result.bind[0].buffer_length, obj);
-        }
-        int old_bufflen = s->result.bind[0].buffer_length;
-        int new_bufflen = blob_length % s->result.bind[0].buffer_length;
-        if (new_bufflen) {
-            s->result.bind[0].buffer_length = new_bufflen;
-            store_buffer(s, loops * old_bufflen, obj);
-        }
-    }
+    char *query = RSTRING_PTR(rb_query);
+
+    MYSQL *conn = mysql_connection(rb_mysql2_client);
+    MYSQL_STMT *stmt = prepare_and_execute_stmt_with_query(conn, query);
+    MYSQL_BIND *bind = build_result_bind(stmt, buffer_length);
+
+    int total_blob_length = determine_blob_length(stmt, bind);
+    loop_store_buffer(stmt, bind, total_blob_length, rb_block, self);
+
+    mysql_stmt_close(stmt);
+    free_result_bind(bind);
     return Qnil;
 }
 
 
 void Init_mysql_blob_streaming()
 {
-    VALUE rb_mMysqlBlobStreaming = rb_define_module("MysqlBlobStreaming");
-    rb_define_method(rb_mMysqlBlobStreaming, "stream", stmt_fetch_and_write, 1);
+    VALUE rb_mMysqlBlobStreaming = rb_define_class("MysqlBlobStreaming", rb_cObject);
+    rb_define_singleton_method(rb_mMysqlBlobStreaming, "stream", stmt_fetch_and_write, -1);
 }

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mysql_blob_streaming
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 15
   prerelease: 
   segments: 
-  - 1
-  - 1
-  - 3
-  version: 1.1.3
+  - 2
+  - 0
+  - 0
+  version: 2.0.0
 platform: ruby
 authors: 
 - Infopark AG
@@ -15,21 +15,23 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-07-12 00:00:00 Z
+date: 2013-01-14 00:00:00 +01:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: mysql
+  name: mysql2
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - "="
       - !ruby/object:Gem::Version 
-        hash: 13
+        hash: 5
         segments: 
-        - 2
-        - 7
-        version: "2.7"
+        - 0
+        - 3
+        - 11
+        version: 0.3.11
   type: :runtime
   version_requirements: *id001
 description: "    This GEM is required by the Infopark Rails Connector (RC) when using MySQL.\n"
@@ -45,9 +47,10 @@ files:
 - ext/mysql_blob_streaming/mysql_blob_streaming.c
 - ext/mysql_blob_streaming/extconf.rb
 - README.markdown
+has_rdoc: true
 homepage: http://www.infopark.de/
-licenses: []
-
+licenses: 
+- MIT
 post_install_message: 
 rdoc_options: 
 - --main
@@ -77,9 +80,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: 
 - Infopark Rails Connector (RC)
 rubyforge_project: 
-rubygems_version: 1.8.21
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
-summary: A blob streaming extension for the native Ruby-MySQL adapter
+summary: A blob streaming extension for the native Ruby-MySQL2 adapter
 test_files: []