Merge pull request #394 from lovasoa/function_post_result

function post result

Author: lovasoa

.github/workflows/ci.yml

@@ -52,6 +52,7 @@ jobs:
         env:
           DATABASE_URL: ${{ matrix.database }}://root:[email protected]/sqlpage
           RUST_BACKTRACE: 1
+          RUST_LOG: sqlpage=debug
 
   windows_test:
     runs-on: windows-latest

CHANGELOG.md

@@ -8,6 +8,8 @@
  - Added a [new example](https://github.com/lovasoa/SQLpage/tree/main/examples/CRUD%20-%20Authentication) to the documentation
  - Bug fix: points with a latitude of 0 are now displayed correctly on the map component. 
  - Bug fix: in sqlite, lower(NULL) now returns NULL instead of an empty string. This is consistent with the standard behavior of lower() in other databases. SQLPage has its own implementation of lower() that supports unicode characters, and our implementation now matches the standard behavior of lower() in mainstream SQLite. 
+ - Allow passing data from the database to sqlpage functions. This fixes most errors like: `Arbitrary SQL expressions as function arguments are not supported.`.
+ - Better error messages in the dynamic component when properties are missing.
 
 ## 0.24.0 (2024-06-23)
  - in the form component, searchable `select` fields now support more than 50 options. They used to display only the first 50 options. 

src/dynamic_component.rs

@@ -21,11 +21,17 @@ impl Iterator for DynamicComponentIterator {
     fn next(&mut self) -> Option<Self::Item> {
         if let Some(db_item) = self.db_item.take() {
             if let DbItem::Row(mut row) = db_item {
-                if let Some(properties) = extract_dynamic_properties(&mut row) {
-                    self.stack = dynamic_properties_to_vec(properties);
-                } else {
-                    // Most common case: just a regular row. We allocated nothing.
-                    return Some(DbItem::Row(row));
+                match extract_dynamic_properties(&mut row) {
+                    Ok(None) => {
+                        // Most common case: just a regular row. We allocated nothing.
+                        return Some(DbItem::Row(row));
+                    }
+                    Ok(Some(properties)) => {
+                        self.stack = dynamic_properties_to_vec(properties);
+                    }
+                    Err(err) => {
+                        return Some(DbItem::Error(err));
+                    }
                 }
             } else {
                 return Some(db_item);
@@ -41,29 +47,47 @@ impl Iterator for DynamicComponentIterator {
 
 fn expand_dynamic_stack(stack: &mut Vec<anyhow::Result<JsonValue>>) {
     while let Some(mut next) = stack.pop() {
-        let dyn_props = next.as_mut().ok().and_then(extract_dynamic_properties);
-        if let Some(properties) = dyn_props {
-            // if the properties contain new (nested) dynamic components, push them onto the stack
-            stack.extend(dynamic_properties_to_vec(properties));
+        let next_value = next.as_mut().ok();
+        // .and_then(extract_dynamic_properties);
+        let dyn_props = if let Some(val) = next_value {
+            extract_dynamic_properties(val)
         } else {
-            // If the properties are not dynamic, push the row back onto the stack
-            stack.push(next);
-            // return at the first non-dynamic row
-            // we don't support non-dynamic rows after dynamic rows nested in the same array
-            return;
+            Ok(None)
+        };
+        match dyn_props {
+            Ok(None) => {
+                // If the properties are not dynamic, push the row back onto the stack
+                stack.push(next);
+                // return at the first non-dynamic row
+                // we don't support non-dynamic rows after dynamic rows nested in the same array
+                return;
+            }
+            Ok(Some(properties)) => {
+                // if the properties contain new (nested) dynamic components, push them onto the stack
+                stack.extend(dynamic_properties_to_vec(properties));
+            }
+            Err(err) => {
+                // if an error occurs, push it onto the stack
+                stack.push(Err(err));
+            }
         }
     }
 }
 
 /// if row.component == 'dynamic', return Some(row.properties), otherwise return None
 #[inline]
-fn extract_dynamic_properties(data: &mut JsonValue) -> Option<JsonValue> {
+fn extract_dynamic_properties(data: &mut JsonValue) -> anyhow::Result<Option<JsonValue>> {
     let component = data.get("component").and_then(|v| v.as_str());
     if component == Some("dynamic") {
-        let properties = data.get_mut("properties").map(JsonValue::take);
-        Some(properties.unwrap_or_default())
+        let Some(properties) = data.get_mut("properties").map(JsonValue::take) else {
+            anyhow::bail!(
+                "The dynamic component requires a property named \"properties\". \
+                Instead, it received the following: {data}"
+            );
+        };
+        Ok(Some(properties))
     } else {
-        None
+        Ok(None)
     }
 }
 

src/webserver/database/execute_queries.rs

@@ -6,7 +6,9 @@ use std::collections::HashMap;
 use std::pin::Pin;
 
 use super::csv_import::run_csv_import;
-use super::sql::{ParsedSqlFile, ParsedStatement, SimpleSelectValue, StmtWithParams};
+use super::sql::{
+    DelayedFunctionCall, ParsedSqlFile, ParsedStatement, SimpleSelectValue, StmtWithParams,
+};
 use crate::dynamic_component::parse_dynamic_rows;
 use crate::utils::add_value_to_map;
 use crate::webserver::database::sql_to_json::row_to_string;
@@ -55,7 +57,9 @@ pub fn stream_query_results_with_conn<'a>(
                     let mut stream = connection.fetch_many(query);
                     while let Some(elem) = stream.next().await {
                         let is_err = elem.is_err();
-                        for i in parse_dynamic_rows(parse_single_sql_result(&stmt.query, elem)) {
+                        let mut query_result = parse_single_sql_result(&stmt.query, elem);
+                        apply_delayed_functions(request, &stmt.delayed_functions, &mut query_result).await?;
+                        for i in parse_dynamic_rows(query_result) {
                             yield i;
                         }
                         if is_err {
@@ -271,6 +275,56 @@ async fn bind_parameters<'a, 'b>(
     Ok(StatementWithParams { sql, arguments })
 }
 
+async fn apply_delayed_functions(
+    request: &RequestInfo,
+    delayed_functions: &[DelayedFunctionCall],
+    item: &mut DbItem,
+) -> anyhow::Result<()> {
+    // We need to open new connections for each delayed function call, because we are still fetching the results of the current query in the main connection.
+    let mut db_conn = None;
+    if let DbItem::Row(serde_json::Value::Object(ref mut results)) = item {
+        for f in delayed_functions {
+            log::trace!("Applying delayed function {} to {:?}", f.function, results);
+            apply_single_delayed_function(request, &mut db_conn, f, results).await?;
+            log::trace!(
+                "Delayed function applied {}. Result: {:?}",
+                f.function,
+                results
+            );
+        }
+    }
+    Ok(())
+}
+
+async fn apply_single_delayed_function(
+    request: &RequestInfo,
+    db_connection: &mut DbConn,
+    f: &DelayedFunctionCall,
+    row: &mut serde_json::Map<String, serde_json::Value>,
+) -> anyhow::Result<()> {
+    let mut params = Vec::new();
+    for arg in &f.argument_col_names {
+        let Some(arg_value) = row.remove(arg) else {
+            anyhow::bail!("The column {arg} is missing in the result set, but it is required by the {} function.", f.function);
+        };
+        params.push(json_to_fn_param(arg_value));
+    }
+    let result_str = f.function.evaluate(request, db_connection, params).await?;
+    let result_json = result_str
+        .map(Cow::into_owned)
+        .map_or(serde_json::Value::Null, serde_json::Value::String);
+    row.insert(f.target_col_name.clone(), result_json);
+    Ok(())
+}
+
+fn json_to_fn_param(json: serde_json::Value) -> Option<Cow<'static, str>> {
+    match json {
+        serde_json::Value::String(s) => Some(Cow::Owned(s)),
+        serde_json::Value::Null => None,
+        _ => Some(Cow::Owned(json.to_string())),
+    }
+}
+
 pub struct StatementWithParams<'a> {
     sql: &'a str,
     arguments: AnyArguments<'a>,