sqlite3 2.1.1-x86_64-linux-musl → 2.2.0-x86_64-linux-musl

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a9796f30949a878b2a25acf72e5dffce3ef87a1f345dae2f61f67ad43a45db8
-  data.tar.gz: 919599cea7668c14f7aacbf94d6c163d742e9306e8f9fe8b9f2b71852e40a4b6
+  metadata.gz: b01c96db500b39c730b3882238d957bb550ac1082515550a95b9e26e897a2efc
+  data.tar.gz: c5228da2d292f7e74ef8cd898f54d9b80f41736851094c1b5a0731422eedd98c
 SHA512:
-  metadata.gz: 7dc8cfd400006d4dc4837033b3ea9a4c232d5d3d6568af60633e1ea41f301c63bda2f34d007c116b714a4ac3fd52f2b9bba1617932303efd74cca7bebe6e84c3
-  data.tar.gz: 145a6d8c18aebe994620daf1727a3489d9d6919b2de8be2c5aecc5e2d779f0df939ccf014828f411928de58c714169e291f633b70bc3ed4719fad78898597a28
+  metadata.gz: 3103c62219e799bf8804afdffdcb5a7f90797afd8bcf9690336a88cff7f3af4ef796208471501235a653e3fe5469c3ec2d944ec5a0081e911d799284d3189cb8
+  data.tar.gz: d7cbf930938430c7d1991576fa209eb774879b9138cc5d21a767accdaed79e41332633d041d07f4284dd81c23de020ea131b8154a79835ba5027bfb59c6c7fc6

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # sqlite3-ruby Changelog
 
+## 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
+
+- 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
+
+
 ## 2.1.1 / 2024-10-22
 
 ### Dependencies

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.1"
+  VERSION = "2.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sqlite3
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.2.0
 platform: x86_64-linux-musl
 authors:
 - Jamis Buck
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-10-22 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