papera 0.2.0

A SQL compatibility layer that transpiles Trino and Redshift SQL to DuckDB SQL
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

//! Demonstrates using TranspileOptions for migration scenarios.
//!
//! Run with: cargo run --example migration

use papera::{
    CopyBehavior, ExternalTableBehavior, IcebergTableBehavior, SourceDialect, TranspileOptions,
    transpile_with_options,
};

fn main() {
    // Migration-friendly options: opt into all conversions
    let opts = TranspileOptions {
        external_table: ExternalTableBehavior::MapToView,
        iceberg_table: IcebergTableBehavior::MapToView,
        copy: CopyBehavior::MapToInsert,
        ..Default::default()
    };

    let examples: &[(&str, SourceDialect, &str)] = &[
        // External table → DuckDB view with read_parquet
        (
            "CREATE EXTERNAL TABLE events (
                id BIGINT,
                ts TIMESTAMP,
                payload STRING
            )
            PARTITIONED BY (dt STRING)
            STORED AS PARQUET
            LOCATION 's3://data-lake/events/'",
            SourceDialect::Hive,
            "Hive external table with partitioning",
        ),
        // Hive external table with CSV and row format
        (
            "CREATE EXTERNAL TABLE logs (
                ts STRING,
                level STRING,
                message STRING
            )
            ROW FORMAT DELIMITED
                FIELDS TERMINATED BY ','
                LINES TERMINATED BY '\\n'
            STORED AS TEXTFILE
            LOCATION 's3://data-lake/logs/'",
            SourceDialect::Hive,
            "Hive CSV external table with delimiters",
        ),
        // Hive external table with SerDe
        (
            "CREATE EXTERNAL TABLE json_events (
                id INT,
                data STRING
            )
            ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.JsonSerDe'
            LOCATION 's3://data-lake/json/'",
            SourceDialect::Hive,
            "Hive external table with JSON SerDe",
        ),
        // Iceberg table (Athena-style)
        (
            "CREATE TABLE analytics (
                user_id BIGINT,
                event VARCHAR,
                ts TIMESTAMP
            )
            LOCATION 's3://warehouse/analytics/'
            TBLPROPERTIES ('table_type'='ICEBERG')",
            SourceDialect::Trino,
            "Iceberg table (Athena TBLPROPERTIES)",
        ),
        // Iceberg table (Trino-style)
        (
            "CREATE TABLE metrics (
                name VARCHAR,
                value DOUBLE,
                ts TIMESTAMP
            )
            WITH (
                table_type = 'ICEBERG',
                location = 's3://warehouse/metrics/',
                format = 'PARQUET'
            )",
            SourceDialect::Trino,
            "Iceberg table (Trino WITH clause)",
        ),
        // Redshift COPY
        (
            "COPY staging_orders FROM 's3://etl-bucket/orders/' IAM_ROLE 'arn:aws:iam::123456789:role/redshift-role' PARQUET",
            SourceDialect::Redshift,
            "Redshift COPY (Parquet from S3)",
        ),
        // Redshift COPY with CSV options
        (
            "COPY staging_users FROM 's3://etl-bucket/users.csv.gz' IAM_ROLE 'arn:aws:iam::123456789:role/redshift-role' CSV DELIMITER ',' IGNOREHEADER 1 GZIP",
            SourceDialect::Redshift,
            "Redshift COPY (gzipped CSV with header)",
        ),
    ];

    for (sql, dialect, label) in examples {
        println!("--- {label} ---");
        match transpile_with_options(sql, *dialect, &opts) {
            Ok(result) => {
                println!("Input ({dialect:?}):");
                for line in sql.lines() {
                    println!("  {}", line.trim());
                }
                println!("Output (DuckDB):");
                println!("  {result}");
            }
            Err(e) => {
                println!("Error: {e}");
            }
        }
        println!();
    }
}