flowcode-core 0.4.1-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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

//! DuckDB Interchange for FlowCode v0.4-alpha
//! This module handles conversion between FlowCode's Table (TypedValue) and DuckDB's data structures.

use crate::types::{TypedValue, ValueKind};
use crate::ast::ArgValue;
use std::error::Error;
use std::fmt;

/// Custom error type for DuckDB interchange operations
#[derive(Debug)]
pub enum InterchangeError {
    ConversionError(String),
    UnsupportedType(String),
}

impl fmt::Display for InterchangeError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            InterchangeError::ConversionError(msg) => write!(f, "Conversion error: {}", msg),
            InterchangeError::UnsupportedType(msg) => write!(f, "Unsupported type: {}", msg),
        }
    }
}

impl Error for InterchangeError {}

/// Converts a DuckDB RecordBatch to a FlowCode TypedValue (Table).
/// This is a stub implementation that returns an empty table.
#[cfg(feature = "duckdb")]
pub fn record_batch_to_table(
    _batch: duckdb::arrow::record_batch::RecordBatch,
) -> Result<TypedValue, Box<dyn Error>> {
    // Stub implementation - returns an empty table
    Ok(TypedValue::new(ValueKind::Table, ArgValue::Table(Vec::new())))
}

/// Converts a FlowCode TypedValue (Table) to a DuckDB RecordBatch.
/// This is a stub implementation that returns an empty RecordBatch.
#[cfg(feature = "duckdb")]
pub fn table_to_record_batch(
    _table: &TypedValue,
) -> Result<duckdb::arrow::record_batch::RecordBatch, Box<dyn Error>> {
    // Stub implementation - returns an empty RecordBatch with no schema
    use duckdb::arrow::array::ArrayRef;
    use duckdb::arrow::datatypes::{Field, Schema};
    use std::sync::Arc;
    
    let schema = Arc::new(Schema::new(Vec::<Field>::new()));
    let columns = Vec::<ArrayRef>::new();
    
    Ok(duckdb::arrow::record_batch::RecordBatch::try_new(schema, columns)?)
}

// DuckDB Interchange Layer for FlowCode v0.4-alpha
// This file handles conversion between FlowCode data structures and DuckDB's Arrow format.

use duckdb::arrow::record_batch::RecordBatch as DuckDBRecordBatch;

/// Converts a DuckDB RecordBatch to a FlowCode TypedValue.
pub fn record_batch_to_typed_value(_batch: DuckDBRecordBatch) -> Result<TypedValue, Box<dyn Error>> {
    // Placeholder for conversion logic from DuckDB Arrow RecordBatch to TypedValue
    // This would typically involve iterating over columns and rows to build a table structure
    // compatible with FlowCode's type system.
    
    // For now, return a placeholder TypedValue (assuming a table structure)
    // In a full implementation, this would map column names and data types.
    Ok(TypedValue::new(ValueKind::Table, ArgValue::Table(vec![])))
}

/// Converts a FlowCode TypedValue to a DuckDB-compatible Arrow RecordBatch.
pub fn typed_value_to_record_batch(_value: &TypedValue) -> Result<DuckDBRecordBatch, Box<dyn Error>> {
    // Placeholder for conversion logic from TypedValue to Arrow RecordBatch
    // This would involve extracting table data from TypedValue and constructing
    // Arrow arrays based on the schema.
    
    // For now, return an error as a placeholder
    Err("Conversion from TypedValue to RecordBatch not yet implemented".into())
}

/// Extracts schema information from a DuckDB RecordBatch for FlowCode compatibility.
pub fn extract_schema(_batch: &DuckDBRecordBatch) -> Result<(), Box<dyn Error>> {
    // Extract the schema from the RecordBatch
    // Temporarily return Ok as schema type is not directly accessible without arrow crate
    Ok(())
}

/// Utility to convert a single DuckDB value to a FlowCode TypedValue.
pub fn duckdb_value_to_typed_value(value: &duckdb::types::Value) -> Result<TypedValue, Box<dyn Error>> {
    // Placeholder for converting individual DuckDB values to TypedValue
    // This would map DuckDB types (e.g., INTEGER, VARCHAR) to FlowCode types.
    // Using placeholder values for ValueKind and ArgValue due to unknown variants
    match value {
        duckdb::types::Value::Null => Ok(TypedValue::new(ValueKind::String, ArgValue::String("null".to_string()))),
        duckdb::types::Value::Boolean(b) => Ok(TypedValue::new(ValueKind::String, ArgValue::String(b.to_string()))),
        duckdb::types::Value::Int(i) => Ok(TypedValue::new(ValueKind::String, ArgValue::String(i.to_string()))),
        duckdb::types::Value::BigInt(i) => Ok(TypedValue::new(ValueKind::String, ArgValue::String(i.to_string()))),
        duckdb::types::Value::Float(f) => Ok(TypedValue::new(ValueKind::String, ArgValue::String(f.to_string()))),
        duckdb::types::Value::Double(d) => Ok(TypedValue::new(ValueKind::String, ArgValue::String(d.to_string()))),
        duckdb::types::Value::Text(s) => Ok(TypedValue::new(ValueKind::String, ArgValue::String(s.clone()))),
        _ => Err(format!("Unsupported DuckDB value type: {:?}", value).into()),
    }
}