sqlite3 1.5.0 → 2.0.2

data/ext/sqlite3/aggregator.c

@@ -31,20 +31,20 @@ typedef struct rb_sqlite3_protected_funcall_args {
 static VALUE
 rb_sqlite3_protected_funcall_body(VALUE protected_funcall_args_ptr)
 {
-  protected_funcall_args_t *args =
-    (protected_funcall_args_t*)protected_funcall_args_ptr;
+    protected_funcall_args_t *args =
+        (protected_funcall_args_t *)protected_funcall_args_ptr;
 
-  return rb_funcall2(args->self, args->method, args->argc, args->params);
+    return rb_funcall2(args->self, args->method, args->argc, args->params);
 }
 
 static VALUE
 rb_sqlite3_protected_funcall(VALUE self, ID method, int argc, VALUE *params,
-                             int* exc_status)
+                             int *exc_status)
 {
-  protected_funcall_args_t args = {
-    .self = self, .method = method, .argc = argc, .params = params
-  };
-  return rb_protect(rb_sqlite3_protected_funcall_body, (VALUE)(&args), exc_status);
+    protected_funcall_args_t args = {
+        .self = self, .method = method, .argc = argc, .params = params
+    };
+    return rb_protect(rb_sqlite3_protected_funcall_body, (VALUE)(&args), exc_status);
 }
 
 /* called in rb_sqlite3_aggregator_step and rb_sqlite3_aggregator_final. It
@@ -54,36 +54,36 @@ rb_sqlite3_protected_funcall(VALUE self, ID method, int argc, VALUE *params,
 static VALUE
 rb_sqlite3_aggregate_instance(sqlite3_context *ctx)
 {
-  VALUE aw = (VALUE) sqlite3_user_data(ctx);
-  VALUE handler_klass = rb_iv_get(aw, "-handler_klass");
-  VALUE inst;
-  VALUE *inst_ptr = sqlite3_aggregate_context(ctx, (int)sizeof(VALUE));
+    VALUE aw = (VALUE) sqlite3_user_data(ctx);
+    VALUE handler_klass = rb_iv_get(aw, "-handler_klass");
+    VALUE inst;
+    VALUE *inst_ptr = sqlite3_aggregate_context(ctx, (int)sizeof(VALUE));
 
-  if (!inst_ptr) {
-    rb_fatal("SQLite is out-of-merory");
-  }
+    if (!inst_ptr) {
+        rb_fatal("SQLite is out-of-merory");
+    }
 
-  inst = *inst_ptr;
+    inst = *inst_ptr;
 
-  if (inst == Qfalse) { /* Qfalse == 0 */
-    VALUE instances = rb_iv_get(aw, "-instances");
-    int exc_status;
+    if (inst == Qfalse) { /* Qfalse == 0 */
+        VALUE instances = rb_iv_get(aw, "-instances");
+        int exc_status;
 
-    inst = rb_class_new_instance(0, NULL, cAggregatorInstance);
-    rb_iv_set(inst, "-handler_instance", rb_sqlite3_protected_funcall(
-      handler_klass, rb_intern("new"), 0, NULL, &exc_status));
-    rb_iv_set(inst, "-exc_status", INT2NUM(exc_status));
+        inst = rb_class_new_instance(0, NULL, cAggregatorInstance);
+        rb_iv_set(inst, "-handler_instance", rb_sqlite3_protected_funcall(
+                      handler_klass, rb_intern("new"), 0, NULL, &exc_status));
+        rb_iv_set(inst, "-exc_status", INT2NUM(exc_status));
 
-    rb_ary_push(instances, inst);
+        rb_ary_push(instances, inst);
 
-    *inst_ptr = inst;
-  }
+        *inst_ptr = inst;
+    }
 
-  if (inst == Qnil) {
-    rb_fatal("SQLite called us back on an already destroyed aggregate instance");
-  }
+    if (inst == Qnil) {
+        rb_fatal("SQLite called us back on an already destroyed aggregate instance");
+    }
 
