extralite-bundle 1.14

data/ext/extralite/common.c

@@ -0,0 +1,347 @@
+#include <stdio.h>
+#include "extralite.h"
+
+static inline VALUE get_column_value(sqlite3_stmt *stmt, int col, int type) {
+  switch (type) {
+    case SQLITE_NULL:
+      return Qnil;
+    case SQLITE_INTEGER:
+      return LL2NUM(sqlite3_column_int64(stmt, col));
+    case SQLITE_FLOAT:
+      return DBL2NUM(sqlite3_column_double(stmt, col));
+    case SQLITE_TEXT:
+      return rb_str_new_cstr((char *)sqlite3_column_text(stmt, col));
+    case SQLITE_BLOB:
+      return rb_str_new((const char *)sqlite3_column_blob(stmt, col), (long)sqlite3_column_bytes(stmt, col));
+    default:
+      rb_raise(cError, "Unknown column type: %d", type);
+  }
+
+  return Qnil;
+}
+
+void bind_parameter_value(sqlite3_stmt *stmt, int pos, VALUE value);
+
+void bind_hash_parameter_values(sqlite3_stmt *stmt, VALUE hash) {
+  VALUE keys = rb_funcall(hash, ID_KEYS, 0);
+  long len = RARRAY_LEN(keys);
+  for (long i = 0; i < len; i++) {
+    VALUE k = RARRAY_AREF(keys, i);
+    VALUE v = rb_hash_aref(hash, k);
+
+    switch (TYPE(k)) {
+      case T_FIXNUM:
+        bind_parameter_value(stmt, NUM2INT(k), v);
+        break;
+      case T_SYMBOL:
+        k = rb_funcall(k, ID_TO_S, 0);
+      case T_STRING:
+        if(RSTRING_PTR(k)[0] != ':') k = rb_str_plus(rb_str_new2(":"), k);
+        int pos = sqlite3_bind_parameter_index(stmt, StringValuePtr(k));
+        bind_parameter_value(stmt, pos, v);
+        break;
+      default:
+        rb_raise(cError, "Cannot bind hash key value idx %ld", i);
+    }
+  }
+  RB_GC_GUARD(keys);
+}
+
+inline void bind_parameter_value(sqlite3_stmt *stmt, int pos, VALUE value) {
+  switch (TYPE(value)) {
+    case T_NIL:
+      sqlite3_bind_null(stmt, pos);
+      return;
+    case T_FIXNUM:
+      sqlite3_bind_int64(stmt, pos, NUM2LL(value));
+      return;
+    case T_FLOAT:
+      sqlite3_bind_double(stmt, pos, NUM2DBL(value));
+      return;
+    case T_TRUE:
+      sqlite3_bind_int(stmt, pos, 1);
+      return;
+    case T_FALSE:
+      sqlite3_bind_int(stmt, pos, 0);
+      return;
+    case T_STRING:
+      sqlite3_bind_text(stmt, pos, RSTRING_PTR(value), RSTRING_LEN(value), SQLITE_TRANSIENT);
+      return;
+    case T_HASH:
+      bind_hash_parameter_values(stmt, value);
+      return;
+    default:
+      rb_raise(cError, "Cannot bind parameter at position %d", pos);
+  }
+}
+
+void bind_all_parameters(sqlite3_stmt *stmt, int argc, VALUE *argv) {
+  for (int i = 0; i < argc; i++) {
+    bind_parameter_value(stmt, i + 1, argv[i]);
+  }
+}
+
+static inline VALUE get_column_names(sqlite3_stmt *stmt, int column_count) {
+  VALUE arr = rb_ary_new2(column_count);
+  for (int i = 0; i < column_count; i++) {
+    VALUE name = ID2SYM(rb_intern(sqlite3_column_name(stmt, i)));
+    rb_ary_push(arr, name);
+  }
+  return arr;
+}
+
+static inline VALUE row_to_hash(sqlite3_stmt *stmt, int column_count, VALUE column_names) {
+  VALUE row = rb_hash_new();
+  for (int i = 0; i < column_count; i++) {
+    VALUE value = get_column_value(stmt, i, sqlite3_column_type(stmt, i));
+    rb_hash_aset(row, RARRAY_AREF(column_names, i), value);
+  }
+  return row;
+}
+
+static inline VALUE row_to_ary(sqlite3_stmt *stmt, int column_count) {
+  VALUE row = rb_ary_new2(column_count);
+  for (int i = 0; i < column_count; i++) {
+    VALUE value = get_column_value(stmt, i, sqlite3_column_type(stmt, i));
+    rb_ary_push(row, value);
+  }
+  return row;
+}
+
+typedef struct {
+  sqlite3 *db;
+  sqlite3_stmt **stmt;
+  const char *str;
+  long len;
+  int rc;
+} prepare_stmt_ctx;
+
+void *prepare_multi_stmt_without_gvl(void *ptr) {
+  prepare_stmt_ctx *ctx = (prepare_stmt_ctx *)ptr;
+  const char *rest = NULL;
+  const char *str = ctx->str;
+  const char *end = ctx->str + ctx->len;
+  while (1) {
+    ctx->rc = sqlite3_prepare_v2(ctx->db, str, end - str, ctx->stmt, &rest);
+    if (ctx->rc) {
+      // error
+      sqlite3_finalize(*ctx->stmt);
+      return NULL;
+    }
+
+    if (rest == end) return NULL;
+
+    // perform current query, but discard its results
+    ctx->rc = sqlite3_step(*ctx->stmt);
+    sqlite3_finalize(*ctx->stmt);
+    switch (ctx->rc) {
+    case SQLITE_BUSY:
+    case SQLITE_ERROR:
+    case SQLITE_MISUSE:
+      return NULL;
+    }
+    str = rest;
+  }
+  return NULL;
+}
+
+/*
+This function prepares a statement from an SQL string containing one or more SQL
+statements. It will release the GVL while the statements are being prepared and
+executed. All statements excluding the last one are executed. The last statement
+is not executed, but instead handed back to the caller for looping over results.
+*/
+void prepare_multi_stmt(sqlite3 *db, sqlite3_stmt **stmt, VALUE sql) {
+  prepare_stmt_ctx ctx = {db, stmt, RSTRING_PTR(sql), RSTRING_LEN(sql), 0};
+  rb_thread_call_without_gvl(prepare_multi_stmt_without_gvl, (void *)&ctx, RUBY_UBF_IO, 0);
+  RB_GC_GUARD(sql);
+
+  switch (ctx.rc) {
+  case 0:
+    return;
+  case SQLITE_BUSY:
+    rb_raise(cBusyError, "Database is busy");
+  case SQLITE_ERROR:
+    rb_raise(cSQLError, "%s", sqlite3_errmsg(db));
+  default:
+    rb_raise(cError, "Invalid return code for prepare_multi_stmt_without_gvl: %d (please open an issue on https://github.com/digital-fabric/extralite)", ctx.rc);
+  }
+}
+
+#define SQLITE_MULTI_STMT -1
+
+void *prepare_single_stmt_without_gvl(void *ptr) {
+  prepare_stmt_ctx *ctx = (prepare_stmt_ctx *)ptr;
+  const char *rest = NULL;
+  const char *str = ctx->str;
+  const char *end = ctx->str + ctx->len;
+
+  ctx->rc = sqlite3_prepare_v2(ctx->db, str, end - str, ctx->stmt, &rest);
+  if (ctx->rc)
+    goto discard_stmt;
+  else if (rest != end) {
+    ctx->rc = SQLITE_MULTI_STMT;
+    goto discard_stmt;
+  }
+  goto end;
+discard_stmt:
+  if (*ctx->stmt) {
+    sqlite3_finalize(*ctx->stmt);
+    *ctx->stmt = NULL;
+  }
+end:
+  return NULL;
+}
+
+void prepare_single_stmt(sqlite3 *db, sqlite3_stmt **stmt, VALUE sql) {
+  prepare_stmt_ctx ctx = {db, stmt, RSTRING_PTR(sql), RSTRING_LEN(sql), 0};
+  rb_thread_call_without_gvl(prepare_single_stmt_without_gvl, (void *)&ctx, RUBY_UBF_IO, 0);
+  RB_GC_GUARD(sql);
+
+  switch (ctx.rc) {
+  case 0:
+    return;
+  case SQLITE_BUSY:
+    rb_raise(cBusyError, "Database is busy");
+  case SQLITE_ERROR:
+    rb_raise(cSQLError, "%s", sqlite3_errmsg(db));
+  case SQLITE_MULTI_STMT:
+    rb_raise(cSQLError, "A prepared statement does not accept SQL strings with multiple queries");
+  default:
+    rb_raise(cError, "Invalid return code for prepare_multi_stmt_without_gvl: %d (please open an issue on https://github.com/digital-fabric/extralite)", ctx.rc);
+  }
+}
+
+struct step_ctx {
+  sqlite3_stmt *stmt;
+  int rc;
+};
+
+void *stmt_iterate_without_gvl(void *ptr) {
+  struct step_ctx *ctx = (struct step_ctx *)ptr;
+  ctx->rc = sqlite3_step(ctx->stmt);
+  return NULL;
+}
+
+static inline int stmt_iterate(sqlite3_stmt *stmt, sqlite3 *db) {
+  struct step_ctx ctx = {stmt, 0};
+  rb_thread_call_without_gvl(stmt_iterate_without_gvl, (void *)&ctx, RUBY_UBF_IO, 0);
+  switch (ctx.rc) {
+    case SQLITE_ROW:
+      return 1;
+    case SQLITE_DONE:
+      return 0;
+    case SQLITE_BUSY:
+      rb_raise(cBusyError, "Database is busy");
+    case SQLITE_ERROR:
+      rb_raise(cSQLError, "%s", sqlite3_errmsg(db));
+    default:
+      rb_raise(cError, "Invalid return code for sqlite3_step: %d (please open an issue on https://github.com/digital-fabric/extralite)", ctx.rc);
+  }
+
+  return 0;
+}
+
+VALUE cleanup_stmt(query_ctx *ctx) {
+  if (ctx->stmt) sqlite3_finalize(ctx->stmt);
+  return Qnil;
+}
+
+VALUE safe_query_hash(query_ctx *ctx) {
+  VALUE result = ctx->self;
+  int yield_to_block = rb_block_given_p();
+  VALUE row;
+  int column_count;
+  VALUE column_names;
+
+  column_count = sqlite3_column_count(ctx->stmt);
+  column_names = get_column_names(ctx->stmt, column_count);
+
+  // block not given, so prepare the array of records to be returned
+  if (!yield_to_block) result = rb_ary_new();
+
+  while (stmt_iterate(ctx->stmt, ctx->sqlite3_db)) {
+    row = row_to_hash(ctx->stmt, column_count, column_names);
+    if (yield_to_block) rb_yield(row); else rb_ary_push(result, row);
+  }
+
+  RB_GC_GUARD(column_names);
+  RB_GC_GUARD(row);
+  RB_GC_GUARD(result);
+  return result;
+}
+
+VALUE safe_query_ary(query_ctx *ctx) {
+  int column_count;
+  VALUE result = ctx->self;
+  int yield_to_block = rb_block_given_p();
+  VALUE row;
+
+  column_count = sqlite3_column_count(ctx->stmt);
+
+  // block not given, so prepare the array of records to be returned
+  if (!yield_to_block) result = rb_ary_new();
+
+  while (stmt_iterate(ctx->stmt, ctx->sqlite3_db)) {
+    row = row_to_ary(ctx->stmt, column_count);
+    if (yield_to_block) rb_yield(row); else rb_ary_push(result, row);
+  }
+
+  RB_GC_GUARD(row);
+  RB_GC_GUARD(result);
+  return result;
+}
+
+VALUE safe_query_single_row(query_ctx *ctx) {
+  int column_count;
+  VALUE row = Qnil;
+  VALUE column_names;
+
+  column_count = sqlite3_column_count(ctx->stmt);
+  column_names = get_column_names(ctx->stmt, column_count);
+
+  if (stmt_iterate(ctx->stmt, ctx->sqlite3_db))
+    row = row_to_hash(ctx->stmt, column_count, column_names);
+
+  RB_GC_GUARD(row);
+  RB_GC_GUARD(column_names);
+  return row;
+}
+
+VALUE safe_query_single_column(query_ctx *ctx) {
+  int column_count;
+  VALUE result = ctx->self;
+  int yield_to_block = rb_block_given_p();
+  VALUE value;
+
+  column_count = sqlite3_column_count(ctx->stmt);
+  if (column_count != 1)
+    rb_raise(cError, "Expected query result to have 1 column");
+
+  // block not given, so prepare the array of records to be returned
+  if (!yield_to_block) result = rb_ary_new();
+
+  while (stmt_iterate(ctx->stmt, ctx->sqlite3_db)) {
+    value = get_column_value(ctx->stmt, 0, sqlite3_column_type(ctx->stmt, 0));
+    if (yield_to_block) rb_yield(value); else rb_ary_push(result, value);
+  }
+
+  RB_GC_GUARD(value);
+  RB_GC_GUARD(result);
+  return result;
+}
+
+VALUE safe_query_single_value(query_ctx *ctx) {
+  int column_count;
+  VALUE value = Qnil;
+
+  column_count = sqlite3_column_count(ctx->stmt);
+  if (column_count != 1)
+    rb_raise(cError, "Expected query result to have 1 column");
+
+  if (stmt_iterate(ctx->stmt, ctx->sqlite3_db))
+    value = get_column_value(ctx->stmt, 0, sqlite3_column_type(ctx->stmt, 0));
+
+  RB_GC_GUARD(value);
+  return value;
+}