lutra-compiler 0.5.1

Compiler for Lutra query 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

//! Representation conversion.
//!
//! Converts between different representations of Lutra values. There are:
//! - query repr,
//! - Postgres repr,
//! - JSON repr,
//! - DuckDB repr,
//! - arrow repr.

use crate::sql::Dialect;
use crate::sql::queries::Context;
use crate::sql::utils::Node;
use lutra_bin::ir;
use std::borrow::Cow;

impl<'a> Context<'a> {
    /// Converts a relation from "native repr" into "query repr".
    /// Native repr is either the postgres repr or duckdb repr.
    pub fn native_import(&mut self, node: Node, ty: &ir::Ty) -> Node {
        match self.dialect() {
            Dialect::Postgres => self.pg_import(node, ty),
            Dialect::DuckDB => self.duck_import(node, ty),
        }
    }

    /// Returns columns in the native repr.
    pub fn native_cols<'t>(&'t self, ty: &'t ir::Ty) -> Vec<(String, Cow<'t, ir::Ty>)> {
        match self.dialect() {
            Dialect::Postgres => self.pg_cols(ty, false),
            Dialect::DuckDB => self.duck_cols(ty),
        }
    }

    /// Converts a relation from "query repr" to "native repr".
    /// Native repr is either the postgres repr or duckdb repr.
    pub fn native_export(&mut self, node: Node, ty: &ir::Ty, include_index: bool) -> Node {
        match self.dialect() {
            Dialect::Postgres => self.pg_export(node, ty, include_index),
            Dialect::DuckDB => self.duck_export(node, ty, include_index),
        }
    }

    /// Convert a relation in "query repr" into a column in "serialized repr".
    ///
    /// What this means depends on the dialect:
    /// - on postgres, this will serialize to json
    /// - on duckdb, this will construct STRUCT/LIST/UNION types
    pub fn serialize(&mut self, node: Node, ty: &ir::Ty) -> Node {
        match self.dialect() {
            Dialect::Postgres => self.pg_serialize(node, ty),
            Dialect::DuckDB => self.duck_serialize(node, ty),
        }
    }

    /// Convert a column in "serialized repr" into a relation in "query repr".
    ///
    /// What this means depends on the dialect:
    /// - on postgres, this will unpack json
    /// - on duckdb, this will deconstruct STRUCT/LIST/UNION types
    pub fn deserialize(&mut self, input: Node, input_ty: &ir::Ty, ty: &ir::Ty) -> Node {
        match self.dialect() {
            Dialect::Postgres => self.pg_deserialize(input, input_ty, ty),
            Dialect::DuckDB => self.duck_deserialize(input, ty),
        }
    }

    /// Returns the name that provides a "row identifier". This value must:
    /// - uniquely identify a row in a table,
    /// - be stable within a transaction,
    /// - exist for every row in every table.
    pub fn row_id(&self) -> &str {
        match self.dialect {
            Dialect::Postgres => "ctid",
            Dialect::DuckDB => "rowid",
        }
    }
}