fix(spinel): column_value hands back native types — and unpin pluck's RBS

The FFI Db shim returned every column as text, a placeholder its own
comment flagged as "until per-column sqlite3_column_type dispatch is
wired". Both gem-backed shims (db_cruby, db_jruby) already answered the
native-type contract, and sqlite_adapter's select_rows comment already
claimed all of them did. Wire the dispatch so the claim is true.

Two changes, because the first alone did nothing:

1. Db.column_value dispatches on sqlite3_column_type (storage class),
   returning Integer/Float/String/nil. Storage class, NOT decltype: the
   declared type diverges from the gem shims exactly when the two
   disagree, and it cannot detect NULL at all — which is the whole
   reason the nullable reads need a per-row probe. Same price
   column_int_opt already pays.

2. Relation's RBS pinned pluck to Array[String] and pick to String?,
   which FORCED the coercion straight back — measured, still String
   after change 1. Both are untyped now, which is what the catalog
   (src/catalog/mod.rs, ArrayOfUntyped) already said; the sidecar was
   the outlier.

Measured on the lobsters AOT lane: recent_threads' pluck(:thread_id)
went from "19948" to 19948, so the thread_ids it returns once again
match the Integer keys model attributes carry. Also closes a second
silent one on a different path — tag.rb's all_with_filtered_counts_for
looks up counts[t.id] against group(:tag_id).group_count, whose keys
were Strings, so filtered_count read 0 for every tag.

/threads itself stays empty: it is blocked behind matz/spinel#3505, a
nil returned through a block typed Integer? that is a different Hash
key than a literal nil. This clears the layer behind that one.

All 26 lobsters routes byte-identical before/after; cargo test green.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: rubys

runtime/ruby/active_record/relation.rbs

@@ -62,8 +62,24 @@ module ActiveRecord
     def size: () -> Integer
     def delete_all: () -> Integer
     def update_all: (untyped updates) -> Integer
-    def pluck: (untyped col) -> Array[String]
-    def pick: (untyped col) -> String?
+    # `pluck`/`pick` hand back whatever the COLUMN holds — Integer for an
+    # INTEGER column, Float for REAL, String for TEXT, nil for NULL —
+    # because they read straight through `select_rows` without a cast.
+    # Pinning these to String used to be harmless: the spinel FFI shim
+    # returned everything as text anyway, so the seed and the runtime
+    # agreed. Once `Db.column_value` began answering the native-type
+    # contract the other shims already met, the String pin became the
+    # thing FORCING the coercion back — `pluck(:thread_id)` handed back
+    # `"19948"` where the model attribute held `19948`, and every Hash
+    # lookup between them missed (lobsters /threads).
+    #
+    # `untyped` is the honest type at this level: the column's type is
+    # not knowable from `Relation`. Typing it precisely means the
+    # lowerer monomorphizing per call site from the schema, the way
+    # `ids` below can be Array[Integer] because it only ever reads a
+    # primary key.
+    def pluck: (untyped col) -> Array[untyped]
+    def pick: (untyped col) -> untyped
     def ids: () -> Array[Integer]
     def find: (Integer id) -> untyped
     def find_by: (untyped conditions) -> untyped

runtime/spinel/db.rb

@@ -55,6 +55,13 @@ module SQL
   ffi_const :OK,   0
   ffi_const :ROW,  100
   ffi_const :DONE, 101
+  # sqlite3_column_type storage classes. NULL is the one the nullable
+  # reads have always needed; the rest let `column_value` hand back the
+  # driver's native type instead of everything-as-text.
+  ffi_const :INTEGER_TYPE, 1
+  ffi_const :FLOAT_TYPE, 2
+  ffi_const :TEXT_TYPE, 3
+  ffi_const :BLOB_TYPE, 4
   ffi_const :NULL_TYPE, 5
   # open_v2 flags: READWRITE | CREATE | URI. The first two are what plain
   # `sqlite3_open` uses, so a non-URI path opens identically either way.
@@ -569,18 +576,48 @@ def self.column_text(stmt, i)
     end
   end
 
