fix(sql): evaluate sequence-backed DEFAULTs on every engine

DEFAULT expressions were honored only where an engine happened to wire
them: uuid() worked on strict, silently vanished on schemaless document,
kv, and columnar; sequence defaults (nextval) did not run anywhere — the
pure planner evaluator does not know the accessors, and every engine path
swallowed "no value" into a missing column. #294's repro: DDL accepted
`DEFAULT nextval('s')`, every insert silently committed NULL (including
primary keys). This is one defect at two layers, fixed together:

1. Storage: the catalog adapter's schemaless branch discarded the DEFAULT
   clause even though `stored.fields` carries the full DDL constraint text
   (parse_column_type_str_full). UUID-class defaults on the document engine
   now materialize; the sql_suite "declared doc" behavior is unchanged.
2. Evaluation: one shared per-row expander (`expand_row_defaults`) now
   serves INSERT and UPSERT on the document family, the columnar batch
   encoder (rows.rs), and the kv converter — replacing three copies of the
   pure-evaluator swallow. Sequence accessors advance the CP-side registry
   through the ConvertContext; unknown sequences raise loudly naming them,
   never NULL.

Mechanics:
- SequenceRegistry threaded SharedState -> QueryContext -> ConvertContext
  (both planning construction sites).
- SqlPlan::KvInsert carries key_column + sequence_defaults; the kv planner
  skips sequence defaults (pure evaluator cannot run them) and the converter
  fills key slot + value map per row (named pk columns are mirrored into the
  value map so scans read them back).
- nodedb_value_to_sql relocated into value/convert for shared use.

Verified (wire `sequence_default_all_engines`, 6 tests, plus typed suite):
strict 1,2,3; document nextval 1,2; document uuid fills; document UPSERT
1,2; kv key 1,2 (mirrored, readable); kv unknown-sequence raises. Regression
sentinels green (kv_column_defaults, dml_returning_kv/insert, not-null gate).
fmt clean; clippy -D warnings clean; nodedb-sql 864 + nodedb-types 688.

Not included here (tracked separately): SELECT/currval/setval evaluation —
accessors stay unregistered so the gate keeps raising 42883 loudly; the
registry registration ships together with the SELECT-side fold so no commit
ever leaves a registered call folding to NULL.

Partially addresses #294.

Author: EnRaiha

nodedb-sql/src/planner/dml_helpers/kv_insert.rs

