sqlite3 2.1.0.rc3-aarch64-linux-musl → 2.2.0-aarch64-linux-musl

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 022d563fce80208b0de29ff6ba0cce6422cd0ba3d69142581a7ba2b171d81ccc
-  data.tar.gz: 419350fa778be055d156c57ace2b7ff4b1c159c68a43a5a0826e4ef2599a2e21
+  metadata.gz: ea7686eb27b6fb919bac4928a6b05d61b05ea8c31a91113dbbd049ca33668404
+  data.tar.gz: 88595080229104242358722f90c48417bb235515b86ae84ab8f97568791e2cf0
 SHA512:
-  metadata.gz: 0e5623879a9467faa28b1547161176bbed47e1b0f214d9117c77f639ab6c4215467f2cdd168bc0f9a92c2e75cc0af302edf7566760f55bf051592adc198cc72f
-  data.tar.gz: 7a5b6f84c35944902926775fe0ebe6415e024f8a79e886e5cc9683c0419b86fad994fbe0a553a7c9f4a2fd04c943b4e7b8c0286690708bbbecf6ce3c9b2fdac9
+  metadata.gz: e5643ee716fd3cacf8c71802a2045d97f651858f76bd34e6e707c3b6630c8afe3a943c9af84c517ae6dcfd13221d43c0e36d9ee035f21e0fd254ed05301e68fa
+  data.tar.gz: 34271016c91c0395868ae246e25882af90a1dabd0cc46ddf89ab24a538d3efabaf5ffb08fb6a3e653cf54f72dda73a531bfc18de85b6ae8a3d7b6ad77cb5513f

data/CHANGELOG.md

@@ -1,20 +1,25 @@
 # sqlite3-ruby Changelog
 
-## prerelease 2.1.0.rc3 / 2024-09-18
+## 2.2.0 / 2024-10-30
+
+### Added
+
+- URI filenames are now allowed. This allows the injection of some behavior via recognized query parameters. See https://www.sqlite.org/uri.html for more information. [#571] @flavorjones
+
 
 ### Improved
 
