Local execution of simple static SET commands

`SET x = 'hello'` is now executed locally by SQLPage and does not send anything to the database. This completely removes the cost of extracting static values into variables for cleaner SQL files.

Author: lovasoa

CHANGELOG.md

@@ -19,6 +19,7 @@
    - Output formats: hexadecimal (default) or base64 (e.g., `sha256-base64`)
    - See the [function documentation](https://sql-page.com/functions.sql?function=hmac) for detailed examples
  - Fixed a slight spacing issue in the list components empty value display.
+ - Improved performance of setting a variable to a literal value. `SET x = 'hello'` is now executed locally by SQLPage and does not send anything to the database. This completely removes the cost of extracting static values into variables for cleaner SQL files.
 
 ## v0.37.1
  - fixed decoding of UUID values

src/webserver/database/execute_queries.rs

@@ -86,6 +86,12 @@ pub fn stream_query_results_with_conn<'a>(
                         format!("Failed to set the {variable} variable to {value:?}")
                     )?;
                 },
+                ParsedStatement::StaticSimpleSet { variable, value} => {
+                    execute_set_simple_static(db_connection, request, variable, value, source_file).await
+                    .with_context(||
+                        format!("Failed to set the {variable} variable to {value:?}")
+                    )?;
+                },
                 ParsedStatement::StaticSimpleSelect(value) => {
                     for i in parse_dynamic_rows(DbItem::Row(exec_static_simple_select(value, request, db_connection).await?)) {
                         yield i;
@@ -214,6 +220,38 @@ async fn execute_set_variable_query<'a>(
     Ok(())
 }
 
+async fn execute_set_simple_static<'a>(
+    db_connection: &'a mut DbConn,
+    request: &'a mut RequestInfo,
+    variable: &StmtParam,
+    value: &SimpleSelectValue,
+    _source_file: &Path,
+) -> anyhow::Result<()> {
+    let value_str = match value {
+        SimpleSelectValue::Static(json_value) => match json_value {
+            serde_json::Value::Null => None,
+            serde_json::Value::String(s) => Some(s.clone()),
+            other => Some(other.to_string()),
+        },
+        SimpleSelectValue::Dynamic(stmt_param) => {
+            extract_req_param(stmt_param, request, db_connection)
+                .await?
+                .map(std::borrow::Cow::into_owned)
+        }
+    };
+
+    let (vars, name) = vars_and_name(request, variable)?;
+
+    if let Some(value) = value_str {
+        log::debug!("Setting variable {name} to static value {value:?}");
+        vars.insert(name.to_owned(), SingleOrVec::Single(value));
+    } else {
+        log::debug!("Removing variable {name} because it was set to the literal value NULL");
+        vars.remove(name);
+    }
+    Ok(())
+}
+
 fn vars_and_name<'a, 'b>(
     request: &'a mut RequestInfo,
     variable: &'b StmtParam,

src/webserver/database/sql.rs

@@ -111,6 +111,10 @@ pub(super) enum ParsedStatement {
         variable: StmtParam,
         value: StmtWithParams,
     },
+    StaticSimpleSet {
+        variable: StmtParam,
+        value: SimpleSelectValue,
+    },
     CsvImport(CsvImport),
     Error(anyhow::Error),
 }
@@ -142,6 +146,7 @@ fn parse_sql<'a>(
             return None;
         }
         let statement = parse_single_statement(&mut parser, db_info, sql);
+        log::debug!("Parsed statement: {statement:?}");
         if let Some(ParsedStatement::Error(_)) = &statement {
             has_error = true;
         }
@@ -182,7 +187,6 @@ fn parse_single_statement(
         Ok(stmt) => stmt,
         Err(err) => return Some(syntax_error(err, parser, source_sql)),
     };