@@ -108,7 +108,10 @@ pub(crate) fn build_kv_insert_plan(
         // position in the statement's column list.
         let key_val = match row.iter().find(|(name, _)| name == key_col_name) {
             Some((_, value)) => value.clone(),
-            None => SqlValue::String(String::new()),
+            // NULL marks "key column absent from this row" — the converter
+            // fills a sequence default there, or stores the legacy empty key
+            // when none is declared.
+            None => SqlValue::Null,
         };
         if let Some((_, value)) = row.iter().find(|(name, _)| name == "ttl") {
             match value {
@@ -124,12 +127,23 @@ pub(crate) fn build_kv_insert_plan(
             .collect();
         entries.push((key_val, value_cols));
     }
+    let sequence_defaults: Vec<(String, String)> = declared_columns
+        .iter()
+        .filter_map(|c| {
+            c.default
+                .as_ref()
+                .filter(|d| is_sequence_default(d))
+                .map(|d| (c.name.clone(), d.clone()))
+        })
+        .collect();
     Ok(vec![SqlPlan::KvInsert {
         collection: table_name,
         entries,
         ttl_secs,
         intent,
         on_conflict_updates,
+        key_column: key_col_name.to_string(),
+        sequence_defaults,
     }])
 }
 
@@ -162,6 +176,12 @@ fn materialize_declared_defaults(
         if row.iter().any(|(name, _)| name == &column.name) {
             continue;
         }
+        // Sequence accessors cannot run in the pure planner evaluator; the
+        // converter advances the CP-side registry instead (the column is
+        // carried on the plan as a sequence default and stays absent here).
+        if is_sequence_default(default_expr) {
+            continue;
+        }
         let evaluated =
             crate::planner::defaults::evaluate_default_expr(default_expr).map_err(|e| {
                 SqlError::Parse {
@@ -211,6 +231,13 @@ fn nodedb_value_to_sql_value(column: &str, value: nodedb_types::Value) -> Result
     })
 }
 
+/// Whether a DEFAULT expression is a sequence accessor the pure planner
+/// evaluator cannot run. Mirrors the convert-side recognizer.
+fn is_sequence_default(expr: &str) -> bool {
+    let upper = expr.trim().to_uppercase();
+    upper.starts_with("NEXTVAL(") || upper.starts_with("SETVAL(") || upper.starts_with("CURRVAL(")
+}
+
 #[cfg(test)]
 mod kv_on_conflict_range_tests {
     use sqlparser::ast::{Expr, Value, ValueWithSpan};

nodedb-sql/src/types/plan/variants.rs

@@ -138,6 +138,12 @@ pub enum SqlPlan {
         /// Empty for plain UPSERT (whole-value overwrite) and for INSERT
         /// variants.
         on_conflict_updates: Vec<(String, SqlExpr)>,
+        /// The collection's primary-key column name (the KV key slot).
+        key_column: String,
+        /// Column defaults that are sequence accessors (`nextval(...)`) —
+        /// the pure planner evaluator cannot run them; the converter
+        /// advances the CP-side registry per row instead.
+        sequence_defaults: Vec<(String, String)>,
     },
     /// UPSERT: insert or merge if document exists.
     Upsert {

nodedb-sql/src/visitor/plan_visitor/dispatch.rs

@@ -113,7 +113,17 @@ pub fn dispatch<V: PlanVisitor>(visitor: &mut V, plan: &SqlPlan) -> Result<V::Ou
             ttl_secs,
             intent,
             on_conflict_updates,
-        } => visitor.kv_insert(collection, entries, *ttl_secs, *intent, on_conflict_updates),
+            key_column,
+            sequence_defaults,
+        } => visitor.kv_insert(
+            collection,
+            entries,
+            *ttl_secs,
+            *intent,
+            on_conflict_updates,
+            key_column,
+            sequence_defaults,
+        ),
         SqlPlan::Upsert {
             collection,
             engine,

nodedb-sql/src/visitor/plan_visitor/trait_def.rs

@@ -73,13 +73,16 @@ pub trait PlanVisitor {
     fn insert(&mut self, args: InsertVisitArgs<'_>) -> Result<Self::Output, Self::Error>;
 
     /// Handle [`SqlPlan::KvInsert`].
+    #[allow(clippy::too_many_arguments)]
     fn kv_insert(
         &mut self,
         collection: &str,
         entries: &[(SqlValue, Vec<(String, SqlValue)>)],
         ttl_secs: u64,
         intent: KvInsertIntent,
         on_conflict_updates: &[(String, SqlExpr)],
+        key_column: &str,
+        sequence_defaults: &[(String, String)],
     ) -> Result<Self::Output, Self::Error>;
 
     /// Handle [`SqlPlan::Upsert`].

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

@@ -61,12 +61,24 @@ pub(super) fn convert_collection_type(
                 .declared_primary_key
                 .clone()
                 .unwrap_or_else(|| "id".to_string());
+            // The stored field entry keeps the FULL DDL constraint text
+            // (`"BIGINT DEFAULT nextval('s') PRIMARY KEY"`), so the DEFAULT
+            // expression is recoverable even though the schemaless type
+            // system records no per-column default slot of its own. Dropping
+            // it here is what made `DEFAULT uuid_v7()` / `DEFAULT
+            // nextval('s')` silently commit NULL on the document engine
+            // (#294): the DDL accepted the expression, the catalog forgot it.
+            let pk_default = stored
+                .fields
+                .iter()
+                .find(|(n, _)| n.eq_ignore_ascii_case(&pk_name))
+                .and_then(|(_, ts)| doc_default_expr(ts));
             let mut columns = vec![ColumnInfo {
                 name: pk_name.clone(),
                 data_type: SqlDataType::String,
                 nullable: false,
                 is_primary_key: true,
-                default: None,
+                default: pk_default,
                 raw_type: None,
                 int_width: None,
                 float_width: None,
@@ -81,7 +93,7 @@ pub(super) fn convert_collection_type(
                     data_type: parse_type_str(type_str),
                     nullable: true,
                     is_primary_key: false,
-                    default: None,
+                    default: doc_default_expr(type_str),
                     raw_type: None,
                     int_width: IntWidth::from_declared_type(type_str),
                     float_width: FloatWidth::from_declared_type(type_str),
@@ -289,6 +301,12 @@ fn parse_type_str(s: &str) -> SqlDataType {
     }
 }
 
+fn doc_default_expr(type_str: &str) -> Option<String> {
+    let (_, _, _, default_expr) =
+        nodedb_sql::ddl_ast::collection_type::parse_column_type_str_full(type_str);
+    default_expr
+}
+
 #[cfg(test)]
 mod tests {
     use nodedb_types::CollectionType;

nodedb/src/control/planner/context/query/context.rs

@@ -40,6 +40,11 @@ pub struct QueryContext {
     /// `QueryContext::new()` test fixtures that never lower to
     /// surrogate-bearing variants.
     pub(super) surrogate_assigner: Option<Arc<crate::control::surrogate::SurrogateAssigner>>,
+    /// Sequence registry — `Some` when the planner has access to
+    /// `SharedState` (production path). SQL sequence accessors
+    /// (`nextval`/`currval`/`setval`) and sequence-backed DEFAULT
+    /// expressions evaluate through this; `None` for sub-planners.
+    pub(super) sequence_registry: Option<Arc<crate::control::sequence::SequenceRegistry>>,
     /// Cluster mode flag — `true` when the node has a live cluster
     /// topology. Passed into `ConvertContext` so array converters can
     /// emit `ClusterArray` variants instead of local `Array` variants.
@@ -109,6 +114,7 @@ impl QueryContext {
             array_catalog: None,
             wal: None,
             surrogate_assigner: None,
+            sequence_registry: None,
             cluster_enabled: false,
             bitemporal_retention_registry: None,
             max_vector_dim: std::sync::atomic::AtomicU32::new(0),
@@ -140,6 +146,7 @@ impl QueryContext {
             Some(Arc::clone(&state.retention_policy_registry)),
         );
         ctx.surrogate_assigner = Some(Arc::clone(&state.surrogate_assigner));
+        ctx.sequence_registry = Some(Arc::clone(&state.sequence_registry));
         ctx.cluster_enabled = state.cluster_topology.is_some();
         ctx.bitemporal_retention_registry = Some(Arc::clone(&state.bitemporal_retention_registry));
         // max_vector_dim starts at 0 (unlimited); connection handlers call
@@ -174,6 +181,7 @@ impl QueryContext {
             array_catalog: Some(state.array_catalog.clone()),
             wal: Some(Arc::clone(&state.wal)),
             surrogate_assigner: Some(Arc::clone(&state.surrogate_assigner)),
+            sequence_registry: Some(Arc::clone(&state.sequence_registry)),
             cluster_enabled: state.cluster_topology.is_some(),
             bitemporal_retention_registry: Some(Arc::clone(&state.bitemporal_retention_registry)),
             // max_vector_dim is tenant-specific; callers supply it via
@@ -215,6 +223,7 @@ impl QueryContext {
             array_catalog: None,
             wal: None,
             surrogate_assigner: None,
+            sequence_registry: None,
             cluster_enabled: false,
             bitemporal_retention_registry: None,
             max_vector_dim: std::sync::atomic::AtomicU32::new(0),

nodedb/src/control/planner/context/query/planning.rs

@@ -147,6 +147,7 @@ impl QueryContext {
                 .map(|i| Arc::clone(&i.credentials)),
             wal: self.wal.clone(),
             surrogate_assigner: self.surrogate_assigner.clone(),
+            sequence_registry: self.sequence_registry.clone(),
             cluster_enabled: self.cluster_enabled,
             bitemporal_retention_registry: self.bitemporal_retention_registry.clone(),
             max_vector_dim: self
@@ -412,6 +413,7 @@ impl QueryContext {
                 .map(|i| Arc::clone(&i.credentials)),
             wal: self.wal.clone(),
             surrogate_assigner: self.surrogate_assigner.clone(),
+            sequence_registry: self.sequence_registry.clone(),
             cluster_enabled: self.cluster_enabled,
             bitemporal_retention_registry: self.bitemporal_retention_registry.clone(),
             max_vector_dim: self

nodedb/src/control/planner/sql_plan_convert/array_fn_convert/aggregate.rs

@@ -144,6 +144,7 @@ mod tests {
             credentials: None,
             wal: None,
             surrogate_assigner: None,
+            sequence_registry: None,
             cluster_enabled,
             bitemporal_retention_registry: None,
             max_vector_dim: 0,

nodedb/src/control/planner/sql_plan_convert/array_fn_convert/slice.rs

@@ -246,6 +246,7 @@ mod tests {
             credentials: None,
             wal: None,
             surrogate_assigner: None,
+            sequence_registry: None,
             cluster_enabled,
             bitemporal_retention_registry: None,
             max_vector_dim: 0,

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

@@ -62,6 +62,9 @@ pub struct ConvertContext {
     pub credentials: Option<Arc<CredentialStore>>,
     /// LSN allocator for array Put/Delete dispatches.
     pub wal: Option<Arc<WalManager>>,
+    /// Sequence registry for SQL sequence accessors and sequence-backed
+    /// DEFAULT expressions. `None` for sub-planner contexts.
+    pub sequence_registry: Option<Arc<crate::control::sequence::SequenceRegistry>>,
     /// CP-side surrogate assigner — bound to the same `Arc` held on
     /// `SharedState`. Threaded into INSERT/UPSERT/KV-INSERT converters
     /// to bind `(collection, pk_bytes)` → `Surrogate` before the op
@@ -281,6 +284,7 @@ mod tests {
             credentials: None,
             wal: None,
             surrogate_assigner: Some(assigner),
+            sequence_registry: None,
             cluster_enabled: false,
             bitemporal_retention_registry: None,
             max_vector_dim: 0,