sqlite3 2.9.6-x86_64-linux-gnu → 2.10.0-x86_64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c97aef61c4c3b103f1410db5184f2de9ac720002b6882e1bcce29e3bbed534c
-  data.tar.gz: 0c99a2035128a56d4408f81943cf5d76028be8b7169ed34a95a6194fdb90d9ac
+  metadata.gz: 925936bfaad5493f668bfa519612ad3253bde99a26f3348a4a43f3d06898590a
+  data.tar.gz: 3c1af19b4c916d77fcbf1814cf129720ddba94df13f700ae5b3c150a5b3f8a0b
 SHA512:
-  metadata.gz: 759387ca94485dc154d98ab3ffb6bd1430a4047a0a1263ddd9bcf845c4dc674cc2976cc58209ac3c4d209c2108740a74dc4146413b783fcfd2100048f510b89d
-  data.tar.gz: 9ff1fbc0bec0c106dcc647daf919fe44e117cee019e2442cefb93e299eccf329ee4dcca8c90fb6ea01080c541ca04749a40ea1b0d2f2cdc59647b0d6a444baa2
+  metadata.gz: be09b9ecca49b6be1546b6f7fcef1f11a9937e5d88dfe0c42479bae8cb37f73dd6e55d0cd775290965e86a9f0948bb808c1841152a2622ac0c09c6e745a91a6f
+  data.tar.gz: 3ab7d2078c7b13596e4c6837d8798fe88e41cab4eeda9d85d9093467612b6cf10ec97432c5b2a8afeb5b6250903ebb71a632a3e6c9f7f5623a3d37d564131049

data/CHANGELOG.md

@@ -1,5 +1,36 @@
 # sqlite3-ruby Changelog
 
