sqlite3 1.3.13 → 1.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: b430789a68a6d6079e0395db6fc53421e4b317ab
-  data.tar.gz: db014f4a1f4e980913a3dcb48d9aab14a5a9eca1
+SHA256:
+  metadata.gz: ff35addc187325a243e752d17c9f38ac54ea4a5b8a48c4809c4dd91692f1f94d
+  data.tar.gz: c9c22fc4b4a091197b12ae09c13d199c2fcd5f8c836944bf04f50be919d32f8a
 SHA512:
-  metadata.gz: 7e2764239b107677240476bb608bcb46cc0966c06d06e90881113b91dbdb8342c6c7558760cf0645a56449ac8e267f13a0e25dbef0d3e820a38f5857a96c4e05
-  data.tar.gz: 1e08a478ed043d22bbe95df2151bf009a7f03a1457c37df4199c8601fa1ccb9de27986e64341c4fb9a009e5ab4023638704078222f88441b55ac1ee2773838d8
+  metadata.gz: 68c1c1233ff73049b7c1ff1e0bbeec883bc90228182bd090564ff4df2b9f37fe92e4e9333a374306ba7fcdd10b0b2f914c4116dff0c34ef5c2e964f9342de986
+  data.tar.gz: 698263b49e7efa9a3c06220d71e617657fdf31b8e8097a9e2278b5ca3a5fbbb3468b2492fa51670345a3756b4760169d2b79681fac523144166f99253f1e40f3

data/.travis.yml

@@ -0,0 +1,33 @@
+language: ruby
+cache: bundler
+before_install:
+  - gem update --system 2.7.7
+  - gem install bundler -v 1.16.2
+addons:
+  apt:
+    packages:
+      - libgmp-dev
+
+after_failure:
+  - "find . -name mkmf.log -exec cat {} \\;"
+
+after_success:
+  - "find . -name mkmf.log -exec cat {} \\;"
+
+env:
+  - USE_MINI_PORTILE=true
+  - USE_MINI_PORTILE=false
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1
+  - 2.2
+  - 2.3
+  - 2.4
+  - 2.5
+  - 2.6
+  - 2.7
+  - ruby-head
+matrix:
+  allow_failures:
+    - env: USE_MINI_PORTILE=false

data/CHANGELOG.rdoc

@@ -1,3 +1,29 @@
+=== 1.4.2
+
+* Travis: Drop unused setting "sudo: false"
+* The taint mechanism will be deprecated in Ruby 2.7
+* Fix Ruby 2.7 rb_check_safe_obj warnings
+* Update travis config
+
+=== 1.4.1
+
+* Don't mandate dl functions for the extention build
+* bumping version
+
+=== 1.4.0
+
+* Enhancements
+  * Better aggregator support
+
+* Bugfixes
+  * Various
+
+=== 1.3.13
+
+* Enancements
+  * Support SQLite flags when defining functions
+  * Add definition for SQLITE_DETERMINISTIC flag
+
 === 1.3.12
 
 * Bugfixes:
@@ -15,7 +41,7 @@
 === 1.3.10 / 2014-10-30
 
 * Enhancements:
-  * Windows: build against SQLite 3.8.7.1. Closes #134, #135 [Hubro]
+  * Windows: build against SQLite 3.8.6. Closes #135 [Hubro]
 
 === 1.3.9 / 2014-02-25
 

data/Gemfile

@@ -5,11 +5,13 @@
 source "https://rubygems.org/"
 
 
-gem "minitest", "~>5.9", :group => [:development, :test]
-gem "rake-compiler", "~>0.9.3", :group => [:development, :test]
-gem "rake-compiler-dock", "~>0.5.2", :group => [:development, :test]
+gem "minitest", "~>5.11", :group => [:development, :test]
+gem "rake-compiler", "~>1.0", :group => [:development, :test]
+gem "rake-compiler-dock", "~>0.6.0", :group => [:development, :test]
 gem "mini_portile", "~>0.6.2", :group => [:development, :test]
 gem "hoe-bundler", "~>1.0", :group => [:development, :test]
