dtcs 0.10.1

Reference implementation of the Data Transformation Contract Standard (DTCS)
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

//! Compilation of transformation plans to execution plans (SPEC Chapter 15).

mod compiler;
mod model;
mod reference;
mod validate;

pub use compiler::Compiler;
pub use model::{ExecutionPlan, ExecutionStep, ExecutionStepKind, ExecutionTarget};
pub use reference::{compile_reference, ReferenceCompiler};
pub use validate::validate;

use crate::capability::{match_plan, reference_profile};
use crate::diagnostics::Diagnostic;
use crate::plan::TransformationPlan;

/// Result of compiling a transformation plan.
#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CompileResult {
    /// Compiled execution plan when compilation succeeded.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub plan: Option<ExecutionPlan>,
    /// Diagnostics from compilation.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub diagnostics: Vec<Diagnostic>,
}

impl CompileResult {
    /// Returns `true` when no error-level diagnostics are present.
    #[must_use]
    pub fn is_valid(&self) -> bool {
        self.plan.is_some() && !self.diagnostics.iter().any(|d| d.severity.is_error())
    }
}

/// Compile a transformation plan using the reference backend.
#[must_use]
pub fn compile(plan: &TransformationPlan) -> CompileResult {
    reference::compile_reference(plan)
}

/// Compile with an explicit capability declaration.
#[must_use]
pub fn compile_with_capability(
    plan: &TransformationPlan,
    capability: &crate::capability::EngineCapabilityDeclaration,
) -> CompileResult {
    reference::ReferenceCompiler.compile(plan, capability)
}

/// Match then compile, returning match diagnostics on failure.
#[must_use]
pub fn compile_after_match(plan: &TransformationPlan) -> CompileResult {
    let capability = reference_profile();
    let match_report = match_plan(plan, &capability);
    if !match_report.is_valid() {
        return CompileResult {
            diagnostics: match_report.diagnostics,
            ..CompileResult::default()
        };
    }
    reference::ReferenceCompiler.compile(plan, &capability)
}