fix(pgwire): preserve declared integer width in RowDescription OIDs

Schemaless/columnar collections resolve every integer width
(SMALLINT, INT4, BIGINT, ...) to the single planner-facing
`SqlDataType::Int64`, and `sql_data_type_to_ddl_col_type` mapped
that straight to OID 20 (int8) for every column regardless of what
was actually declared. Clients that declared `SMALLINT` or `INT4`
got back OID 20 instead of the expected 21/23, which breaks ORMs
and typed client libraries that trust the advertised wire OID.
`SMALLINT`/`INT2` were also missing from the schemaless type-string
parser and fell through to a `String` default, rendering as OID 25
(text) instead of an integer OID at all.

The catalog now threads the column's raw declared type string
through to the planner alongside its resolved `SqlDataType`, and a
new `sql_data_type_to_ddl_col_type_with_raw` uses it to narrow an
`Int8` result to `Int4`/`Int2` when the raw type says so. Only the
wire-advertised width changes; storage stays a full i64 either way.

Fixes #217.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0193ftf9LuUWejMqe2KVWkya

Author: emanzx

nodedb/src/control/planner/catalog_adapter/type_convert.rs

@@ -61,7 +61,12 @@ pub(super) fn convert_collection_type(
                     nullable: true,
                     is_primary_key: false,
                     default: None,
-                    raw_type: None,
+                    // Mirrors the columnar branch below: the raw declared
+                    // type string is the only place the wire-width refiner
+                    // (`sql_data_type_to_ddl_col_type_with_raw`) can recover
+                    // `SMALLINT`/`INT4` vs `BIGINT` — `parse_type_str`
+                    // collapses all of them to the same `SqlDataType::Int64`.
+                    raw_type: Some(type_str.clone()),
                 });
             }
             (EngineType::DocumentSchemaless, columns, Some(pk_name))
