sqlite3 2.10.0-x86_64-linux-gnu → 2.10.2-x86_64-linux-gnu

data/ext/sqlite3/statement.c

@@ -31,7 +31,7 @@ statement_memsize(const void *data)
 }
 
 static const rb_data_type_t statement_type = {
-    "SQLite3::Backup",
+    "SQLite3::Statement",
     {
         NULL,
         statement_deallocate,
@@ -54,8 +54,9 @@ prepare(VALUE self, VALUE db, VALUE sql)
 {
     sqlite3RubyPtr db_ctx = sqlite3_database_unwrap(db);
     sqlite3StmtRubyPtr ctx;
-    const char *tail = NULL;
-    int status;
+    const char *sql_cstr, *tail = NULL;
+    rb_sqlite3_callback_frame_t frame;
+    int sql_len, status, callback_state;
 
     StringValue(sql);
 
@@ -68,17 +69,22 @@ prepare(VALUE self, VALUE db, VALUE sql)
 
     timespecclear(&db_ctx->stmt_deadline);
 
+    sql_cstr = StringValuePtr(sql);
+    sql_len = RSTRING_LENINT(sql);
+
+    rb_sqlite3_push_callback_frame(&frame);
 #ifdef HAVE_SQLITE3_PREPARE_V2
     status = sqlite3_prepare_v2(
 #else
     status = sqlite3_prepare(
 #endif
                  db_ctx->db,
-                 (const char *)StringValuePtr(sql),
-                 (int)RSTRING_LEN(sql),
+                 sql_cstr,
+                 sql_len,
                  &ctx->st,
                  &tail
              );
+    if ((callback_state = rb_sqlite3_pop_callback_frame(&frame))) { rb_jump_tag(callback_state); }
 
     CHECK_PREPARE(db_ctx->db, status, StringValuePtr(sql));
 
@@ -125,7 +131,8 @@ step(VALUE self)
 {
     sqlite3StmtRubyPtr ctx;
     sqlite3_stmt *stmt;
-    int value, length;
+    rb_sqlite3_callback_frame_t frame;
+    int value, length, callback_state;
     VALUE list;
     rb_encoding *internal_encoding;
 
@@ -144,14 +151,13 @@ step(VALUE self)
         timespecclear(&ctx->db->stmt_deadline);
     }
 
+    rb_sqlite3_push_callback_frame(&frame);
     value = sqlite3_step(stmt);
-    if (rb_errinfo() != Qnil) {
-        /* some user defined function was invoked as a callback during step and
-         * it raised an exception that has been suppressed until step returns.
-         * Now re-raise it. */
-        VALUE exception = rb_errinfo();
-        rb_set_errinfo(Qnil);
-        rb_exc_raise(exception);
+    if ((callback_state = rb_sqlite3_pop_callback_frame(&frame))) { rb_jump_tag(callback_state); }
+
+    if (value == SQLITE_DONE) {
+        ctx->done_p = 1;
+        return Qnil;
     }
 
     length = sqlite3_column_count(stmt);
@@ -200,10 +206,6 @@ step(VALUE self)
             }
         }
         break;
-        case SQLITE_DONE:
-            ctx->done_p = 1;
-            return Qnil;
-            break;
         default:
             sqlite3_reset(stmt);
             ctx->done_p = 0;
@@ -236,6 +238,10 @@ step(VALUE self)
  *
  *   stmt.bind_param(1, my_binary_str.encode(Encoding::UTF_8))
  *
+ * The value that this method binds stays bound when you execute or reset the
+ * statement. To change the value, bind a new value to the same parameter. To
+ * clear all values, call #clear_bindings!.
+ *
  * See also #bind_params.
  */
 static VALUE
@@ -274,7 +280,7 @@ bind_param(VALUE self, VALUE key, VALUE value)
                              ctx->st,
                              index,
                              (const char *)StringValuePtr(value),
-                             (int)RSTRING_LEN(value),
+                             RSTRING_LENINT(value),
                              SQLITE_TRANSIENT
                          );
             } else {
@@ -285,7 +291,7 @@ bind_param(VALUE self, VALUE key, VALUE value)
                                  ctx->st,
                                  index,
                                  (const char *)StringValuePtr(value),
-                                 (int)RSTRING_LEN(value),
+                                 RSTRING_LENINT(value),
                                  SQLITE_TRANSIENT
                              );
                 } else {
@@ -296,7 +302,7 @@ bind_param(VALUE self, VALUE key, VALUE value)
                                  ctx->st,
                                  index,
                                  (const char *)StringValuePtr(value),
-                                 (int)RSTRING_LEN(value),
+                                 RSTRING_LENINT(value),
                                  SQLITE_TRANSIENT
                              );
                 }
@@ -331,8 +337,11 @@ bind_param(VALUE self, VALUE key, VALUE value)
 
 /* call-seq: stmt.reset!
  *
- * Resets the statement. This is typically done internally, though it might
- * occasionally be necessary to manually reset the statement.
+ * Resets the statement. The library usually calls this method for you, but
+ * you can also call it yourself.
+ *
+ * This method does not clear the values that you bound to the parameters. To
+ * clear them, call #clear_bindings!.
  */
 static VALUE
 reset_bang(VALUE self)