-  return inst;
+    return inst;
 }
 
 /* called by rb_sqlite3_aggregator_final. Unlinks and frees the
@@ -92,84 +92,84 @@ rb_sqlite3_aggregate_instance(sqlite3_context *ctx)
 static void
 rb_sqlite3_aggregate_instance_destroy(sqlite3_context *ctx)
 {
-  VALUE aw = (VALUE) sqlite3_user_data(ctx);
-  VALUE instances = rb_iv_get(aw, "-instances");
-  VALUE *inst_ptr = sqlite3_aggregate_context(ctx, 0);
-  VALUE inst;
+    VALUE aw = (VALUE) sqlite3_user_data(ctx);
+    VALUE instances = rb_iv_get(aw, "-instances");
+    VALUE *inst_ptr = sqlite3_aggregate_context(ctx, 0);
+    VALUE inst;
 
-  if (!inst_ptr || (inst = *inst_ptr)) {
-    return;
-  }
+    if (!inst_ptr || (inst = *inst_ptr)) {
+        return;
+    }
 
-  if (inst == Qnil) {
-    rb_fatal("attempt to destroy aggregate instance twice");
-  }
+    if (inst == Qnil) {
+        rb_fatal("attempt to destroy aggregate instance twice");
+    }
 
-  rb_iv_set(inst, "-handler_instance", Qnil); // may catch use-after-free
-  if (rb_ary_delete(instances, inst) == Qnil) {
-    rb_fatal("must be in instances at that point");
-  }
+    rb_iv_set(inst, "-handler_instance", Qnil); // may catch use-after-free
+    if (rb_ary_delete(instances, inst) == Qnil) {
+        rb_fatal("must be in instances at that point");
+    }
 
-  *inst_ptr = Qnil;
+    *inst_ptr = Qnil;
 }
 
 static void
-rb_sqlite3_aggregator_step(sqlite3_context * ctx, int argc, sqlite3_value **argv)
+rb_sqlite3_aggregator_step(sqlite3_context *ctx, int argc, sqlite3_value **argv)
 {
-  VALUE inst = rb_sqlite3_aggregate_instance(ctx);
-  VALUE handler_instance = rb_iv_get(inst, "-handler_instance");
-  VALUE * params = NULL;
-  VALUE one_param;
-  int exc_status = NUM2INT(rb_iv_get(inst, "-exc_status"));
-  int i;
-
-  if (exc_status) {
-    return;
-  }
-
-  if (argc == 1) {
-    one_param = sqlite3val2rb(argv[0]);
-    params = &one_param;
-  }
-  if (argc > 1) {
-    params = xcalloc((size_t)argc, sizeof(VALUE));
-    for(i = 0; i < argc; i++) {
-      params[i] = sqlite3val2rb(argv[i]);
+    VALUE inst = rb_sqlite3_aggregate_instance(ctx);
+    VALUE handler_instance = rb_iv_get(inst, "-handler_instance");
+    VALUE *params = NULL;
+    VALUE one_param;
+    int exc_status = NUM2INT(rb_iv_get(inst, "-exc_status"));
+    int i;
+
+    if (exc_status) {
+        return;
+    }
+
+    if (argc == 1) {
+        one_param = sqlite3val2rb(argv[0]);
+        params = &one_param;
     }
-  }
-  rb_sqlite3_protected_funcall(
-    handler_instance, rb_intern("step"), argc, params, &exc_status);
-  if (argc > 1) {
-    xfree(params);
-  }
-
-  rb_iv_set(inst, "-exc_status", INT2NUM(exc_status));
+    if (argc > 1) {
+        params = xcalloc((size_t)argc, sizeof(VALUE));
+        for (i = 0; i < argc; i++) {
+            params[i] = sqlite3val2rb(argv[i]);
+        }
+    }
+    rb_sqlite3_protected_funcall(
+        handler_instance, rb_intern("step"), argc, params, &exc_status);
+    if (argc > 1) {
+        xfree(params);
+    }
+
+    rb_iv_set(inst, "-exc_status", INT2NUM(exc_status));
 }
 
 /* we assume that this function is only called once per execution context */
 static void