@@ -180,7 +185,7 @@ fn parse_type_str(s: &str) -> SqlDataType {
         return SqlDataType::Decimal;
     }
     match upper.as_str() {
-        "INT" | "INTEGER" | "INT4" | "INT8" | "BIGINT" => SqlDataType::Int64,
+        "INT" | "INTEGER" | "INT4" | "INT8" | "BIGINT" | "SMALLINT" | "INT2" => SqlDataType::Int64,
         "FLOAT" | "FLOAT4" | "FLOAT8" | "FLOAT64" | "DOUBLE" | "REAL" => SqlDataType::Float64,
         "BOOL" | "BOOLEAN" => SqlDataType::Bool,
         "BYTES" | "BYTEA" | "BLOB" => SqlDataType::Bytes,
@@ -193,9 +198,23 @@ fn parse_type_str(s: &str) -> SqlDataType {
 mod tests {
     use nodedb_types::CollectionType;
 
-    use super::{SqlDataType, convert_collection_type};
+    use super::{SqlDataType, convert_collection_type, parse_type_str};
     use crate::control::security::catalog::StoredCollection;
 
+    /// `SMALLINT`/`INT2` are valid PostgreSQL wire-width integer keywords
+    /// (issue #217) that must resolve to the same `SqlDataType::Int64` arm as
+    /// `INT`/`INTEGER`/`INT4`/`INT8`/`BIGINT` — previously they were unlisted
+    /// and fell through to the `_ => SqlDataType::String` default, which is
+    /// what produced the wire OID 25 (text) bug for `SMALLINT` columns.
+    #[test]
+    fn parse_type_str_smallint_and_int2_map_to_int64() {
+        assert_eq!(parse_type_str("SMALLINT"), SqlDataType::Int64);
+        assert_eq!(parse_type_str("INT2"), SqlDataType::Int64);
+        // Case-insensitivity, matching every other arm in this function.
+        assert_eq!(parse_type_str("smallint"), SqlDataType::Int64);
+        assert_eq!(parse_type_str("int2"), SqlDataType::Int64);
+    }
+
     /// A columnar (or spatial, which shares the same non-timeseries
     /// synthetic-PK path) collection whose DDL declares an explicit
     /// `id` field must not surface two `id` columns to the planner —

nodedb/src/control/planner/sql_plan_convert/output_schema.rs

@@ -20,7 +20,7 @@ use nodedb_sql::types_expr::SqlExpr;
 use super::lateral::collection_name_from_plan;
 use super::output_schema_types::{infer_aggregate_type, infer_computed_expr_type};
 use crate::control::server::response_shape::schema::{
-    OutputColumn, OutputSchema, sql_data_type_to_ddl_col_type,
+    OutputColumn, OutputSchema, sql_data_type_to_ddl_col_type_with_raw,
 };
 use crate::control::server::response_shape::types::DdlColType;
 
@@ -94,7 +94,12 @@ fn column_types_for<C: SqlCatalog>(
         Ok(Some(info)) => info
             .columns
             .iter()
-            .map(|c| (c.name.clone(), sql_data_type_to_ddl_col_type(&c.data_type)))
+            .map(|c| {
+                (
+                    c.name.clone(),
+                    sql_data_type_to_ddl_col_type_with_raw(&c.data_type, c.raw_type.as_deref()),
+                )
+            })
             .collect(),
         _ => HashMap::new(),
     }
@@ -173,7 +178,7 @@ fn ordered_columns_for<C: SqlCatalog>(
             .map(|c| OutputColumn {
                 display_name: c.name.clone(),
                 lookup_key: c.name.clone(),
-                ty: sql_data_type_to_ddl_col_type(&c.data_type),
+                ty: sql_data_type_to_ddl_col_type_with_raw(&c.data_type, c.raw_type.as_deref()),
             })
             .collect(),
         _ => Vec::new(),

nodedb/src/control/server/response_shape/schema.rs

@@ -63,12 +63,147 @@ pub fn sql_data_type_to_ddl_col_type(
     }
 }
 
+/// Like [`sql_data_type_to_ddl_col_type`], but refines an `Int8` result using
+/// the catalog's declared raw type string (`ColumnInfo::raw_type`), when
+/// present.
+///
+/// # Why only `Int8` is refined
+///
+/// `SqlDataType::Int64` is the single planner-facing type for every integer
+/// width — `SMALLINT`/`INT2`, `INTEGER`/`INT4`, and `BIGINT`/`INT8` all parse
+/// to it (see `catalog_adapter::type_convert::parse_type_str` and
+/// `nodedb_types::columnar::ColumnType::from_str`), because nodedb's
+/// storage — columnar, strict, and kv alike — always keeps integers as a
+/// full `i64`. The declared width therefore carries no storage or
+/// computation meaning; it is authoritative for exactly one thing: the wire
+/// type a pgwire client expects in `RowDescription`. A client that declared
+/// `SMALLINT` expects OID 21 (and, for binary-format results, a 2-byte
+/// value) — silently widening every integer to `BIGINT`'s OID 20 breaks ORMs
+/// and typed client libraries that trust the advertised OID (nodedb upstream
+/// issue #217). So this function narrows *display width only*, strictly
+/// downstream of `sql_data_type_to_ddl_col_type`'s own type mapping: every
+/// other `SqlDataType` variant (`String`, `Float64`, `Bool`, ...) passes
+/// through unchanged, with `raw` ignored, because there is no other
+/// wire-ambiguous case to resolve.
+///
+/// # Matching
+///
+/// `raw` is matched case-insensitively by keyword, using the same
+/// prefix-with-boundary logic as
+/// `pgwire::catalog::tables::collections::field_type_to_oid` (the
+/// already-correct reference implementation this mirrors): `BIGINT`/`INT8`
+/// are checked *first* so a plain `INT` prefix check can't accidentally
+/// swallow `INT8` (there is no separator between `INT` and `8` for the
+/// boundary check to reject). An unrecognized or absent `raw` leaves the
+/// base `Int8` untouched — refinement is best-effort, never a hard error.
+pub fn sql_data_type_to_ddl_col_type_with_raw(
+    ty: &nodedb_sql::types_expr::SqlDataType,
+    raw: Option<&str>,
+) -> super::types::DdlColType {
+    use super::types::DdlColType;
+
+    let base = sql_data_type_to_ddl_col_type(ty);
+    let (DdlColType::Int8, Some(raw)) = (base, raw) else {
+        return base;
+    };
+
+    let normalized = raw.trim().to_ascii_lowercase();
+    let starts_with_type = |name: &str| {
+        normalized == name
+            || normalized.strip_prefix(name).is_some_and(|rest| {
+                rest.starts_with('(') || rest.chars().next().is_some_and(char::is_whitespace)
+            })
+    };
+
+    if starts_with_type("bigint") || starts_with_type("int8") {
+        DdlColType::Int8
+    } else if starts_with_type("smallint") || starts_with_type("int2") {
+        DdlColType::Int2
+    } else if starts_with_type("integer") || starts_with_type("int4") || starts_with_type("int") {
+        DdlColType::Int4
+    } else {
+        DdlColType::Int8
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::super::types::DdlColType;
     use super::*;
     use nodedb_sql::types_expr::SqlDataType;
 
+    /// `sql_data_type_to_ddl_col_type_with_raw` must narrow an `Int64`
+    /// (base `Int8`) column to `Int4`/`Int2` when the catalog's declared raw
+    /// type string says the DDL author wrote a narrower integer keyword.
+    /// `BIGINT`/`INT8` stay `Int8`. Case-insensitive, matching every other
+    /// raw-type match in this codebase (e.g. `field_type_to_oid`).
+    #[test]
+    fn refine_narrows_int8_by_raw_integer_keyword() {
+        let cases: &[(&str, DdlColType)] = &[
+            ("BIGINT", DdlColType::Int8),
+            ("INT8", DdlColType::Int8),
+            ("INTEGER", DdlColType::Int4),
+            ("INT", DdlColType::Int4),
+            ("INT4", DdlColType::Int4),
+            ("SMALLINT", DdlColType::Int2),
+            ("INT2", DdlColType::Int2),
+        ];
+        for (raw, expected) in cases {
+            assert_eq!(
+                sql_data_type_to_ddl_col_type_with_raw(&SqlDataType::Int64, Some(raw)),
+                *expected,
+                "raw type {raw:?} must refine to {expected:?}"
+            );
+            // Case-insensitivity.
+            assert_eq!(
+                sql_data_type_to_ddl_col_type_with_raw(
+                    &SqlDataType::Int64,
+                    Some(&raw.to_lowercase())
+                ),
+                *expected,
+                "lowercase raw type {raw:?} must refine to {expected:?}"
+            );
+        }
+    }
+
+    /// A raw string that isn't a recognized integer keyword leaves the base
+    /// `Int8` untouched — the refinement is best-effort, never a hard error.
+    #[test]
+    fn refine_unrecognized_raw_keyword_stays_int8() {
+        assert_eq!(
+            sql_data_type_to_ddl_col_type_with_raw(&SqlDataType::Int64, Some("NOT_A_TYPE")),
+            DdlColType::Int8
+        );
+    }
+
+    /// `raw = None` (planner-synthesized columns, e.g. an auto-injected
+    /// `id`, carry no raw type) passes through to the unrefined base type.
+    #[test]
+    fn refine_with_no_raw_type_stays_base() {
+        assert_eq!(
+            sql_data_type_to_ddl_col_type_with_raw(&SqlDataType::Int64, None),
+            DdlColType::Int8
+        );
+    }
+
+    /// Only an `Int8` base is eligible for refinement — every other
+    /// `SqlDataType` passes through `sql_data_type_to_ddl_col_type` exactly,
+    /// with `raw` ignored even when it names an integer keyword (a raw type
+    /// string can never disagree with the planner's own resolved
+    /// `SqlDataType`, but this proves the fn doesn't misapply integer
+    /// narrowing to non-integer columns regardless).
+    #[test]
+    fn refine_passes_through_non_int8_types_untouched() {
+        assert_eq!(
+            sql_data_type_to_ddl_col_type_with_raw(&SqlDataType::String, Some("SMALLINT")),
+            DdlColType::Text
+        );
+        assert_eq!(
+            sql_data_type_to_ddl_col_type_with_raw(&SqlDataType::Float64, None),
+            DdlColType::Float8
+        );
+    }
+
     #[test]
     fn maps_every_sql_data_type_variant() {
         assert_eq!(

nodedb/tests/pgwire_ddl_result_types.rs

@@ -27,6 +27,8 @@ use tokio::net::TcpStream;
 /// PostgreSQL built-in type OIDs (stable, wire-level constants).
 const OID_TEXT: u32 = 25;
 const OID_INT8: u32 = 20;
+const OID_INT4: u32 = 23;
+const OID_INT2: u32 = 21;
 
 /// A decoded simple-query result: the `RowDescription` columns as
 /// `(name, type_oid)` pairs, plus each `DataRow`'s fields as raw text
@@ -262,3 +264,83 @@ async fn show_collections_row_description_preserves_int8_column() {
         "created_at INT8 value must round-trip as a decimal integer, got {created_at:?}"
     );
 }
+
+/// Upstream issue #217 repro: integer OID wire fidelity. A schemaless
+/// `CREATE COLLECTION` (no `WITH (engine=...)` clause) declaring every
+/// PostgreSQL integer width — `INT`, `INTEGER`, `INT4`, `BIGINT`, `INT8`,
+/// `SMALLINT`, `INT2` — must advertise each column's *own* wire OID in
+/// `RowDescription`: 23 (int4) for the 4-byte aliases, 20 (int8) for the
+/// 8-byte aliases, 21 (int2) for the 2-byte aliases. Before the fix, every
+/// declared width collapsed to `SqlDataType::Int64`'s single wire mapping —
+/// `INT`/`INTEGER`/`INT4`/`BIGINT`/`INT8` all rendered as OID 20 (int8), and
+/// `SMALLINT`/`INT2` (unlisted in the type-string parser) fell through to
+/// the `String` default and rendered as OID 25 (text) instead of an integer
+/// OID at all.
+#[tokio::test]
+async fn create_collection_int_widths_preserve_wire_oids() {
+    let server = TestServer::start().await;
+    server
+        .exec(
+            "CREATE COLLECTION fixprobe_ints (\
+                id TEXT PRIMARY KEY, \
+                a INT, \
+                b INTEGER, \
+                c INT4, \
+                d BIGINT, \
+                e INT8, \
+                f SMALLINT, \
+                g INT2\
+             )",
+        )
+        .await
+        .expect("CREATE COLLECTION fixprobe_ints must succeed");
+    server
+        .exec(
+            "INSERT INTO fixprobe_ints (id, a, b, c, d, e, f, g) \
+             VALUES ('r1', 1, 2, 3, 4, 5, 6, 7)",
+        )
+        .await
+        .expect("INSERT fixprobe_ints must succeed");
+
+    let res = raw_simple_query(
+        server.pg_port,
+        "SELECT id, a, b, c, d, e, f, g FROM fixprobe_ints",
+    )
+    .await;
+
+    let expected = vec![
+        ("id".to_string(), OID_TEXT),
+        ("a".to_string(), OID_INT4),
+        ("b".to_string(), OID_INT4),
+        ("c".to_string(), OID_INT4),
+        ("d".to_string(), OID_INT8),
+        ("e".to_string(), OID_INT8),
+        ("f".to_string(), OID_INT2),
+        ("g".to_string(), OID_INT2),
+    ];
+    assert_eq!(
+        res.columns, expected,
+        "fixprobe_ints RowDescription (name, OID) must preserve each declared \
+         integer width — INT/INTEGER/INT4 -> int4 (23), BIGINT/INT8 -> int8 (20), \
+         SMALLINT/INT2 -> int2 (21)"
+    );
+
+    let row = res
+        .rows
+        .first()
+        .unwrap_or_else(|| panic!("expected 1 row, got: {:?}", res.rows));
+    assert_eq!(
+        row,
+        &vec![
+            Some("r1".to_string()),
+            Some("1".to_string()),
+            Some("2".to_string()),
+            Some("3".to_string()),
+            Some("4".to_string()),
+            Some("5".to_string()),
+            Some("6".to_string()),
+            Some("7".to_string()),
+        ],
+        "fixprobe_ints row values must round-trip unchanged"
+    );
+}

nodedb/tests/pgwire_extended_query_engines.rs

@@ -194,10 +194,13 @@ async fn extended_query_columnar_typed_scan() {
     let id: &str = rows[0].get("id");
     assert_eq!(id, "r1");
 
-    // RowDescription: id→TEXT(25), n→INT8(20), score→FLOAT8(701), flag→BOOL(16), label→TEXT(25).
+    // RowDescription: id→TEXT(25), n→INT4(23), score→FLOAT8(701), flag→BOOL(16), label→TEXT(25).
+    // `n` is declared `INT` in the DDL above, which is the INT4 alias — issue
+    // #217 fixed this column advertising OID 20 (int8) for every declared
+    // integer width; it now correctly narrows to OID 23 (int4).
     let expected: &[(&str, u32)] = &[
         ("id", 25),
-        ("n", 20),
+        ("n", 23),
         ("score", 701),
         ("flag", 16),
         ("label", 25),