dtcs 0.12.0

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
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
136
137
138

//! Embedded `dtcs:reference` capability profile.

use crate::model::{COMPOSITE_TYPES, PRIMITIVE_TYPES};
use crate::registry::default_registry;

use super::model::{CapabilityCategories, EngineCapabilityDeclaration};

/// Reference engine identifier.
pub const REFERENCE_ENGINE_ID: &str = "dtcs:reference";

/// Supported expression operators in the reference runtime.
pub const REFERENCE_OPERATORS: &[&str] = &[
    "add",
    "sub",
    "mul",
    "div",
    "eq",
    "neq",
    "lt",
    "lte",
    "gt",
    "gte",
    "and",
    "or",
    "negate",
    "not",
    "in",
    "contains",
    "dtcs:add",
    "dtcs:subtract",
    "dtcs:multiply",
    "dtcs:divide",
    "dtcs:eq",
    "dtcs:not_eq",
    "dtcs:lt",
    "dtcs:lte",
    "dtcs:gt",
    "dtcs:gte",
    "dtcs:and",
    "dtcs:or",
    "dtcs:not",
    "dtcs:negate",
    "dtcs:in",
    "dtcs:between",
    "dtcs:null_safe_eq",
    "dtcs:field",
    "dtcs:index",
    "dtcs:element_at",
    "dtcs:modulo",
];

/// Supported language features for the reference engine.
pub const REFERENCE_LANGUAGE_FEATURES: &[&str] = &[
    "nullMissingInvalidDistinction",
    "collectionOperators",
    "temporalLiterals",
];

/// Supported optimization capabilities.
pub const REFERENCE_OPTIMIZATION: &[&str] = &[
    "constantFolding",
    "actionFusion",
    "ruleDedup",
    "deadExpressionElimination",
];

/// Supported runtime features for the reference engine.
pub const REFERENCE_RUNTIME_FEATURES: &[&str] = &[
    "rowOriented",
    "prePostconditions",
    "lineageMaterialization",
    "deterministic",
    "nonDeterminismSourceReporting",
    "datasetActions",
];

/// Returns the embedded reference engine capability profile.
#[must_use]
pub fn reference_profile() -> EngineCapabilityDeclaration {
    let registry = default_registry();
    let mut semantic_actions = Vec::new();
    let mut functions = Vec::new();
    let mut rules = Vec::new();

    for entry in registry.entries.values() {
        match entry.category {
            crate::model::RegistryCategory::SemanticAction => {
                semantic_actions.push(entry.id.clone());
            }
            crate::model::RegistryCategory::Function => {
                functions.push(entry.id.clone());
            }
            crate::model::RegistryCategory::Rule => {
                rules.push(entry.id.clone());
            }
            _ => {}
        }
    }
    semantic_actions.sort();
    functions.sort();
    rules.sort();

    let mut logical_types: Vec<String> = PRIMITIVE_TYPES
        .iter()
        .chain(COMPOSITE_TYPES.iter())
        .map(|t| (*t).to_string())
        .collect();
    logical_types.sort();

    EngineCapabilityDeclaration {
        engine_id: REFERENCE_ENGINE_ID.into(),
        engine_version: env!("CARGO_PKG_VERSION").into(),
        capability_version: "1.0.0".into(),
        categories: CapabilityCategories {
            language_features: REFERENCE_LANGUAGE_FEATURES
                .iter()
                .map(|f| (*f).to_string())
                .collect(),
            logical_types,
            semantic_actions,
            functions,
            rules,
            operators: REFERENCE_OPERATORS
                .iter()
                .map(|op| (*op).to_string())
                .collect(),
            optimization: REFERENCE_OPTIMIZATION
                .iter()
                .map(|f| (*f).to_string())
                .collect(),
            runtime_features: REFERENCE_RUNTIME_FEATURES
                .iter()
                .map(|f| (*f).to_string())
                .collect(),
            extension_support: vec!["vendorNamespacedPreserve".into()],
        },
    }
}