-gem "hoe", "~>3.15", :group => [:development, :test]
+gem "hoe-gemspec", "~>1.0", :group => [:development, :test]
+gem "rdoc", ">=4.0", "<6", :group => [:development, :test]
+gem "hoe", "~>3.17", :group => [:development, :test]
 
 # vim: syntax=ruby

data/Manifest.txt

@@ -1,3 +1,5 @@
+.gemtest
+.travis.yml
 API_CHANGES.rdoc
 CHANGELOG.rdoc
 ChangeLog.cvs
@@ -6,6 +8,9 @@ LICENSE
 Manifest.txt
 README.rdoc
 Rakefile
+appveyor.yml
+ext/sqlite3/aggregator.c
+ext/sqlite3/aggregator.h
 ext/sqlite3/backup.c
 ext/sqlite3/backup.h
 ext/sqlite3/database.c
@@ -29,19 +34,22 @@ lib/sqlite3/statement.rb
 lib/sqlite3/translator.rb
 lib/sqlite3/value.rb
 lib/sqlite3/version.rb
+rakelib/faq.rake
+rakelib/gem.rake
+rakelib/native.rake
+rakelib/vendor_sqlite3.rake
 setup.rb
-tasks/faq.rake
-tasks/gem.rake
-tasks/native.rake
-tasks/vendor_sqlite3.rake
 test/helper.rb
 test/test_backup.rb
 test/test_collation.rb
 test/test_database.rb
+test/test_database_flags.rb
 test/test_database_readonly.rb
+test/test_database_readwrite.rb
 test/test_deprecated.rb
 test/test_encoding.rb
 test/test_integration.rb
+test/test_integration_aggregate.rb
 test/test_integration_open_close.rb
 test/test_integration_pending.rb
 test/test_integration_resultset.rb

data/README.rdoc

@@ -107,7 +107,7 @@ which can be found here:
 
 For help figuring out the SQLite3/Ruby interface, check out the
 SYNOPSIS as well as the RDoc. It includes examples of