+## 2.10.0 / 2026-10-13
+
+### Dependencies
+
+- Vendored sqlite is updated to [v3.54.0](https://www.sqlite.org/releaselog/3_54_0.html) (from v3.53.2). #750 @flavorjones
+
+  Notable changes in this version include:
+  - `ALTER TABLE` now raises an error when adding, renaming, or dropping a column named `ROWID`, `_ROWID_`, or `OID`.
+  - The authorizer callback is now invoked for SQL functions in the `DEFAULT` clauses of `CREATE TABLE` statements.
+  - SQLite no longer supports Windows XP or earlier. On Windows, the precompiled gem and any installation that compiles the vendored sqlite now require Windows Vista or later.
+
+### Added
+
+- `ResultSet#each` and `#each_hash` return an `Enumerator` when called without a block. Previously they raised `LocalJumpError`. #656 @kch
+- Introduce `Database#serialize`, which returns a database as a binary string, and `Database#deserialize`, which replaces a database with the contents of such a string. These wrap [`sqlite3_serialize()`](https://www.sqlite.org/c3ref/serialize.html) and [`sqlite3_deserialize()`](https://www.sqlite.org/c3ref/deserialize.html). Both methods are defined only when SQLite was compiled without `SQLITE_OMIT_DESERIALIZE`, and `Database#deserialize` also requires that the loaded SQLite is v3.54.0 or later. An image of a database in WAL mode cannot be queried after deserializing; see the `Database#deserialize` documentation. #685 @Maaarcocr
+
+### Fixed
+
+- Fix `Database#statement_timeout=` interrupting statements almost immediately instead of after the timeout elapsed, including re-executed prepared statements and calls to `Database#execute_batch2`. #737 @palkan @flavorjones
+
+### Improved
+
+- On CRuby, `Statement#types` allocates fewer strings. Each declared type is downcased and interned in C, instead of allocating two strings per column. #743 @jhawthorn
+
+### Changed
+
+- `ResultSet#each` and `#each_hash` return the result set when called with a block. As a consequence, `Database#execute` and `#execute2` called with a block return the closed `ResultSet` instead of `nil`. #656 @kch
+- `Statement#columns` and `Statement#types` return frozen arrays, and the strings in `Statement#types` are frozen. Code that mutates them now raises `FrozenError`. #743 @jhawthorn
+- `Statement#column_decltype` and `Statement#types` return UTF-8 strings. Previously they returned ASCII-8BIT strings. #743 @jhawthorn
+
+
 ## 2.9.6 / 2026-08-11
 
 ### Security / Stability
@@ -25,7 +56,7 @@
 
 ### Dependencies
 
-- Vendored sqlite is updated to [v3.53.2](https://www.sqlite.org/releaselog/3_53_3.html) (from v3.53.1). #709 @flavorjones
+- Vendored sqlite is updated to [v3.53.2](https://www.sqlite.org/releaselog/3_53_2.html) (from v3.53.1). #709 @flavorjones
 
 ### Security / Stability
 

data/dependencies.yml

@@ -1,13 +1,13 @@
 sqlite3:
   # checksum verified by first checking the published sha3(256) checksum against https://sqlite.org/download.html:
-  # 025328da165109f48abccc6e7478508060804412bed2bd81d47e98ba1b72983b
+  # f5e3e724e9c9b3b5d512c76b02082091a59eeea9becd169a9fbf4d376403acce
   #
-  # $ sha3sum -a 256 ports/archives/sqlite-autoconf-3530200.tar.gz
-  # 025328da165109f48abccc6e7478508060804412bed2bd81d47e98ba1b72983b  ports/archives/sqlite-autoconf-3530200.tar.gz
+  # $ sha3sum -a 256 ports/archives/sqlite-autoconf-3540000.tar.gz
+  # f5e3e724e9c9b3b5d512c76b02082091a59eeea9becd169a9fbf4d376403acce  ports/archives/sqlite-autoconf-3540000.tar.gz
   #
-  # $ sha256sum ports/archives/sqlite-autoconf-3530200.tar.gz
-  # 588ad51949419a56ebe81fe56193d510c559eb94c9a57748387860b5d3069316  ports/archives/sqlite-autoconf-3530200.tar.gz
-  version: "3.53.2"
+  # $ sha256sum ports/archives/sqlite-autoconf-3540000.tar.gz
+  # 134ec0802dda5795816e25d25872d20b312cb3973438c49b30bc40b7705ea9ed  ports/archives/sqlite-autoconf-3540000.tar.gz
+  version: "3.54.0"
   files:
-    - url: "https://sqlite.org/2026/sqlite-autoconf-3530200.tar.gz"
-      sha256: "588ad51949419a56ebe81fe56193d510c559eb94c9a57748387860b5d3069316"
+    - url: "https://sqlite.org/2026/sqlite-autoconf-3540000.tar.gz"
+      sha256: "134ec0802dda5795816e25d25872d20b312cb3973438c49b30bc40b7705ea9ed"

data/ext/sqlite3/database.c

@@ -417,8 +417,10 @@ rb_sqlite3_statement_timeout(void *context)
     clock_gettime(CLOCK_MONOTONIC, &currentTime);
 
     if (!timespecisset(&ctx->stmt_deadline)) {
-        // Set stmt_deadline if not already set
-        ctx->stmt_deadline = currentTime;
+        struct timespec timeout;
+        timeout.tv_sec = ctx->stmt_timeout / 1000;
+        timeout.tv_nsec = (ctx->stmt_timeout % 1000) * 1000000L;
+        timespecadd(&currentTime, &timeout, &ctx->stmt_deadline);
     } else if (timespecafter(&currentTime, &ctx->stmt_deadline)) {
         return 1;
     }
@@ -990,6 +992,8 @@ exec_batch(VALUE self, VALUE sql, VALUE results_as_hash)
     TypedData_Get_Struct(self, sqlite3Ruby, &database_type, ctx);
     REQUIRE_OPEN_DB(ctx);
 
+    timespecclear(&ctx->stmt_deadline);
+
     if (results_as_hash == Qtrue) {
         status = sqlite3_exec(ctx->db, StringValuePtr(sql), (sqlite3_callback)hash_callback_function,
                               (void *)callback_ary,
@@ -1024,6 +1028,137 @@ db_filename(VALUE self, VALUE db_name)
     return Qnil;
 }
 
+#ifdef HAVE_SQLITE3_SERIALIZE
+/* call-seq: db.serialize(database_name = "main")
+ *
+ * Serialize the database into a binary string.
+ *
+ * [database_name]  The name of the database to serialize. The default value
+ *                  is +main+ which is the main database file. For ATTACHed
+ *                  databases, use the name given in the ATTACH statement.
+ *
+ * Returns the contents of the database as a binary string. For an ordinary
+ * on-disk database file, this is just a copy of the disk file. For an
+ * in-memory database or a "TEMP" database, this is the same sequence of bytes
+ * which would be written to disk if that database were backed up to disk.
+ *
+ * Note: This method will only be defined if SQLite was compiled without
+ * +SQLITE_OMIT_DESERIALIZE+.
+ *
+ * See also: https://www.sqlite.org/c3ref/serialize.html
+ */
+static VALUE
+serialize(int argc, VALUE *argv, VALUE self)
+{
+    sqlite3RubyPtr ctx;
+    VALUE db_name;
+    const char *zSchema;
+    sqlite3_int64 size;
+    unsigned char *data;
+    VALUE result;
+
+    TypedData_Get_Struct(self, sqlite3Ruby, &database_type, ctx);
+    REQUIRE_OPEN_DB(ctx);
+
+    rb_scan_args(argc, argv, "01", &db_name);
+
+    zSchema = NIL_P(db_name) ? NULL : StringValueCStr(db_name);
+
+    data = sqlite3_serialize(ctx->db, zSchema, &size, 0);
+
+    if (data == NULL && size < 0) {
+        rb_raise(rb_path2class("SQLite3::Exception"), "unable to serialize database \"%s\"",
+                 zSchema ? zSchema : "main");
+    }
+    if (data == NULL && size > 0) {
+        rb_raise(rb_eNoMemError, "failed to allocate %lld bytes for serialization", (long long)size);
+    }
+
+    result = rb_str_new((const char *)data, (long)size);
+    sqlite3_free(data);
+
+    return result;
+}
+#endif
+
+#ifdef HAVE_SQLITE3_DESERIALIZE
+/* call-seq: db.deserialize(data, database_name = "main")
+ *
+ * Deserialize a binary string into the database. The database is replaced with
+ * the contents of the serialized data.
+ *
+ * [data]           A binary string containing the serialized database content.
+ *                  This is typically obtained from a prior call to #serialize.
+ *
+ * [database_name]  The name of the database to replace. The default value is
+ *                  +main+ which is the main database file. For ATTACHed
+ *                  databases, use the name given in the ATTACH statement.
+ *
+ * Raises SQLite3::BusyException if the database has an open read or write
+ * transaction, including one held by an unfinished statement, or is involved in
+ * a backup.
+ *
+ * Deserializing into a database backed by a file detaches the connection from
+ * that file. The file is left unchanged, and #filename(database_name) returns an
+ * empty string afterwards.
+ *
+ * ⚠ An image of a database in WAL mode deserializes without error, but later
+ * statements, even <tt>SELECT 1</tt>, raise SQLite3::CantOpenException. Rails
+ * enables WAL mode by default.
+ *
+ * ⚠ Deserializing untrusted data carries the same risks as opening an untrusted
+ * database file. See https://www.sqlite.org/security.html
+ *
+ * Note: This method will only be defined if the loaded SQLite is version 3.54.0
+ * or later and was compiled without +SQLITE_OMIT_DESERIALIZE+. Older versions do
+ * not raise SQLite3::BusyException; they free memory that an unfinished statement
+ * still uses.
+ *
+ * See also: https://www.sqlite.org/c3ref/deserialize.html
+ */
+static VALUE
+deserialize(int argc, VALUE *argv, VALUE self)
+{
+    sqlite3RubyPtr ctx;
+    VALUE data, db_name;
+    const char *zSchema;
+    unsigned char *pData;
+    sqlite3_int64 szDb, szBuf;
+    int status;
+
+    TypedData_Get_Struct(self, sqlite3Ruby, &database_type, ctx);
+    REQUIRE_OPEN_DB(ctx);
+
+    rb_scan_args(argc, argv, "11", &data, &db_name);
+
+    StringValue(data);
+    zSchema = NIL_P(db_name) ? NULL : StringValueCStr(db_name);
+    szDb = RSTRING_LEN(data);
+
+    /* SQLite's docs advise padding the buffer with about 20 extra bytes, because a maliciously
+     * malformed image may make SQLite read past its end. See https://www.sqlite.org/c3ref/deserialize.html
+     *
+     * With SQLITE_DESERIALIZE_RESIZEABLE set, SQLite copies pages out of the buffer with bounds
+     * checks instead of reading it in place, so the padding is defensive. It also keeps the
+     * allocation nonzero for an empty string, for which sqlite3_malloc64(0) returns NULL.
+     */
+    szBuf = szDb + 20;
+    pData = sqlite3_malloc64(szBuf);
+    if (pData == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate %lld bytes for deserialization", (long long)szBuf);
+    }
+    memcpy(pData, RSTRING_PTR(data), (size_t)szDb);
+    memset(pData + szDb, 0, (size_t)(szBuf - szDb));
+
+    status = sqlite3_deserialize(ctx->db, zSchema, pData, szDb, szDb,
+                                 SQLITE_DESERIALIZE_FREEONCLOSE | SQLITE_DESERIALIZE_RESIZEABLE);
+
+    CHECK(ctx->db, status);
+
+    return self;
+}
+#endif
+
 static VALUE
 rb_sqlite3_open16(VALUE self, VALUE file)
 {
@@ -1104,6 +1239,16 @@ init_sqlite3_database(void)
 #endif
 #endif
 
+#ifdef HAVE_SQLITE3_SERIALIZE
+    rb_define_method(cSqlite3Database, "serialize", serialize, -1);
+#endif
+
+#ifdef HAVE_SQLITE3_DESERIALIZE
+    /* Before 3.54.0, sqlite3_deserialize frees memory that an unfinished statement still uses. */
+    if (sqlite3_libversion_number() >= 3054000) {
+        rb_define_method(cSqlite3Database, "deserialize", deserialize, -1);
+    }
+#endif
 
     rb_sqlite3_aggregator_init();
 }

data/ext/sqlite3/extconf.rb

@@ -65,7 +65,10 @@ module Sqlite3
               "-DSQLITE_ENABLE_DBPAGE_VTAB=1",
               "-DSQLITE_ENABLE_DBSTAT_VTAB=1"
             ]
-            env["CFLAGS"] = [user_cflags, env["CFLAGS"], more_cflags].flatten.join(" ")
+            # sqlite >= 3.54 requires Vista APIs, same as ruby's default target. Placed first so a
+            # user-defined _WIN32_WINNT takes precedence.
+            windows_cflags = windows? ? ["-D_WIN32_WINNT=0x0600"] : []
+            env["CFLAGS"] = [windows_cflags, user_cflags, env["CFLAGS"], more_cflags].flatten.join(" ")
             recipe.configure_options += env.slice(*ENV_ALLOWLIST)
               .map { |key, value| "#{key}=#{value.strip}" }
           end
@@ -115,9 +118,10 @@ module Sqlite3
 
         abort_could_not_find(libname) unless find_library(libname, "sqlite3_libversion_number", "sqlite3.h")
 
-        # Truffle Ruby doesn't support this yet:
+        # Ruby 3.0+, but not on every implementation:
         # https://github.com/oracle/truffleruby/issues/3408
         have_func("rb_enc_interned_str_cstr")
+        have_func("rb_enc_interned_str")
 
         # Functions defined in 1.9 but not 1.8
         have_func("rb_proc_arity")
@@ -139,6 +143,8 @@ 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_func("sqlite3_serialize", "sqlite3.h") # v3.23.0
+        have_func("sqlite3_deserialize", "sqlite3.h") # v3.23.0
 
         have_type("sqlite3_int64", "sqlite3.h")
         have_type("sqlite3_uint64", "sqlite3.h")

data/ext/sqlite3/statement.c

@@ -66,6 +66,8 @@ prepare(VALUE self, VALUE db, VALUE sql)
      * variable will keep it from being GCed. */
     ctx->db = db_ctx;
 
+    timespecclear(&db_ctx->stmt_deadline);
+
 #ifdef HAVE_SQLITE3_PREPARE_V2
     status = sqlite3_prepare_v2(
 #else
@@ -79,7 +81,6 @@ prepare(VALUE self, VALUE db, VALUE sql)
              );
 
     CHECK_PREPARE(db_ctx->db, status, StringValuePtr(sql));
-    timespecclear(&db_ctx->stmt_deadline);
 
     return rb_utf8_str_new_cstr(tail);
 }
@@ -139,6 +140,10 @@ step(VALUE self)
 
     stmt = ctx->st;
 
+    if (!sqlite3_stmt_busy(stmt)) {
+        timespecclear(&ctx->db->stmt_deadline);
+    }
+
     value = sqlite3_step(stmt);
     if (rb_errinfo() != Qnil) {
         /* some user defined function was invoked as a callback during step and
@@ -216,6 +221,21 @@ step(VALUE self)
  * Fixnum, it is treated as an index for a positional placeholder.
  * Otherwise it is used as the name of the placeholder to bind to.
  *
+ * Type mapping from Ruby to SQLite3:
+ * - +nil+        → NULL
+ * - Integer      → INTEGER (or REAL when outside the signed int64 range)
+ * - Float        → REAL
+ * - SQLite3::Blob → BLOB
+ * - String with Encoding::ASCII_8BIT (a.k.a. BINARY) → BLOB
+ * - String with Encoding::UTF_16LE or Encoding::UTF_16BE → TEXT (bound as UTF-16)
+ * - String (all other encodings) → TEXT (re-encoded to UTF-8 if necessary)
+ * - Any other type → raises RuntimeError
+ *
+ * Note: if you have a string with only ASCII characters but ASCII-8BIT
+ * encoding and want it bound as TEXT rather than BLOB, re-encode it first:
+ *
+ *   stmt.bind_param(1, my_binary_str.encode(Encoding::UTF_8))
+ *
  * See also #bind_params.
  */
 static VALUE
@@ -398,6 +418,33 @@ interned_utf8_cstr(const char *str)
 }
 #endif
 
+/* Like interned_utf8_cstr, but ASCII-downcases as it copies. */
+static VALUE
+interned_downcased_utf8_cstr(const char *str)
+{
+#if HAVE_RB_ENC_INTERNED_STR
+    VALUE tmp, ret;
+    char *buf;
+    size_t i, len;
+
+    len = strlen(str);
+    buf = ALLOCV_N(char, tmp, len);
+
+    for (i = 0; i < len; i++) {
+        unsigned char c = (unsigned char)str[i];
+        buf[i] = (char)((c >= 'A' && c <= 'Z') ? c + ('a' - 'A') : c);
+    }
+
+    ret = rb_enc_interned_str(buf, (long)len, rb_utf8_encoding());
+    ALLOCV_END(tmp);
+    return ret;
+#else
+    VALUE rb_str = rb_funcall(rb_utf8_str_new_cstr(str), rb_intern("downcase"), 1,
+                              ID2SYM(rb_intern("ascii")));
+    return rb_funcall(rb_str, rb_intern("-@"), 0);
+#endif
+}
+
 /* call-seq: stmt.column_name(index)
  *
  * Get the column name at +index+.  0 based.
@@ -425,7 +472,8 @@ column_name(VALUE self, VALUE index)
 
 /* call-seq: stmt.column_decltype(index)
  *
- * Get the column type at +index+.  0 based.
+ * Get the declared type of the column at +index+, as a UTF-8 string.  0 based.
+ * Returns +nil+ if the column has no declared type, such as an expression.
  */
 static VALUE
 column_decltype(VALUE self, VALUE index)
@@ -440,7 +488,24 @@ column_decltype(VALUE self, VALUE index)
 
     name = sqlite3_column_decltype(ctx->st, (int)NUM2INT(index));
 
-    if (name) { return rb_str_new2(name); }
+    if (name) { return rb_utf8_str_new_cstr(name); }
+    return Qnil;
+}
+
+static VALUE
+column_decltype_downcased(VALUE self, VALUE index)
+{
+    sqlite3StmtRubyPtr ctx;
+    const char *name;
+
+    TypedData_Get_Struct(self, sqlite3StmtRuby, &statement_type, ctx);
+
+    REQUIRE_LIVE_DB(ctx);
+    REQUIRE_OPEN_STMT(ctx);
+
+    name = sqlite3_column_decltype(ctx->st, (int)NUM2INT(index));
+
+    if (name) { return interned_downcased_utf8_cstr(name); }
     return Qnil;
 }
 
@@ -733,6 +798,7 @@ init_sqlite3_statement(void)
     rb_define_method(cSqlite3Statement, "memused", memused, 0);
 #endif
 
+    rb_define_private_method(cSqlite3Statement, "column_decltype_downcased", column_decltype_downcased, 1);
     rb_define_private_method(cSqlite3Statement, "prepare", prepare, 2);
     rb_define_private_method(cSqlite3Statement, "stats_as_hash", stats_as_hash, 0);
     rb_define_private_method(cSqlite3Statement, "stat_for", stat_for, 1);

data/ext/sqlite3/timespec.h

@@ -15,6 +15,15 @@
 			(vsp)->tv_nsec += 1000000000L;			\
 		}							\
 	} while (0)
