feat(sql): support constant queries without a FROM clause

Handle SELECT statements with no FROM clause (e.g. SELECT 1, SELECT
'hello' AS name, SELECT 1 + 2). The planner evaluates constant
expressions at planning time and emits a ConstantResult plan that
produces a single row without touching any engine.

- Add ConstantResult variant to SqlPlan with columns and values
- Evaluate literal, unary negation, and binary arithmetic/concat exprs
- Convert to a MetaOp::RawResponse physical task (zerompk-encoded)
- Dispatch RawResponse in the Data Plane executor without engine I/O
- Wire permission check (Read) for RawResponse tasks
- Handle ConstantResult in nodedb-lite query engine

Author: farhan-syah

nodedb-lite/src/query/engine.rs

@@ -81,6 +81,15 @@ impl<S: StorageEngine> LiteQueryEngine<S> {
 
     fn execute_plan(&self, plan: &SqlPlan) -> Result<QueryResult, LiteError> {
         match plan {
+            SqlPlan::ConstantResult { columns, values } => {
+                let row = values.iter().map(sql_value_to_value).collect();
+                Ok(QueryResult {
+                    columns: columns.clone(),
+                    rows: vec![row],
+                    rows_affected: 0,
+                })
+            }
+
             SqlPlan::Scan {
                 collection, engine, ..
             } => self.execute_scan(collection, engine),
@@ -286,6 +295,17 @@ fn sql_value_to_loro(v: &SqlValue) -> loro::LoroValue {
     }
 }
 
+fn sql_value_to_value(v: &nodedb_sql::types::SqlValue) -> Value {
+    match v {
+        nodedb_sql::types::SqlValue::Int(i) => Value::Integer(*i),
+        nodedb_sql::types::SqlValue::Float(f) => Value::Float(*f),
+        nodedb_sql::types::SqlValue::String(s) => Value::String(s.clone()),
+        nodedb_sql::types::SqlValue::Bool(b) => Value::Bool(*b),
+        nodedb_sql::types::SqlValue::Null => Value::Null,
+        _ => Value::Null,
+    }
+}
+
 fn loro_value_to_json(v: &loro::LoroValue) -> serde_json::Value {
     match v {
         loro::LoroValue::Null => serde_json::Value::Null,

nodedb-sql/src/planner/select.rs

@@ -59,12 +59,36 @@ fn plan_select(
     // 1. Resolve FROM tables.
     let scope = TableScope::resolve_from(catalog, &select.from)?;
 
-    // 2. Check for JOINs.
+    // 2. Handle constant queries (no FROM clause): SELECT 1, SELECT 'hello', etc.
+    if select.from.is_empty() {
+        let projection = convert_projection(&select.projection)?;
+        let mut columns = Vec::new();
+        let mut values = Vec::new();
+        for (i, proj) in projection.iter().enumerate() {
+            match proj {
+                Projection::Computed { expr, alias } => {
+                    columns.push(alias.clone());
+                    values.push(eval_constant_expr(expr));
+                }
+                Projection::Column(name) => {
+                    columns.push(name.clone());
+                    values.push(SqlValue::Null);
+                }
+                _ => {
+                    columns.push(format!("col{i}"));
+                    values.push(SqlValue::Null);
+                }
+            }
+        }
+        return Ok(SqlPlan::ConstantResult { columns, values });
+    }
+
+    // 3. Check for JOINs.
     if let Some(plan) = try_plan_join(select, &scope, catalog, functions)? {
         return Ok(plan);
     }
 
-    // 3. Single-table query.
+    // 4. Single-table query.
     let table = scope.single_table().ok_or_else(|| SqlError::Unsupported {
         detail: "multi-table FROM without JOIN".into(),
     })?;
@@ -589,6 +613,38 @@ fn extract_func_args(func: &ast::Function) -> Result<Vec<ast::Expr>> {
     }
 }
 
+/// Evaluate a constant SqlExpr to a SqlValue.
+fn eval_constant_expr(expr: &SqlExpr) -> SqlValue {
+    match expr {
+        SqlExpr::Literal(v) => v.clone(),
+        SqlExpr::UnaryOp {
+            op: UnaryOp::Neg,
+            expr,
+        } => match eval_constant_expr(expr) {
+            SqlValue::Int(i) => SqlValue::Int(-i),
+            SqlValue::Float(f) => SqlValue::Float(-f),
+            other => other,
+        },
+        SqlExpr::BinaryOp { left, op, right } => {
+            let l = eval_constant_expr(left);
+            let r = eval_constant_expr(right);
+            match (l, op, r) {
+                (SqlValue::Int(a), BinaryOp::Add, SqlValue::Int(b)) => SqlValue::Int(a + b),
+                (SqlValue::Int(a), BinaryOp::Sub, SqlValue::Int(b)) => SqlValue::Int(a - b),
+                (SqlValue::Int(a), BinaryOp::Mul, SqlValue::Int(b)) => SqlValue::Int(a * b),
+                (SqlValue::Float(a), BinaryOp::Add, SqlValue::Float(b)) => SqlValue::Float(a + b),
+                (SqlValue::Float(a), BinaryOp::Sub, SqlValue::Float(b)) => SqlValue::Float(a - b),
+                (SqlValue::Float(a), BinaryOp::Mul, SqlValue::Float(b)) => SqlValue::Float(a * b),
+                (SqlValue::String(a), BinaryOp::Concat, SqlValue::String(b)) => {
+                    SqlValue::String(format!("{a}{b}"))
+                }
+                _ => SqlValue::Null,
+            }
+        }
+        _ => SqlValue::Null,
+    }
+}
+
 fn extract_column_name(expr: &ast::Expr) -> Result<String> {
     match expr {
         ast::Expr::Identifier(ident) => Ok(normalize_ident(ident)),

nodedb-sql/src/types.rs

@@ -6,6 +6,14 @@
 /// The top-level plan produced by the SQL planner.
 #[derive(Debug, Clone)]
 pub enum SqlPlan {
+    // ── Constant ──
+    /// Query with no FROM clause: SELECT 1, SELECT 'hello' AS name, etc.
+    /// Produces a single row with evaluated constant expressions.
+    ConstantResult {
+        columns: Vec<String>,
+        values: Vec<SqlValue>,
+    },
+
     // ── Reads ──
     Scan {
         collection: String,

nodedb/src/bridge/physical_plan/meta.rs

@@ -70,6 +70,10 @@ pub enum MetaOp {
         source_collection: String,
     },
 
+    /// Pre-computed response payload. The Data Plane echoes it back without
+    /// touching any engine. Used for constant queries (SELECT 1 AS value).
+    RawResponse { payload: Vec<u8> },
+
     /// Purge ALL data for a tenant across every engine and cache.
     ///
     /// Deletes documents, indexes, vectors, graph edges, timeseries,

nodedb/src/control/planner/sql_plan_convert.rs

@@ -41,6 +41,25 @@ fn convert_one(
     ctx: &ConvertContext,
 ) -> crate::Result<Vec<PhysicalTask>> {
     match plan {
+        SqlPlan::ConstantResult { columns, values } => {
+            // Build a single-row result as Value::Object → zerompk.
+            let mut map = std::collections::HashMap::new();
+            for (col, val) in columns.iter().zip(values.iter()) {
+                map.insert(col.clone(), sql_value_to_nodedb_value(val));
+            }
+            let row = nodedb_types::Value::Object(map);
+            let payload =
+                nodedb_types::value_to_msgpack(&row).map_err(|e| crate::Error::Serialization {
+                    format: "msgpack".into(),
+                    detail: format!("constant result: {e}"),
+                })?;
+            Ok(vec![PhysicalTask {
+                tenant_id,
+                vshard_id: VShardId::from_collection(""),
+                plan: PhysicalPlan::Meta(MetaOp::RawResponse { payload }),
+            }])
+        }
+
         SqlPlan::Scan {
             collection,
             engine,

nodedb/src/control/security/identity.rs

@@ -281,6 +281,9 @@ pub fn required_permission(plan: &crate::bridge::envelope::PhysicalPlan) -> Perm
             | VectorOp::Rebuild { .. },
         ) => Permission::Alter,
 
+        // Pre-computed responses (constant queries like SELECT 1).
+        PhysicalPlan::Meta(MetaOp::RawResponse { .. }) => Permission::Read,
+
         // Control operations.
         PhysicalPlan::Meta(MetaOp::Cancel { .. }) => Permission::Admin,
 

nodedb/src/data/executor/dispatch/other.rs

@@ -363,6 +363,10 @@ impl CoreLoop {
                 }
             }
 
+            PhysicalPlan::Meta(MetaOp::RawResponse { payload }) => {
+                self.response_with_payload(task, payload.clone())
+            }
+
             PhysicalPlan::Meta(MetaOp::QueryLastValue {
                 collection,
                 series_id,