flowcode-core 0.4.3-alpha

Core execution engine for FlowCode data scripting language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

#[cfg(test)]
#[cfg(feature = "duckdb")]
mod tests {
    use crate::duckdb_session::DuckSession;
    use crate::types::TypedValue;
    use crate::ast::ArgValue;
    use crate::duckdb_verbs::map_verb_to_sql;
    use std::path::PathBuf;

    #[test]
    fn test_sql_direct_query() {
        let session = DuckSession::new().expect("Failed to create DuckSession");
        let query = TypedValue {
            kind: crate::types::ValueKind::String,
            value: ArgValue::String("SELECT 42 AS answer".to_string()),
        };
        let args = vec![query];

        let result = map_verb_to_sql("sql", &args, &session);
        assert!(result.is_ok());
        let sql_query = result.unwrap();
        assert_eq!(sql_query, "SELECT 42 AS answer");

        // Execute the query to ensure it works end-to-end
        let query_result = session.execute_sql(&sql_query);
        assert!(query_result.is_ok());
        let typed_value = query_result.unwrap();
        if let ArgValue::Table(table) = typed_value.value {
            assert_eq!(table.data.len(), 1);
            assert_eq!(table.data[0].len(), 1);
            if let ArgValue::Number(n) = &table.data[0][0].value {
                assert_eq!(*n, 42.0);
            } else {
                panic!("Expected a number in the result");
            }
        } else {
            panic!("Expected a table result from SQL query");
        }
    }

    #[test]
    fn test_sql_empty_query() {
        let session = DuckSession::new().expect("Failed to create DuckSession");
        let args = vec![];

        let result = map_verb_to_sql("sql", &args, &session);
        assert!(result.is_err());
        if let Err(e) = result {
            assert!(e.to_string().contains("sql command requires a query string"));
        }
    }

    #[test]
    fn test_sql_invalid_argument_type() {
        let session = DuckSession::new().expect("Failed to create DuckSession");
        let invalid_arg = TypedValue {
            kind: crate::types::ValueKind::Number,
            value: ArgValue::Number(42.0),
        };
        let args = vec![invalid_arg];

        let result = map_verb_to_sql("sql", &args, &session);
        assert!(result.is_err());
        if let Err(e) = result {
            assert!(e.to_string().contains("sql command requires a string argument"));
        }
    }
}