-  # Raw typed column read — the gem-backed shims (db_cruby/db_jruby)
-  # return the driver's native value (Integer/Float/String/nil). The
-  # FFI shim keeps the text representation until per-column
-  # `sqlite3_column_type` dispatch is wired; NULL at least maps to nil
-  # (not "") so nil-keyed grouping and truthiness behave. Same
-  # copy-out as column_text (the buffer dies at the next step).
+  # Raw typed column read — the driver's native value, the same contract
+  # the gem-backed shims (db_cruby/db_jruby) answer: Integer for an
+  # INTEGER storage class, Float for REAL, String for TEXT, nil for NULL.
+  #
+  # Dispatches on the STORAGE CLASS of the value in THIS row, not on the
+  # column's declared type. SQLite is dynamically typed and both gem
+  # shims report what is actually stored, so storage class is what keeps
+  # the AOT tree's hydration in step with the CRuby lane. Caching
+  # `sqlite3_column_decltype` once per statement would save the probe
+  # below, but it would diverge from the shims exactly when storage class
+  # and declaration disagree — and it cannot detect NULL at all, which is
+  # the whole reason the nullable reads need a per-row probe.
+  #
+  # Costs one `sqlite3_column_type` call per column per row on top of the
+  # value read. That is the same price `column_int_opt` and friends
+  # already pay, and it is unavoidable: `sqlite3_column_int` cannot tell
+  # a stored 0 from NULL. Before this, every value arrived as text, so
+  # `pluck(:thread_id)` handed back `"19948"` where the model attribute
+  # held `19948` and every Hash lookup between them missed.
+  #
+  # Integers read through `sqlite3_column_int` (32-bit), matching
+  # `column_int` and the `from_stmt` hydration path; a corpus with keys
+  # past 2^31 would need `sqlite3_column_int64` wired for all of them
+  # together, not just here. BLOB falls to the text read — no corpus
+  # caller stores one, and text is a more useful stand-in than raising.
   def self.column_value(stmt, i)
-    s = SQL.sqlite3_column_text(stmt, i)
-    if s.nil?
+    t = SQL.sqlite3_column_type(stmt, i)
+    if t == SQL::NULL_TYPE
       nil
+    elsif t == SQL::INTEGER_TYPE
+      SQL.sqlite3_column_int(stmt, i)
+    elsif t == SQL::FLOAT_TYPE
+      SQL.sqlite3_column_double(stmt, i)
     else
-      s + ""
+      # Same copy-out as column_text — the libsqlite3 buffer is
+      # invalidated by the next step or finalize on this stmt.
+      s = SQL.sqlite3_column_text(stmt, i)
+      if s.nil?
+        nil
+      else
+        s + ""
+      end
     end
   end
 

runtime/spinel/sqlite_adapter.rb

@@ -92,8 +92,9 @@ def self.truncate(table)
   # keyed by column name. Values read through `Db.column_value` — the
   # driver's NATIVE types (Integer/Float/String, nil for NULL), which
   # is what ActiveRecord hands the app: `group_by(&:fk)[nil]` finds
-  # root rows, integer columns compare as integers. (The FFI Db shim
-  # still returns text values, nil-for-NULL aside — see db.rb.) Each
+  # root rows, integer columns compare as integers, and `pluck(:fk)`
+  # returns keys that match the ones model attributes carry. All three
+  # shims answer this now, the FFI one by storage-class dispatch. Each
   # row is its own Hash so the caller gets a stable copy after
   # `finalize`.
   def self.select_rows(sql)

src/emit/ruby/expr.rs

@@ -389,13 +389,16 @@ fn emit_cast(value: &Expr, target_ty: &crate::ty::Ty) -> String {
         // than a missed narrowing.
         //
         // Adapters disagree about what a boolean column reads as: the
-        // gem-backed shims give `true`/`false` or `1`/`0`, while
-        // spinel's `Db.column_value` is `sqlite3_column_text`, so every
-        // value arrives as a STRING — `"0"` for false. Assigning that
-        // raw string into a slot the RBS pins `bool` makes it `true`,
-        // and lobsters' `Rack::MiniProfiler.authorize_request if @user
-        // && @user.is_admin?` then fired for a user whose `is_admin` is
-        // 0, taking the whole request down under spinel AOT.
+        // gem-backed shims give `true`/`false` or `1`/`0`, and spinel's
+        // `Db.column_value` gives the `0`/`1` of the INTEGER storage
+        // class (it used to give the STRING `"0"`, before storage-class
+        // dispatch landed in runtime/spinel/db.rb — the string spelling
+        // stays covered below because nothing guarantees a future
+        // adapter won't reintroduce it). Assigning a raw `"0"` into a
+        // slot the RBS pins `bool` makes it `true`, and lobsters'
+        // `Rack::MiniProfiler.authorize_request if @user &&
+        // @user.is_admin?` then fired for a user whose `is_admin` is 0,
+        // taking the whole request down under spinel AOT.
         //
         // Compare the string form so one expression covers every
         // adapter: `false`/`0`/`"0"` are the false spellings, plus `""`