fix(sql): honor declared float width across DDL, DML, and pgwire

REAL/FLOAT4/FLOAT8/DOUBLE PRECISION and their PostgreSQL aliases were
rejected as unknown column types, and even where declared, values on
untyped write paths (KV, document-schemaless) were stored as decimal
text and silently dropped by the pgwire encoder. Add a FloatWidth type
mirroring IntWidth (shared declared-type keyword matching factored
into declared_type_keyword.rs), coerce float/int literals to their
declared representation before storage, and narrow floats on the wire
with an overflow-only error, so RowDescription OIDs, catalog
introspection, and encoded values all agree with the declared width.

Author: farhan-syah

nodedb-sql/src/placeholder_types/slots.rs

@@ -3,28 +3,32 @@
 //! Per-position inference state: the slot table, its conflict rule, and the
 //! parsing of a `$N` placeholder body into a position.
 
-use nodedb_types::columnar::IntWidth;
+use nodedb_types::columnar::{FloatWidth, IntWidth};
 use sqlparser::ast::{Expr, Value, ValueWithSpan};
 
 use crate::types::ColumnInfo;
 use crate::types_expr::SqlDataType;
 
 /// A parameter type the statement pins down.
 ///
-/// Carries the declared integer width alongside the logical type because the
+/// Carries the declared numeric width alongside the logical type because the
 /// two are not interchangeable on the wire: a column declared `INT` must be
-/// advertised as `int4` (OID 23), not `int8` (OID 20). The client encodes its
-/// bind value at exactly the width the `ParameterDescription` names, so
-/// collapsing every integer to `int8` here would put a 4-byte column behind an
-/// 8-byte promise — the precise failure the catalog's resolved [`IntWidth`]
-/// exists to prevent.
+/// advertised as `int4` (OID 23), not `int8` (OID 20), and one declared `REAL`
+/// as `float4` (OID 700), not `float8` (OID 701). The client encodes its bind
+/// value at exactly the width the `ParameterDescription` names, so collapsing
+/// every integer to `int8` or every float to `float8` here would put a 4-byte
+/// column behind an 8-byte promise — the precise failure the catalog's
+/// resolved [`IntWidth`] / [`FloatWidth`] exist to prevent.
 #[derive(Debug, Clone, PartialEq)]
 pub struct InferredParamType {
     /// The logical type this position resolves to.
     pub data_type: SqlDataType,
     /// Declared width for an integer position, or `None` when the form that
     /// resolved it had no catalog column behind it.
     pub int_width: Option<IntWidth>,
+    /// Declared width for a floating-point position, or `None` when the form
+    /// that resolved it had no catalog column behind it.
+    pub float_width: Option<FloatWidth>,
 }
 
 impl InferredParamType {
@@ -38,6 +42,7 @@ impl InferredParamType {
         Self {
             data_type,
             int_width: None,
+            float_width: None,
         }
     }
 
@@ -47,6 +52,7 @@ impl InferredParamType {
         Self {
             data_type: column.data_type.clone(),
             int_width: column.int_width,
+            float_width: column.float_width,
         }
     }
 }

nodedb-sql/src/placeholder_types/tests.rs

@@ -3,7 +3,7 @@
 //! Unit tests for `$N` placeholder type inference.
 
 use nodedb_types::DatabaseId;
-use nodedb_types::columnar::IntWidth;
+use nodedb_types::columnar::{FloatWidth, IntWidth};
 
 use super::infer_placeholder_types;
 use super::slots::{InferredParamType, parse_placeholder_body};
@@ -24,6 +24,18 @@ fn col(name: &str, data_type: SqlDataType, int_width: Option<IntWidth>) -> Colum
         default: None,
         raw_type: None,
         int_width,
+        float_width: None,
+    }
+}
+
+/// A float column with a declared width — the float analogue of `col`'s
+/// `int_width` argument. Separate because the two families never co-occur on
+/// one column, so widening `col` with a fourth argument would make every
+/// integer and string call site carry a `None` it can never set.
+fn float_col(name: &str, float_width: FloatWidth) -> ColumnInfo {
+    ColumnInfo {
+        float_width: Some(float_width),
+        ..col(name, SqlDataType::Float64, None)
     }
 }
 
@@ -62,6 +74,8 @@ impl SqlCatalog for TestCatalog {
                     col("big", SqlDataType::Int64, Some(IntWidth::I64)),
                     col("label", SqlDataType::String, None),
                     col("flag", SqlDataType::Bool, None),
+                    float_col("ratio", FloatWidth::F32),
+                    float_col("wide", FloatWidth::F64),
                 ],
             )),
             // Two relations sharing a column name: the ambiguity lock.
@@ -100,14 +114,25 @@ fn from_sql(data_type: SqlDataType) -> Option<InferredParamType> {
     Some(InferredParamType {
         data_type,
         int_width: None,
+        float_width: None,
     })
 }
 
-/// A type taken from a catalog column, declared width included.
+/// A type taken from a catalog column, declared integer width included.
 fn from_col(data_type: SqlDataType, int_width: Option<IntWidth>) -> Option<InferredParamType> {
     Some(InferredParamType {
         data_type,
         int_width,
+        float_width: None,
+    })
+}
+
+/// A type taken from a catalog float column, declared float width included.
+fn from_float_col(float_width: FloatWidth) -> Option<InferredParamType> {
+    Some(InferredParamType {
+        data_type: SqlDataType::Float64,
+        int_width: None,
+        float_width: Some(float_width),
     })
 }
 
@@ -309,6 +334,21 @@ fn where_comparison_resolves_column_type_and_width() {
     );
 }
 
+/// The float analogue: a `REAL` column must carry its declared `F32` width so
+/// the caller advertises oid 700 and the client encodes four bytes, while a
+/// `DOUBLE` column stays `F64` (oid 701).
+#[test]
+fn where_comparison_resolves_declared_float_width() {
+    assert_eq!(
+        infer("SELECT id FROM t WHERE ratio = $1"),
+        vec![from_float_col(FloatWidth::F32)]
+    );
+    assert_eq!(
+        infer("SELECT id FROM t WHERE wide = $1"),
+        vec![from_float_col(FloatWidth::F64)]
+    );
+}
+
 /// `$1 = col` is the same form with the operands swapped.
 #[test]
 fn reversed_operand_order_resolves() {
@@ -418,17 +458,22 @@ fn insert_multi_row_values_map_each_row() {
 }
 
 /// No explicit column list: positional against the declared column order,
-/// which is only meaningful when the arity matches it exactly.
+/// which is only meaningful when the arity matches it exactly. `t` declares
+/// seven columns, so seven values are required for the mapping to apply —
+/// the two trailing float columns also pin that declared float width rides
+/// along the same positional path as integer width.
 #[test]
 fn insert_without_column_list_maps_against_declared_order() {
     assert_eq!(
-        infer("INSERT INTO t VALUES ($1, $2, $3, $4, $5)"),
+        infer("INSERT INTO t VALUES ($1, $2, $3, $4, $5, $6, $7)"),
         vec![
             from_col(SqlDataType::String, None),
             from_col(SqlDataType::Int64, Some(IntWidth::I32)),
             from_col(SqlDataType::Int64, Some(IntWidth::I64)),
             from_col(SqlDataType::String, None),
             from_col(SqlDataType::Bool, None),
+            from_float_col(FloatWidth::F32),
+            from_float_col(FloatWidth::F64),
         ]
     );
 }