@@ -353,8 +362,11 @@ reset_bang(VALUE self)
 
 /* call-seq: stmt.clear_bindings!
  *
- * Resets the statement. This is typically done internally, though it might
- * occasionally be necessary to manually reset the statement.
+ * Sets the value of each parameter in the statement to NULL.
+ *
+ * The values that you bind with #bind_param, #bind_params, or #execute stay
+ * bound when you execute or reset the statement. Call this method to clear
+ * them.
  */
 static VALUE
 clear_bindings_bang(VALUE self)

data/lib/sqlite3/database.rb

@@ -579,6 +579,25 @@ module SQLite3
       self
     end
 
+    # The "handler" that #define_aggregator hands to define_aggregator2, which
+    # only needs something that responds to +new+ (a fresh aggregator for each
+    # aggregate invocation) and +arity+.
+    class AggregatorFactory # :nodoc:
+      def initialize(template)
+        @template = template
+      end
+
+      def new
+        @template.clone
+      end
+
+      # this is what sqlite3_obj_method_arity did before
+      def arity
+        @template.method(:step).arity
+      end
+    end
+    private_constant :AggregatorFactory
+
     # Define an aggregate function named +name+ using a object template
     # object +aggregator+. +aggregator+ must respond to +step+ and +finalize+.
     # +step+ will be called with row information and +finalize+ must return the
@@ -592,36 +611,7 @@ module SQLite3
     def define_aggregator(name, aggregator)
       # Previously, this has been implemented in C. Now this is just yet
       # another compatibility shim
-      proxy = Class.new do
-        @template = aggregator
-        @name = name
-
-        def self.template
-          @template
-        end
-
-        def self.name
-          @name
-        end
-
-        def self.arity
-          # this is what sqlite3_obj_method_arity did before
-          @template.method(:step).arity
-        end
-
-        def initialize
-          @klass = self.class.template.clone
-        end
-
-        def step(*args)
-          @klass.step(*args)
-        end
-
-        def finalize
-          @klass.finalize
-        end
-      end
-      define_aggregator2(proxy, name)
+      define_aggregator2(AggregatorFactory.new(aggregator), name)
       self
     end
 

data/lib/sqlite3/resultset.rb

@@ -16,8 +16,12 @@ module SQLite3
       @stmt = stmt
     end
 
-    # Reset the cursor, so that a result set which has reached end-of-file
-    # can be rewound and reiterated.
+    # Resets the cursor to the first row, so that you can iterate over the
+    # result set again after it reaches the end.
+    #
+    # This method binds each argument to the statement with
+    # Statement#bind_params. The values that you bound before stay bound
+    # unless you bind new values to the same parameters.
     def reset(*bind_params)
       @stmt.reset!
       @stmt.bind_params(*bind_params)

data/lib/sqlite3/statement.rb

@@ -65,6 +65,10 @@ module SQLite3
     #   stmt = db.prepare( "select * from table where a=? and b=?" )
     #   stmt.bind_params( 15, "hello" )
     #
+    # The values that this method binds stay bound when you execute or reset
+    # the statement. To change a value, bind a new value to the same
+    # parameter. To clear all values, call #clear_bindings!.
+    #
     # See also #execute, #bind_param, Statement#bind_param, and
     # Statement#bind_params.
     def bind_params(*bind_vars)
@@ -83,7 +87,17 @@ module SQLite3
     # statement's virtual machine. If a block was given, the new ResultSet will
     # be yielded to it; otherwise, the ResultSet will be returned.
     #
-    # Any parameters will be bound to the statement using #bind_params.
+    # This method binds each argument to the statement with #bind_params. The
+    # values stay bound after this method returns. If a later call to #execute
+    # does not give a value for a parameter, the statement uses the value from
+    # the earlier call. To set all parameters to NULL before you execute the
+    # statement again, call #clear_bindings!:
+    #
+    #   stmt = db.prepare( "select :a, :b" )
+    #   stmt.execute( a: 1, b: 2 ).to_a  # => [[1, 2]]
+    #   stmt.execute( a: 3 ).to_a        # => [[3, 2]]
+    #   stmt.clear_bindings!
+    #   stmt.execute( a: 3 ).to_a        # => [[3, nil]]
     #
     # Example:
     #
@@ -92,7 +106,7 @@ module SQLite3
     #     ...
     #   end
     #
-    # See also #bind_params, #execute!.
+    # See also #bind_params, #execute!, #clear_bindings!.
     def execute(*bind_vars)
       reset! if active? || done?
 
@@ -109,7 +123,9 @@ module SQLite3
     # rows returned by executing the statement. Otherwise, each row will be
     # yielded to the block.
     #
-    # Any parameters will be bound to the statement using #bind_params.
+    # This method binds each argument to the statement with #bind_params. The
+    # values stay bound after this method returns. For more information, see
+    # #execute.
     #
     # Example:
     #

data/lib/sqlite3/version.rb

@@ -1,4 +1,4 @@
 module SQLite3
   # (String) the version of the sqlite3 gem, e.g. "2.1.1"
-  VERSION = "2.10.0"
+  VERSION = "2.10.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sqlite3
 version: !ruby/object:Gem::Version
-  version: 2.10.0
+  version: 2.10.2
 platform: x86_64-linux-gnu
 authors:
 - Jamis Buck