-rb_sqlite3_aggregator_final(sqlite3_context * ctx)
+rb_sqlite3_aggregator_final(sqlite3_context *ctx)
 {
-  VALUE inst = rb_sqlite3_aggregate_instance(ctx);
-  VALUE handler_instance = rb_iv_get(inst, "-handler_instance");
-  int exc_status = NUM2INT(rb_iv_get(inst, "-exc_status"));
+    VALUE inst = rb_sqlite3_aggregate_instance(ctx);
+    VALUE handler_instance = rb_iv_get(inst, "-handler_instance");
+    int exc_status = NUM2INT(rb_iv_get(inst, "-exc_status"));
 
-  if (!exc_status) {
-    VALUE result = rb_sqlite3_protected_funcall(
-      handler_instance, rb_intern("finalize"), 0, NULL, &exc_status);
     if (!exc_status) {
-      set_sqlite3_func_result(ctx, result);
+        VALUE result = rb_sqlite3_protected_funcall(
+                           handler_instance, rb_intern("finalize"), 0, NULL, &exc_status);
+        if (!exc_status) {
+            set_sqlite3_func_result(ctx, result);
+        }
     }
-  }
 
-  if (exc_status) {
-    /* the user should never see this, as Statement.step() will pick up the
-     * outstanding exception and raise it instead of generating a new one
-     * for SQLITE_ERROR with message "Ruby Exception occurred" */
-    sqlite3_result_error(ctx, "Ruby Exception occurred", -1);
-  }
+    if (exc_status) {
+        /* the user should never see this, as Statement.step() will pick up the
+         * outstanding exception and raise it instead of generating a new one
+         * for SQLITE_ERROR with message "Ruby Exception occurred" */
+        sqlite3_result_error(ctx, "Ruby Exception occurred", -1);
+    }
 
-  rb_sqlite3_aggregate_instance_destroy(ctx);
+    rb_sqlite3_aggregate_instance_destroy(ctx);
 }
 
 /* call-seq: define_aggregator2(aggregator)
@@ -205,70 +205,66 @@ rb_sqlite3_aggregator_final(sqlite3_context * ctx)
 VALUE
 rb_sqlite3_define_aggregator2(VALUE self, VALUE aggregator, VALUE ruby_name)
 {
-  /* define_aggregator is added as a method to SQLite3::Database in database.c */
-  sqlite3RubyPtr ctx;
-  int arity, status;
-  VALUE aw;
-  VALUE aggregators;
-
-  Data_Get_Struct(self, sqlite3Ruby, ctx);
-  if (!ctx->db) {
-    rb_raise(rb_path2class("SQLite3::Exception"), "cannot use a closed database");
-  }
-
-  if (rb_respond_to(aggregator, rb_intern("arity"))) {
-    VALUE ruby_arity = rb_funcall(aggregator, rb_intern("arity"), 0);
-    arity = NUM2INT(ruby_arity);
-  } else {
-    arity = -1;
-  }
-
-  if (arity < -1 || arity > 127) {
+    /* define_aggregator is added as a method to SQLite3::Database in database.c */
+    sqlite3RubyPtr ctx = sqlite3_database_unwrap(self);
+    int arity, status;
+    VALUE aw;
+    VALUE aggregators;
+
+    if (!ctx->db) {
+        rb_raise(rb_path2class("SQLite3::Exception"), "cannot use a closed database");
+    }
+
+    if (rb_respond_to(aggregator, rb_intern("arity"))) {
+        VALUE ruby_arity = rb_funcall(aggregator, rb_intern("arity"), 0);
+        arity = NUM2INT(ruby_arity);
+    } else {
+        arity = -1;
+    }
+
+    if (arity < -1 || arity > 127) {
 #ifdef PRIsVALUE
-    rb_raise(rb_eArgError, "%"PRIsVALUE" arity=%d out of range -1..127",
-            self, arity);
+        rb_raise(rb_eArgError, "%"PRIsVALUE" arity=%d out of range -1..127",
+                 self, arity);
 #else
-    rb_raise(rb_eArgError, "Aggregator arity=%d out of range -1..127", arity);
+        rb_raise(rb_eArgError, "Aggregator arity=%d out of range -1..127", arity);
 #endif
-  }
-
-  if (!rb_ivar_defined(self, rb_intern("-aggregators"))) {
-    rb_iv_set(self, "-aggregators", rb_ary_new());
-  }
-  aggregators = rb_iv_get(self, "-aggregators");
-
-  aw = rb_class_new_instance(0, NULL, cAggregatorWrapper);
-  rb_iv_set(aw, "-handler_klass", aggregator);
-  rb_iv_set(aw, "-instances", rb_ary_new());
-
-  status = sqlite3_create_function(
-    ctx->db,
-    StringValueCStr(ruby_name),
-    arity,
-    SQLITE_UTF8,
-    (void*)aw,
-    NULL,
-    rb_sqlite3_aggregator_step,
-    rb_sqlite3_aggregator_final
-  );
-
-  if (status != SQLITE_OK) {
-    rb_sqlite3_raise(ctx->db, status);
-    return self; // just in case rb_sqlite3_raise returns.
-  }
-
-  rb_ary_push(aggregators, aw);
-
-  return self;
+    }
+
+    if (!rb_ivar_defined(self, rb_intern("-aggregators"))) {
+        rb_iv_set(self, "-aggregators", rb_ary_new());
+    }
+    aggregators = rb_iv_get(self, "-aggregators");
+
+    aw = rb_class_new_instance(0, NULL, cAggregatorWrapper);
+    rb_iv_set(aw, "-handler_klass", aggregator);
+    rb_iv_set(aw, "-instances", rb_ary_new());
+
+    status = sqlite3_create_function(
+                 ctx->db,
+                 StringValueCStr(ruby_name),
+                 arity,
+                 SQLITE_UTF8,
+                 (void *)aw,
+                 NULL,
+                 rb_sqlite3_aggregator_step,
+                 rb_sqlite3_aggregator_final
+             );
+
+    CHECK(ctx->db, status);
+
+    rb_ary_push(aggregators, aw);
+
+    return self;
 }
 
 void
 rb_sqlite3_aggregator_init(void)
 {
-  /* rb_class_new generatos class with undefined allocator in ruby 1.9 */
-  cAggregatorWrapper = rb_funcall(rb_cClass, rb_intern("new"), 0);
-  rb_gc_register_mark_object(cAggregatorWrapper);
+    /* rb_class_new generatos class with undefined allocator in ruby 1.9 */
+    cAggregatorWrapper = rb_funcall(rb_cClass, rb_intern("new"), 0);
+    rb_gc_register_mark_object(cAggregatorWrapper);
 
-  cAggregatorInstance = rb_funcall(rb_cClass, rb_intern("new"), 0);
-  rb_gc_register_mark_object(cAggregatorInstance);
+    cAggregatorInstance = rb_funcall(rb_cClass, rb_intern("new"), 0);
+    rb_gc_register_mark_object(cAggregatorInstance);
 }