-usage. If you have any questions that you feel should be address in the
+usage. If you have any questions that you feel should be addressed in the
 FAQ, please send them to {the mailing list}[http://groups.google.com/group/sqlite3-ruby]
 
 == Source Code

data/Rakefile

@@ -4,7 +4,5 @@
 # Thank You.
 #
 
-# load rakefile extensions (tasks)
-Dir['tasks/*.rake'].sort.each { |f| load f }
 
 # vim: syntax=ruby

data/appveyor.yml

@@ -0,0 +1,36 @@
+---
+version: "{build}"
+branches:
+  only:
+    - master
+    - 1-3-stable
+clone_depth: 10
+install:
+  - SET PATH=C:\Ruby%ruby_version%\bin;%PATH%
+  - ruby --version
+  - gem --version
+  - gem install bundler --quiet --no-ri --no-rdoc
+  - bundler --version
+  - bundle install
+build_script:
+  - rake native gem
+test_script:
+  - rake test
+artifacts:
+  - path: pkg\*.gem
+
+environment:
+  matrix:
+    - ruby_version: "193"
+    - ruby_version: "200"
+    - ruby_version: "200-x64"
+    - ruby_version: "21"
+    - ruby_version: "21-x64"
+    - ruby_version: "22"
+    - ruby_version: "22-x64"
+    - ruby_version: "23"
+    - ruby_version: "23-x64"
+    - ruby_version: "24"
+    - ruby_version: "24-x64"
+    - ruby_version: "25"
+    - ruby_version: "25-x64"

data/ext/sqlite3/aggregator.c

@@ -0,0 +1,273 @@
+#include <aggregator.h>
+#include <database.h>
+
+/* wraps a factory "handler" class. The "-aggregators" instance variable of
+ * the SQLite3::Database holds an array of all AggrogatorWrappers.
+ *
+ * An AggregatorWrapper holds the following instance variables:
+ * -handler_klass: the handler that creates the instances.
+ * -instances:     array of all the cAggregatorInstance objects currently
+ *                 in-flight for this aggregator. */
+static VALUE cAggregatorWrapper;
+
+/* wraps a intance of the "handler" class. Loses its reference at the end of
+ * the xFinal callback.
+ *
+ * An AggregatorInstance holds the following instnace variables:
+ * -handler_instance: the instance to call `step` and `finalize` on.
+ * -exc_status:       status returned by rb_protect.
+ *                    != 0 if an exception occurred. If an exception occured
+ *                    `step` and `finalize` won't be called any more. */
+static VALUE cAggregatorInstance;
+
+typedef struct rb_sqlite3_protected_funcall_args {
+    VALUE self;
+    ID method;
+    int argc;
+    VALUE *params;
+} protected_funcall_args_t;
+
+/* why isn't there something like this in the ruby API? */
+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;
+
+  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)
+{
+  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
+ * checks if the exection context already has an associated instance. If it
+ * has one, it returns it. If there is no instance yet, it creates one and
+ * associates it with the context. */
+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));
+
+  if (!inst_ptr) {
+    rb_fatal("SQLite is out-of-merory");
+  }
+
+  inst = *inst_ptr;
+
+  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));
+
+    rb_ary_push(instances, inst);
+
+    *inst_ptr = inst;
+  }
+
+  if (inst == Qnil) {
+    rb_fatal("SQLite called us back on an already destroyed aggregate instance");
+  }
+
+  return inst;
+}
+
+/* called by rb_sqlite3_aggregator_final. Unlinks and frees the
+ * aggregator_instance_t, so the handler_instance won't be marked any more
+ * and Ruby's GC may free it. */
+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;
+
+  if (!inst_ptr || (inst = *inst_ptr)) {
+    return;
+  }
+
+  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");
+  }
+
+  *inst_ptr = Qnil;
+}
+
+static void
+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]);
+    }
+  }
+  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)
+{
+  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);
+    }
+  }
+
+  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 occured" */
+    sqlite3_result_error(ctx, "Ruby Exception occured", -1);
+  }
+
+  rb_sqlite3_aggregate_instance_destroy(ctx);
+}
+
+/* call-seq: define_aggregator2(aggregator)
+ *
+ * Define an aggregrate function according to a factory object (the "handler")
+ * that knows how to obtain to all the information. The handler must provide
+ * the following class methods:
+ *
+ * +arity+:: corresponds to the +arity+ parameter of #create_aggregate. This
+ *           message is optional, and if the handler does not respond to it,
+ *           the function will have an arity of -1.
+ * +name+:: this is the name of the function. The handler _must_ implement
+ *          this message.
+ * +new+:: this must be implemented by the handler. It should return a new
+ *         instance of the object that will handle a specific invocation of
+ *         the function.
+ *
+ * The handler instance (the object returned by the +new+ message, described
+ * above), must respond to the following messages:
+ *
+ * +step+:: this is the method that will be called for each step of the
+ *          aggregate function's evaluation. It should take parameters according
+ *          to the *arity* definition.
+ * +finalize+:: this is the method that will be called to finalize the
+ *              aggregate function's evaluation. It should not take arguments.
+ *
+ * Note the difference between this function and #create_aggregate_handler
+ * is that no FunctionProxy ("ctx") object is involved. This manifests in two
+ * ways: The return value of the aggregate function is the return value of
+ * +finalize+ and neither +step+ nor +finalize+ take an additional "ctx"
+ * parameter.
+ */
+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) {
+#ifdef PRIsVALUE
+    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);
+#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;
+}
+
+void
+rb_sqlite3_aggregator_init(void)
+{
+  rb_gc_register_address(&cAggregatorWrapper);
+  rb_gc_register_address(&cAggregatorInstance);
+  /* rb_class_new generatos class with undefined allocator in ruby 1.9 */
+  cAggregatorWrapper = rb_funcall(rb_cClass, rb_intern("new"), 0);
+  cAggregatorInstance = rb_funcall(rb_cClass, rb_intern("new"), 0);
+}

data/ext/sqlite3/aggregator.h

@@ -0,0 +1,12 @@
+#ifndef SQLITE3_AGGREGATOR_RUBY
+#define SQLITE3_AGGREGATOR_RUBY
+
+#include <sqlite3_ruby.h>
+
+VALUE
+rb_sqlite3_define_aggregator2(VALUE self, VALUE aggregator, VALUE ruby_name);
+
+void
+rb_sqlite3_aggregator_init(void);
+
+#endif