datafold 0.1.55

A personal database for data sovereignty with AI-powered ingestion
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//! Error types for schema indexing iterator stack operations

use std::fmt;

/// Errors that can occur during iterator stack operations
#[derive(Debug, Clone, PartialEq)]
pub enum IteratorStackError {
    /// Invalid chain syntax in expression
    InvalidChainSyntax { expression: String, reason: String },
    /// Incompatible fan-out depths between fields
    IncompatibleFanoutDepths {
        field1: String,
        depth1: usize,
        field2: String,
        depth2: usize,
    },
    /// Fields fan out on incomparable branches (cartesian product)
    CartesianFanoutError {
        field1: String,
        branch1: String,
        field2: String,
        branch2: String,
    },
    /// Field requires a reducer but none was provided
    ReducerRequired {
        field: String,
        current_depth: usize,
        max_depth: usize,
    },
    /// Invalid iterator chain structure
    InvalidIteratorChain { chain: String, reason: String },
    /// Ambiguous fan-out on different branches
    AmbiguousFanoutDifferentBranches { branches: Vec<String> },
    /// Iterator depth exceeds maximum allowed
    MaxDepthExceeded {
        current_depth: usize,
        max_depth: usize,
    },
    /// Field alignment validation failed
    FieldAlignmentError { field: String, reason: String },
    /// Runtime execution error
    ExecutionError { message: String },
}

impl fmt::Display for IteratorStackError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            IteratorStackError::InvalidChainSyntax { expression, reason } => {
                write!(
                    f,
                    "Invalid chain syntax in expression '{}': {}",
                    expression, reason
                )
            }
            IteratorStackError::IncompatibleFanoutDepths {
                field1,
                depth1,
                field2,
                depth2,
            } => {
                write!(
                    f,
                    "Incompatible fan-out depths: field '{}' at depth {} vs field '{}' at depth {}",
                    field1, depth1, field2, depth2
                )
            }
            IteratorStackError::CartesianFanoutError {
                field1,
                branch1,
                field2,
                branch2,
            } => {
                write!(
                    f,
                    "Cartesian fan-out error: field '{}' on branch '{}' vs field '{}' on branch '{}'",
                    field1, branch1, field2, branch2
                )
            }
            IteratorStackError::ReducerRequired {
                field,
                current_depth,
                max_depth,
            } => {
                write!(
                    f,
                    "Field '{}' at depth {} exceeds max depth {} and requires a reducer",
                    field, current_depth, max_depth
                )
            }
            IteratorStackError::InvalidIteratorChain { chain, reason } => {
                write!(f, "Invalid iterator chain '{}': {}", chain, reason)
            }
            IteratorStackError::AmbiguousFanoutDifferentBranches { branches } => {
                write!(
                    f,
                    "Ambiguous fan-out on different branches: {}",
                    branches.join(", ")
                )
            }
            IteratorStackError::MaxDepthExceeded {
                current_depth,
                max_depth,
            } => {
                write!(
                    f,
                    "Iterator depth {} exceeds maximum allowed depth {}",
                    current_depth, max_depth
                )
            }
            IteratorStackError::FieldAlignmentError { field, reason } => {
                write!(f, "Field alignment error for '{}': {}", field, reason)
            }
            IteratorStackError::ExecutionError { message } => {
                write!(f, "Execution error: {}", message)
            }
        }
    }
}

impl std::error::Error for IteratorStackError {}

/// Result type for iterator stack operations
pub type IteratorStackResult<T> = Result<T, IteratorStackError>;

/// Constants for iterator stack limits
pub mod constants {
    /// Maximum iterator depth allowed
    pub const MAX_ITERATOR_DEPTH: usize = 10;

    /// Maximum number of fields in a single schema
    pub const MAX_FIELDS_PER_SCHEMA: usize = 100;

    /// Maximum chain expression length
    pub const MAX_CHAIN_EXPRESSION_LENGTH: usize = 1000;
}