-- Allow suppression of fork safety warnings. [#566] @flavorjones
+- SQL Syntax errors during `Database#prepare` will raise a verbose exception with a multiline message indicating with a "^" exactly where in the statement the error occurred. [#554] @fractaledmind @flavorjones
 
 
-## prerelease 2.1.0.rc2 / 2024-09-18
+## 2.1.1 / 2024-10-22
 
-### Improved
+### Dependencies
 
-- Address a performance regression in 2.1.0.rc1.
+- Vendored sqlite is updated to [v3.47.0](https://sqlite.org/releaselog/3_47_0.html) [#570] @flavorjones
 
 
-## prerelease 2.1.0.rc1 / 2024-09-18
+## 2.1.0 / 2024-09-24
 
 ### Ruby
 
@@ -28,9 +33,9 @@ Sqlite itself is [not fork-safe](https://www.sqlite.org/howtocorrupt.html#_carry
 - All open writable database connections carried across a `fork()` will immediately be closed in the child process to mitigate the risk of corrupting the database file.
 - These connections will be incompletely closed ("discarded") which will result in a one-time memory leak in the child process.
 
-If it's at all possible, we strongly recommend that you close writable database connections in the parent before forking.
+If it's at all possible, we strongly recommend that you close writable database connections in the parent before forking. If absolutely necessary (and you know what you're doing), you may suppress the fork safety warnings by calling `SQLite3::ForkSafety.suppress_warnings!`.
 
-See the README "Fork Safety" section and `adr/2024-09-fork-safety.md` for more information. [#558] @flavorjones
+See the README's "Fork Safety" section and `adr/2024-09-fork-safety.md` for more information. [#558, #565, #566] @flavorjones
 
 
 ### Improved
@@ -39,6 +44,11 @@ See the README "Fork Safety" section and `adr/2024-09-fork-safety.md` for more i
 - When setting a Database `busy_handler`, fire the write barrier to prevent potential crashes during the GC mark phase. [#556] @jhawthorn
 
 
+### Documentation
+
+- The `FAQ.md` has been updated to fix some inaccuracies. [#562] @rickhull
+
+
 ## 2.0.4 / 2024-08-13
 
 ### Dependencies

data/README.md

@@ -160,7 +160,7 @@ To help protect users of this gem from accidental corruption due to this lack of
 connections in the child will incur a small one-time memory leak per connection, but that's
 preferable to potentially corrupting your database.
 
-Whenever possible, close writable connections in the parent before forking.
+Whenever possible, close writable connections in the parent before forking. If absolutely necessary (and you know what you're doing), you may suppress the fork safety warnings by calling `SQLite3::ForkSafety.suppress_warnings!`.
 
 See [./adr/2024-09-fork-safety.md](./adr/2024-09-fork-safety.md) for more information and context.
 

data/dependencies.yml

@@ -1,13 +1,13 @@
 sqlite3:
   # checksum verified by first checking the published sha3(256) checksum against https://sqlite.org/download.html:
-  # 923f68143dcd9fc0c38778dee253fd6540a91f578173a04ca5adff885d8a8fbb
+  # a9166e017ef8bc33379b1c2eed346bf43cded6d40df0feb984a33fba1a828ba9
   #
-  # $ sha3sum -a 256 ports/archives/sqlite-autoconf-3460100.tar.gz
-  # 923f68143dcd9fc0c38778dee253fd6540a91f578173a04ca5adff885d8a8fbb  ports/archives/sqlite-autoconf-3460100.tar.gz
+  # $ sha3sum -a 256 ports/archives/sqlite-autoconf-3470000.tar.gz
+  # a9166e017ef8bc33379b1c2eed346bf43cded6d40df0feb984a33fba1a828ba9  ports/archives/sqlite-autoconf-3470000.tar.gz
   #
-  # $ sha256sum ports/archives/sqlite-autoconf-3460100.tar.gz
-  # 67d3fe6d268e6eaddcae3727fce58fcc8e9c53869bdd07a0c61e38ddf2965071  ports/archives/sqlite-autoconf-3460100.tar.gz
-  version: "3.46.1"
+  # $ sha256sum ports/archives/sqlite-autoconf-3470000.tar.gz
+  # 83eb21a6f6a649f506df8bd3aab85a08f7556ceed5dbd8dea743ea003fc3a957  ports/archives/sqlite-autoconf-3470000.tar.gz
+  version: "3.47.0"
   files:
-    - url: "https://sqlite.org/2024/sqlite-autoconf-3460100.tar.gz"
-      sha256: "67d3fe6d268e6eaddcae3727fce58fcc8e9c53869bdd07a0c61e38ddf2965071"
+    - url: "https://sqlite.org/2024/sqlite-autoconf-3470000.tar.gz"
+      sha256: "83eb21a6f6a649f506df8bd3aab85a08f7556ceed5dbd8dea743ea003fc3a957"

data/ext/sqlite3/exception.c

@@ -1,101 +1,82 @@
 #include <sqlite3_ruby.h>
 
-void
-rb_sqlite3_raise(sqlite3 *db, int status)
+static VALUE
+status2klass(int status)
 {
-    VALUE klass = Qnil;
-
     /* Consider only lower 8 bits, to work correctly when
        extended result codes are enabled. */
     switch (status & 0xff) {
         case SQLITE_OK:
-            return;
-            break;
+            return Qnil;
         case SQLITE_ERROR:
-            klass = rb_path2class("SQLite3::SQLException");
-            break;
+            return rb_path2class("SQLite3::SQLException");
         case SQLITE_INTERNAL:
-            klass = rb_path2class("SQLite3::InternalException");
-            break;
+            return rb_path2class("SQLite3::InternalException");
         case SQLITE_PERM:
-            klass = rb_path2class("SQLite3::PermissionException");
-            break;
+            return rb_path2class("SQLite3::PermissionException");
         case SQLITE_ABORT:
-            klass = rb_path2class("SQLite3::AbortException");
-            break;
+            return rb_path2class("SQLite3::AbortException");
         case SQLITE_BUSY:
-            klass = rb_path2class("SQLite3::BusyException");
-            break;
+            return rb_path2class("SQLite3::BusyException");
         case SQLITE_LOCKED:
-            klass = rb_path2class("SQLite3::LockedException");
-            break;
+            return rb_path2class("SQLite3::LockedException");
         case SQLITE_NOMEM:
-            klass = rb_path2class("SQLite3::MemoryException");
-            break;
+            return rb_path2class("SQLite3::MemoryException");
         case SQLITE_READONLY:
-            klass = rb_path2class("SQLite3::ReadOnlyException");
-            break;
+            return rb_path2class("SQLite3::ReadOnlyException");
         case SQLITE_INTERRUPT:
-            klass = rb_path2class("SQLite3::InterruptException");
-            break;
+            return rb_path2class("SQLite3::InterruptException");
         case SQLITE_IOERR:
-            klass = rb_path2class("SQLite3::IOException");
-            break;
+            return rb_path2class("SQLite3::IOException");
         case SQLITE_CORRUPT:
-            klass = rb_path2class("SQLite3::CorruptException");
-            break;
+            return rb_path2class("SQLite3::CorruptException");
         case SQLITE_NOTFOUND:
-            klass = rb_path2class("SQLite3::NotFoundException");
-            break;
+            return rb_path2class("SQLite3::NotFoundException");
         case SQLITE_FULL:
-            klass = rb_path2class("SQLite3::FullException");
-            break;
+            return rb_path2class("SQLite3::FullException");
         case SQLITE_CANTOPEN:
-            klass = rb_path2class("SQLite3::CantOpenException");
-            break;
+            return rb_path2class("SQLite3::CantOpenException");
         case SQLITE_PROTOCOL:
-            klass = rb_path2class("SQLite3::ProtocolException");
-            break;
+            return rb_path2class("SQLite3::ProtocolException");
         case SQLITE_EMPTY:
-            klass = rb_path2class("SQLite3::EmptyException");
-            break;
+            return rb_path2class("SQLite3::EmptyException");
         case SQLITE_SCHEMA:
-            klass = rb_path2class("SQLite3::SchemaChangedException");
-            break;
+            return rb_path2class("SQLite3::SchemaChangedException");
         case SQLITE_TOOBIG:
-            klass = rb_path2class("SQLite3::TooBigException");
-            break;
+            return rb_path2class("SQLite3::TooBigException");
         case SQLITE_CONSTRAINT:
-            klass = rb_path2class("SQLite3::ConstraintException");
-            break;
+            return rb_path2class("SQLite3::ConstraintException");
         case SQLITE_MISMATCH:
-            klass = rb_path2class("SQLite3::MismatchException");
-            break;
+            return rb_path2class("SQLite3::MismatchException");
         case SQLITE_MISUSE:
-            klass = rb_path2class("SQLite3::MisuseException");
-            break;
+            return rb_path2class("SQLite3::MisuseException");
         case SQLITE_NOLFS:
-            klass = rb_path2class("SQLite3::UnsupportedException");
-            break;
+            return rb_path2class("SQLite3::UnsupportedException");
         case SQLITE_AUTH:
-            klass = rb_path2class("SQLite3::AuthorizationException");
-            break;
+            return rb_path2class("SQLite3::AuthorizationException");
         case SQLITE_FORMAT:
-            klass = rb_path2class("SQLite3::FormatException");
-            break;
+            return rb_path2class("SQLite3::FormatException");
         case SQLITE_RANGE:
-            klass = rb_path2class("SQLite3::RangeException");
-            break;
+            return rb_path2class("SQLite3::RangeException");
         case SQLITE_NOTADB:
-            klass = rb_path2class("SQLite3::NotADatabaseException");
-            break;
+            return rb_path2class("SQLite3::NotADatabaseException");
         default:
-            klass = rb_path2class("SQLite3::Exception");
+            return rb_path2class("SQLite3::Exception");
+    }
+}
+
+void
+rb_sqlite3_raise(sqlite3 *db, int status)
+{
+    VALUE klass = status2klass(status);
+    if (NIL_P(klass)) {
+        return;
     }
 
-    klass = rb_exc_new2(klass, sqlite3_errmsg(db));
-    rb_iv_set(klass, "@code", INT2FIX(status));
-    rb_exc_raise(klass);
+    VALUE exception = rb_exc_new2(klass, sqlite3_errmsg(db));
+    rb_iv_set(exception, "@code", INT2FIX(status));
+
+    rb_exc_raise(exception);
 }
 
 /*
@@ -104,14 +85,38 @@ rb_sqlite3_raise(sqlite3 *db, int status)
 void
 rb_sqlite3_raise_msg(sqlite3 *db, int status, const char *msg)
 {
-    VALUE exception;
-
-    if (status == SQLITE_OK) {
+    VALUE klass = status2klass(status);
+    if (NIL_P(klass)) {
         return;
     }
 
-    exception = rb_exc_new2(rb_path2class("SQLite3::Exception"), msg);
+    VALUE exception = rb_exc_new2(klass, msg);
+    rb_iv_set(exception, "@code", INT2FIX(status));
     sqlite3_free((void *)msg);
+
+    rb_exc_raise(exception);
+}
+
+void
+rb_sqlite3_raise_with_sql(sqlite3 *db, int status, const char *sql)
+{
+    VALUE klass = status2klass(status);
+    if (NIL_P(klass)) {
+        return;
+    }
+
+    const char *error_msg = sqlite3_errmsg(db);
+    int error_offset = -1;
+#ifdef HAVE_SQLITE3_ERROR_OFFSET
+    error_offset = sqlite3_error_offset(db);
+#endif
+
+    VALUE exception = rb_exc_new2(klass, error_msg);
     rb_iv_set(exception, "@code", INT2FIX(status));
+    if (sql) {
+        rb_iv_set(exception, "@sql", rb_str_new2(sql));
+        rb_iv_set(exception, "@sql_offset", INT2FIX(error_offset));
+    }
+
     rb_exc_raise(exception);
 }

data/ext/sqlite3/exception.h

@@ -3,8 +3,10 @@
 
 #define CHECK(_db, _status) rb_sqlite3_raise(_db, _status);
 #define CHECK_MSG(_db, _status, _msg) rb_sqlite3_raise_msg(_db, _status, _msg);
+#define CHECK_PREPARE(_db, _status, _sql) rb_sqlite3_raise_with_sql(_db, _status, _sql)
 
 void rb_sqlite3_raise(sqlite3 *db, int status);
 void rb_sqlite3_raise_msg(sqlite3 *db, int status, const char *msg);
+void rb_sqlite3_raise_with_sql(sqlite3 *db, int status, const char *sql);
 
 #endif

data/ext/sqlite3/extconf.rb

@@ -50,8 +50,9 @@ module Sqlite3
       def configure_packaged_libraries
         minimal_recipe.tap do |recipe|
           recipe.configure_options += [
-            "--enable-shared=no",
-            "--enable-static=yes",
+            "--disable-shared",
+            "--enable-static",
+            "--disable-tcl",
             "--enable-fts5"
           ]
           ENV.to_h.tap do |env|
@@ -60,7 +61,8 @@ module Sqlite3
               "-fPIC", # needed for linking the static library into a shared library
               "-O2", # see https://github.com/sparklemotion/sqlite3-ruby/issues/335 for some benchmarks
               "-fvisibility=hidden", # see https://github.com/rake-compiler/rake-compiler-dock/issues/87
-              "-DSQLITE_DEFAULT_WAL_SYNCHRONOUS=1"
+              "-DSQLITE_DEFAULT_WAL_SYNCHRONOUS=1",
+              "-DSQLITE_USE_URI=1"
             ]
             env["CFLAGS"] = [user_cflags, env["CFLAGS"], more_cflags].flatten.join(" ")
             recipe.configure_options += env.select { |k, v| ENV_ALLOWLIST.include?(k) }
@@ -132,6 +134,7 @@ module Sqlite3
 
         have_func("sqlite3_prepare_v2")
         have_func("sqlite3_db_name", "sqlite3.h") # v3.39.0
+        have_func("sqlite3_error_offset", "sqlite3.h") # v3.38.0
 
         have_type("sqlite3_int64", "sqlite3.h")
         have_type("sqlite3_uint64", "sqlite3.h")

data/ext/sqlite3/statement.c

@@ -78,7 +78,7 @@ prepare(VALUE self, VALUE db, VALUE sql)
                  &tail
              );
 
-    CHECK(db_ctx->db, status);
+    CHECK_PREPARE(db_ctx->db, status, StringValuePtr(sql));
     timespecclear(&db_ctx->stmt_deadline);
 
     return rb_utf8_str_new_cstr(tail);

data/lib/sqlite3/errors.rb

@@ -4,6 +4,34 @@ module SQLite3
   class Exception < ::StandardError
     # A convenience for accessing the error code for this exception.
     attr_reader :code
+
+    # If the error is associated with a SQL query, this is the query
+    attr_reader :sql
+
+    # If the error is associated with a particular offset in a SQL query, this is the non-negative
+    # offset. If the offset is not available, this will be -1.
+    attr_reader :sql_offset
+
+    def message
+      [super, sql_error].compact.join(":\n")
+    end
+
+    private def sql_error
+      return nil unless @sql
+      return @sql.chomp unless @sql_offset >= 0
+
+      offset = @sql_offset
+      sql.lines.flat_map do |line|
+        if offset >= 0 && line.length > offset
+          blanks = " " * offset
+          offset = -1
+          [line.chomp, blanks + "^"]
+        else
+          offset -= line.length if offset
+          line.chomp
+        end
+      end.join("\n")
+    end
   end
 
   class SQLException < Exception; end

data/lib/sqlite3/version.rb

@@ -1,3 +1,3 @@
 module SQLite3
-  VERSION = "2.1.0.rc3"
+  VERSION = "2.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sqlite3
 version: !ruby/object:Gem::Version
-  version: 2.1.0.rc3
+  version: 2.2.0
 platform: aarch64-linux-musl
 authors:
 - Jamis Buck
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-09-24 00:00:00.000000000 Z
+date: 2024-10-30 00:00:00.000000000 Z
 dependencies: []
 description: |
   Ruby library to interface with the SQLite3 database engine (http://www.sqlite.org). Precompiled
@@ -90,9 +90,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 3.4.dev
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
-    - !ruby/object:Gem::Version
-      version: 1.3.1
   - - ">="
     - !ruby/object:Gem::Version
       version: 3.3.22