+#define	timespecadd(tsp, usp, vsp)					\
+	do {								\
+		(vsp)->tv_sec = (tsp)->tv_sec + (usp)->tv_sec;		\
+		(vsp)->tv_nsec = (tsp)->tv_nsec + (usp)->tv_nsec;	\
+		if ((vsp)->tv_nsec >= 1000000000L) {			\
+			(vsp)->tv_sec++;				\
+			(vsp)->tv_nsec -= 1000000000L;			\
+		}							\
+	} while (0)
 #define timespecafter(tsp, usp)						\
 	(((tsp)->tv_sec > (usp)->tv_sec) ||				\
 	 ((tsp)->tv_sec == (usp)->tv_sec && (tsp)->tv_nsec > (usp)->tv_nsec))

data/lib/sqlite3/resultset.rb

@@ -43,20 +43,26 @@ module SQLite3
       @stmt.step
     end
 
-    # Required by the Enumerable mixin. Provides an internal iterator over the
-    # rows of the result set.
+    # With a block given, iterates over the rows of the result set, passing each
+    # to the block. Returns self.
+    # With no block given, returns a new Enumerator.
     def each
+      return enum_for(__method__) unless block_given?
       while (node = self.next)
         yield node
       end
+      self
     end
 
-    # Provides an internal iterator over the rows of the result set where
-    # each row is yielded as a hash.
+    # With a block given, iterates over the rows of the result set, passing each
+    # to the block as a hash. Returns self.
+    # With no block given, returns a new Enumerator.
     def each_hash