data/ext/sqlite3/aggregator.h

@@ -3,10 +3,8 @@
 
 #include <sqlite3_ruby.h>
 
-VALUE
-rb_sqlite3_define_aggregator2(VALUE self, VALUE aggregator, VALUE ruby_name);
+VALUE rb_sqlite3_define_aggregator2(VALUE self, VALUE aggregator, VALUE ruby_name);
 
-void
-rb_sqlite3_aggregator_init(void);
+void rb_sqlite3_aggregator_init(void);
 
 #endif

data/ext/sqlite3/backup.c

@@ -8,16 +8,31 @@
 
 VALUE cSqlite3Backup;
 
-static void deallocate(void * ctx)
+static size_t
+backup_memsize(const void *data)
 {
-  sqlite3BackupRubyPtr c = (sqlite3BackupRubyPtr)ctx;
-  xfree(c);
+    sqlite3BackupRubyPtr ctx = (sqlite3BackupRubyPtr)data;
+    // NB: can't account for ctx->p because the type is incomplete.
+    return sizeof(*ctx);
 }
 
-static VALUE allocate(VALUE klass)
+static const rb_data_type_t backup_type = {
+    "SQLite3::Backup",
+    {
+        NULL,
+        RUBY_TYPED_DEFAULT_FREE,
+        backup_memsize,
+    },
+    0,
+    0,
+    RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
+static VALUE
+allocate(VALUE klass)
 {
-  sqlite3BackupRubyPtr ctx = xcalloc((size_t)1, sizeof(sqlite3BackupRuby));
-  return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
+    sqlite3BackupRubyPtr ctx;
+    return TypedData_Make_Struct(klass, sqlite3BackupRuby, &backup_type, ctx);
 }
 
 /* call-seq: SQLite3::Backup.new(dstdb, dstname, srcdb, srcname)
@@ -56,31 +71,33 @@ static VALUE allocate(VALUE klass)
  *   b.finish
  *
  */
-static VALUE initialize(VALUE self, VALUE dstdb, VALUE dstname, VALUE srcdb, VALUE srcname)
+static VALUE
+initialize(VALUE self, VALUE dstdb, VALUE dstname, VALUE srcdb, VALUE srcname)
 {
-  sqlite3BackupRubyPtr ctx;
-  sqlite3RubyPtr ddb_ctx, sdb_ctx;
-  sqlite3_backup *pBackup;
-
-  Data_Get_Struct(self, sqlite3BackupRuby, ctx);
-  Data_Get_Struct(dstdb, sqlite3Ruby, ddb_ctx);
-  Data_Get_Struct(srcdb, sqlite3Ruby, sdb_ctx);
-
-  if(!sdb_ctx->db)
-    rb_raise(rb_eArgError, "cannot backup from a closed database");
-  if(!ddb_ctx->db)
-    rb_raise(rb_eArgError, "cannot backup to a closed database");
-
-  pBackup = sqlite3_backup_init(ddb_ctx->db, StringValuePtr(dstname),
-    sdb_ctx->db, StringValuePtr(srcname));
-  if( pBackup ){
-    ctx->p = pBackup;
-  }
-  else {
-    CHECK(ddb_ctx->db, sqlite3_errcode(ddb_ctx->db));
-  }
-
-  return self;
+    sqlite3BackupRubyPtr ctx;
+    sqlite3RubyPtr ddb_ctx, sdb_ctx;
+    sqlite3_backup *pBackup;
+
+    TypedData_Get_Struct(self, sqlite3BackupRuby, &backup_type, ctx);
+    ddb_ctx = sqlite3_database_unwrap(dstdb);
+    sdb_ctx = sqlite3_database_unwrap(srcdb);
+
+    if (!sdb_ctx->db) {
+        rb_raise(rb_eArgError, "cannot backup from a closed database");
+    }
+    if (!ddb_ctx->db) {
+        rb_raise(rb_eArgError, "cannot backup to a closed database");
+    }
+
+    pBackup = sqlite3_backup_init(ddb_ctx->db, StringValuePtr(dstname),
+                                  sdb_ctx->db, StringValuePtr(srcname));
+    if (pBackup) {
+        ctx->p = pBackup;
+    } else {
+        CHECK(ddb_ctx->db, sqlite3_errcode(ddb_ctx->db));
+    }
+
+    return self;
 }
 
 /* call-seq: SQLite3::Backup#step(nPage)
@@ -92,30 +109,32 @@ static VALUE initialize(VALUE self, VALUE dstdb, VALUE dstname, VALUE srcdb, VAL
  * When coping is not done, it returns SQLite3::Constants::ErrorCode::OK.
  * When some errors occur, it returns the error code.
  */
-static VALUE step(VALUE self, VALUE nPage)
+static VALUE
+step(VALUE self, VALUE nPage)
 {
-  sqlite3BackupRubyPtr ctx;
-  int status;
+    sqlite3BackupRubyPtr ctx;
+    int status;
 
-  Data_Get_Struct(self, sqlite3BackupRuby, ctx);
-  REQUIRE_OPEN_BACKUP(ctx);
-  status = sqlite3_backup_step(ctx->p, NUM2INT(nPage));
-  return INT2NUM(status);
+    TypedData_Get_Struct(self, sqlite3BackupRuby, &backup_type, ctx);
+    REQUIRE_OPEN_BACKUP(ctx);
+    status = sqlite3_backup_step(ctx->p, NUM2INT(nPage));
+    return INT2NUM(status);
 }
 
 /* call-seq: SQLite3::Backup#finish
  *
  * Destroy the backup object.
  */
-static VALUE finish(VALUE self)
+static VALUE
+finish(VALUE self)
 {
-  sqlite3BackupRubyPtr ctx;
+    sqlite3BackupRubyPtr ctx;
 
-  Data_Get_Struct(self, sqlite3BackupRuby, ctx);
-  REQUIRE_OPEN_BACKUP(ctx);
-  (void)sqlite3_backup_finish(ctx->p);
-  ctx->p = NULL;
-  return Qnil;
+    TypedData_Get_Struct(self, sqlite3BackupRuby, &backup_type, ctx);
+    REQUIRE_OPEN_BACKUP(ctx);
+    (void)sqlite3_backup_finish(ctx->p);
+    ctx->p = NULL;
+    return Qnil;
 }
 
 /* call-seq: SQLite3::Backup#remaining
@@ -125,13 +144,14 @@ static VALUE finish(VALUE self)
  * Note that the value is only updated after step() is called,
  * so before calling step() returned value is invalid.
  */
-static VALUE remaining(VALUE self)
+static VALUE
+remaining(VALUE self)
 {
-  sqlite3BackupRubyPtr ctx;
+    sqlite3BackupRubyPtr ctx;
 
-  Data_Get_Struct(self, sqlite3BackupRuby, ctx);
-  REQUIRE_OPEN_BACKUP(ctx);
-  return INT2NUM(sqlite3_backup_remaining(ctx->p));
+    TypedData_Get_Struct(self, sqlite3BackupRuby, &backup_type, ctx);
+    REQUIRE_OPEN_BACKUP(ctx);
+    return INT2NUM(sqlite3_backup_remaining(ctx->p));
 }
 
 /* call-seq: SQLite3::Backup#pagecount
@@ -141,28 +161,30 @@ static VALUE remaining(VALUE self)
  * Note that the value is only updated after step() is called,
  * so before calling step() returned value is invalid.
  */
-static VALUE pagecount(VALUE self)
+static VALUE
+pagecount(VALUE self)
 {
-  sqlite3BackupRubyPtr ctx;
+    sqlite3BackupRubyPtr ctx;
 
-  Data_Get_Struct(self, sqlite3BackupRuby, ctx);
-  REQUIRE_OPEN_BACKUP(ctx);
-  return INT2NUM(sqlite3_backup_pagecount(ctx->p));
+    TypedData_Get_Struct(self, sqlite3BackupRuby, &backup_type, ctx);
+    REQUIRE_OPEN_BACKUP(ctx);
+    return INT2NUM(sqlite3_backup_pagecount(ctx->p));
 }
 
-void init_sqlite3_backup()
+void
+init_sqlite3_backup(void)
 {
 #if 0
-  VALUE mSqlite3 = rb_define_module("SQLite3");
+    VALUE mSqlite3 = rb_define_module("SQLite3");
 #endif
-  cSqlite3Backup = rb_define_class_under(mSqlite3, "Backup", rb_cObject);
-
-  rb_define_alloc_func(cSqlite3Backup, allocate);
-  rb_define_method(cSqlite3Backup, "initialize", initialize, 4);
-  rb_define_method(cSqlite3Backup, "step", step, 1);
-  rb_define_method(cSqlite3Backup, "finish", finish, 0);
-  rb_define_method(cSqlite3Backup, "remaining", remaining, 0);
-  rb_define_method(cSqlite3Backup, "pagecount", pagecount, 0);
+    cSqlite3Backup = rb_define_class_under(mSqlite3, "Backup", rb_cObject);
+
+    rb_define_alloc_func(cSqlite3Backup, allocate);
+    rb_define_method(cSqlite3Backup, "initialize", initialize, 4);
+    rb_define_method(cSqlite3Backup, "step", step, 1);
+    rb_define_method(cSqlite3Backup, "finish", finish, 0);
+    rb_define_method(cSqlite3Backup, "remaining", remaining, 0);
+    rb_define_method(cSqlite3Backup, "pagecount", pagecount, 0);
 }
 
 #endif

data/ext/sqlite3/backup.h

@@ -4,11 +4,11 @@
 #include <sqlite3_ruby.h>
 
 struct _sqlite3BackupRuby {
-  sqlite3_backup *p;
+    sqlite3_backup *p;
 };
 
 typedef struct _sqlite3BackupRuby sqlite3BackupRuby;
-typedef sqlite3BackupRuby * sqlite3BackupRubyPtr;
+typedef sqlite3BackupRuby *sqlite3BackupRubyPtr;
 
 void init_sqlite3_backup();