-    log::debug!("Parsed statement: {stmt}");
     let mut semicolon = false;
     while parser.consume_token(&SemiColon) {
         semicolon = true;
@@ -404,40 +408,10 @@ fn extract_static_simple_select(
     let mut items = Vec::with_capacity(select_items.len());
     let mut params_iter = params.iter().cloned();
     for select_item in select_items {
-        use serde_json::Value::{Bool, Null, Number, String};
-        use SimpleSelectValue::{Dynamic, Static};
         let sqlparser::ast::SelectItem::ExprWithAlias { expr, alias } = select_item else {
             return None;
         };
-        let value = match expr {
-            Expr::Value(ValueWithSpan {
-                value: Value::Boolean(b),
-                ..
-            }) => Static(Bool(*b)),
-            Expr::Value(ValueWithSpan {
-                value: Value::Number(n, _),
-                ..
-            }) => Static(Number(n.parse().ok()?)),
-            Expr::Value(ValueWithSpan {
-                value: Value::SingleQuotedString(s),
-                ..
-            }) => Static(String(s.clone())),
-            Expr::Value(ValueWithSpan {
-                value: Value::Null, ..
-            }) => Static(Null),
-            e if is_simple_select_placeholder(e) => {
-                if let Some(p) = params_iter.next() {
-                    Dynamic(p)
-                } else {
-                    log::error!("Parameter not extracted for placehorder: {expr:?}");
-                    return None;
-                }
-            }
-            other => {
-                log::trace!("Cancelling simple select optimization because of expr: {other:?}");
-                return None;
-            }
-        };
+        let value = expr_to_simple_select_val(&mut params_iter, expr)?;
         let key = alias.value.clone();
         items.push((key, value));
     }
@@ -448,6 +422,43 @@ fn extract_static_simple_select(
     Some(items)
 }
 
+fn expr_to_simple_select_val(
+    params_iter: &mut impl Iterator<Item = StmtParam>,
+    expr: &Expr,
+) -> Option<SimpleSelectValue> {
+    use serde_json::Value::{Bool, Null, Number, String};
+    use SimpleSelectValue::{Dynamic, Static};
+    Some(match expr {
+        Expr::Value(ValueWithSpan {
+            value: Value::Boolean(b),
+            ..
+        }) => Static(Bool(*b)),
+        Expr::Value(ValueWithSpan {
+            value: Value::Number(n, _),
+            ..
+        }) => Static(Number(n.parse().ok()?)),
+        Expr::Value(ValueWithSpan {
+            value: Value::SingleQuotedString(s),
+            ..
+        }) => Static(String(s.clone())),
+        Expr::Value(ValueWithSpan {
+            value: Value::Null, ..
+        }) => Static(Null),
+        e if is_simple_select_placeholder(e) => {
+            if let Some(p) = params_iter.next() {
+                Dynamic(p)
+            } else {
+                log::error!("Parameter not extracted for placehorder: {expr:?}");
+                return None;
+            }
+        }
+        other => {
+            log::trace!("Cancelling simple select optimization because of expr: {other:?}");
+            return None;
+        }
+    })
+}
+
 fn is_simple_select_placeholder(e: &Expr) -> bool {
     match e {
         Expr::Value(ValueWithSpan {
@@ -485,6 +496,11 @@ fn extract_set_variable(
                 StmtParam::PostOrGet(std::mem::take(&mut ident.value))
             };
             let owned_expr = std::mem::replace(value, Expr::value(Value::Null));
+            let mut params_iter = params.iter().cloned();
+            if let Some(value) = expr_to_simple_select_val(&mut params_iter, &owned_expr) {
+                return Some(ParsedStatement::StaticSimpleSet { variable, value });
+            }
+
             let mut select_stmt: Statement = expr_to_statement(owned_expr);
             let delayed_functions = extract_toplevel_functions(&mut select_stmt);
             if let Err(err) = validate_function_calls(&select_stmt) {
@@ -1248,26 +1264,24 @@ mod test {
     }
 
     #[test]
-    fn test_set_variable() {
+    fn test_set_variable_to_other_variable() {
         let sql = "set x = $y";
         for &(dialect, dbms) in ALL_DIALECTS {
             let mut parser = Parser::new(dialect).try_with_sql(sql).unwrap();
             let db_info = create_test_db_info(dbms);
-            let stmt = parse_single_statement(&mut parser, &db_info, sql);
-            if let Some(ParsedStatement::SetVariable {
-                variable,
-                value: StmtWithParams { query, params, .. },
-            }) = stmt
-            {
-                assert_eq!(
-                    variable,
-                    StmtParam::PostOrGet("x".to_string()),
-                    "{dialect:?}"
-                );
-                assert!(query.starts_with("SELECT "));
-                assert_eq!(params, [StmtParam::PostOrGet("y".to_string())]);
-            } else {
-                panic!("Failed for dialect {dialect:?}: {stmt:#?}",);
+            match parse_single_statement(&mut parser, &db_info, sql) {
+                Some(ParsedStatement::StaticSimpleSet { variable, value }) => {
+                    assert_eq!(
+                        variable,
+                        StmtParam::PostOrGet("x".to_string()),
+                        "{dialect:?}"
+                    );
+                    assert_eq!(
+                        value,
+                        SimpleSelectValue::Dynamic(StmtParam::PostOrGet("y".to_string()))
+                    );
+                }
+                other => panic!("Failed for dialect {dialect:?}: {other:#?}"),
             }
         }
     }
@@ -1398,7 +1412,7 @@ mod test {
 
     #[test]
     fn test_extract_set_variable() {
-        let sql = "set x = 42";
+        let sql = "set x = CURRENT_TIMESTAMP";
         for &(dialect, dbms) in ALL_DIALECTS {
             let mut parser = Parser::new(dialect).try_with_sql(sql).unwrap();
             let db_info = create_test_db_info(dbms);
@@ -1413,14 +1427,33 @@ mod test {
                     StmtParam::PostOrGet("x".to_string()),
                     "{dialect:?}"
                 );
-                assert_eq!(query, "SELECT 42 AS sqlpage_set_expr");
+                assert_eq!(query, "SELECT CURRENT_TIMESTAMP AS sqlpage_set_expr");
                 assert!(params.is_empty());
             } else {
                 panic!("Failed for dialect {dialect:?}: {stmt:#?}",);
             }
         }
     }
 
+    #[test]
+    fn test_extract_set_variable_static() {
+        let sql = "set x = 'hello'";
+        for &(dialect, dbms) in ALL_DIALECTS {
+            let mut parser = Parser::new(dialect).try_with_sql(sql).unwrap();
+            let db_info = create_test_db_info(dbms);
+            match parse_single_statement(&mut parser, &db_info, sql) {
+                Some(ParsedStatement::StaticSimpleSet {
+                    variable: StmtParam::PostOrGet(var_name),
+                    value: SimpleSelectValue::Static(value),
+                }) => {
+                    assert_eq!(var_name, "x");
+                    assert_eq!(value, "hello");
+                }
+                other => panic!("Failed for dialect {dialect:?}: {other:#?}"),
+            }
+        }
+    }
+
     #[test]
     fn test_static_extract_doesnt_match() {
         assert_eq!(