+      return enum_for(__method__) unless block_given?
       while (node = next_hash)
         yield node
       end
+      self
     end
 
     # Closes the statement that spawned this result set.

data/lib/sqlite3/statement.rb

@@ -42,6 +42,24 @@ module SQLite3
     # See Database#execute for a description of the valid placeholder
     # syntaxes.
     #
+    # Type mapping from Ruby to SQLite3:
+    # - +nil+                            → NULL
+    # - Integer                          → INTEGER (or REAL when outside the signed int64 range)
+    # - Float                            → REAL
+    # - SQLite3::Blob                    → BLOB
+    # - String with Encoding::ASCII_8BIT
+    #   (a.k.a. BINARY)                  → BLOB
+    # - String with Encoding::UTF_16LE
+    #   or Encoding::UTF_16BE            → TEXT (bound as UTF-16)
+    # - String (all other encodings)     → TEXT (re-encoded to UTF-8 if needed)
+    # - Any other type                   → raises RuntimeError
+    #
+    # Note: a String with Encoding::ASCII_8BIT (BINARY) is always bound as a
+    # BLOB, even when its bytes are all valid ASCII. If you want such a string
+    # compared or stored as TEXT, re-encode it before binding:
+    #
+    #   stmt.bind_params(my_binary_str.encode(Encoding::UTF_8))
+    #
     # Example:
     #
     #   stmt = db.prepare( "select * from table where a=? and b=?" )
@@ -112,9 +130,9 @@ module SQLite3
       !done?
     end
 
-    # Return an array of the column names for this statement. Note that this
-    # may execute the statement in order to obtain the metadata; this makes it
-    # a (potentially) expensive operation.
+    # Return a frozen array of the column names for this statement, as frozen
+    # UTF-8 strings. Note that this may execute the statement in order to
+    # obtain the metadata; this makes it a (potentially) expensive operation.
     def columns
       get_metadata unless @columns
       @columns
@@ -128,9 +146,11 @@ module SQLite3
       end
     end
 
-    # Return an array of the data types for each column in this statement. Note
-    # that this may execute the statement in order to obtain the metadata; this
-    # makes it a (potentially) expensive operation.
+    # Return a frozen array of the declared types of the columns in this
+    # statement, as frozen UTF-8 strings with ASCII letters downcased. A column
+    # with no declared type, such as an expression, has a +nil+ type. Note that
+    # this may execute the statement in order to obtain the metadata; this makes
+    # it a (potentially) expensive operation.
     def types
       must_be_open!
       get_metadata unless @types
@@ -180,11 +200,10 @@ module SQLite3
     def get_metadata
       @columns = Array.new(column_count) do |column|
         column_name column
-      end
+      end.freeze
       @types = Array.new(column_count) do |column|
-        val = column_decltype(column)
-        val&.downcase
-      end
+        column_decltype_downcased(column)
+      end.freeze
     end
   end
 end

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.9.6"
+  VERSION = "2.10.0"
 end

metadata

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