query-forge 0.5.0

Run SQL queries on XLSX/XML/CSV/JSON/JSONL/Markdown/HTML/Parquet inputs and export results as text, CSV, JSONL, Markdown, XML, HTML, XLSX, or Parquet
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

use std::time::Instant;

use anyhow::Result;
use clap::Parser;

mod cli;
mod input_spec;
mod inspect;
#[path = "cli_output/mod.rs"]
mod output;
mod query;

use crate::cli::{Cli, Commands};

fn main() -> Result<()> {
    let cli = Cli::parse();

    match cli.command {
        Commands::Query(cmd) => {
            let sql = query::load_query(&cmd)?;
            let params = query::parse_query_params(&cmd.params)?;
            let type_inference_options = query::resolve_type_inference_options(&cmd);
            let input_normalization_options = query::resolve_input_normalization_options(&cmd);
            let extraction_options = query::resolve_extraction_options(&cmd);
            let input_specs = input_spec::parse_input_specs(&cmd.input, None)?;
            let workbook_inputs = input_specs
                .iter()
                .map(|input| query_forge::WorkbookInput {
                    path: input.path.as_path(),
                    sheet_name: input.sheet_name.as_deref(),
                    table_name: input.table_name.as_deref(),
                })
                .collect::<Vec<_>>();

            let start = Instant::now();
            let result =
                query_forge::run_query_with_params_multi_inputs_and_options_and_normalization(
                    &workbook_inputs,
                    &sql,
                    &params,
                    &type_inference_options,
                    &input_normalization_options,
                    &extraction_options,
                    !cmd.no_headers,
                )?;
            let elapsed = start.elapsed();

            output::write_query_result(&result, cmd.output.as_deref(), cmd.format)?;

            if cmd.meta {
                let input_tables = input_specs
                    .iter()
                    .enumerate()
                    .map(|(i, spec)| output::InputTableMeta {
                        table_name: spec.table_name.clone().unwrap_or_else(|| {
                            if i == 0 {
                                "table".to_owned()
                            } else {
                                format!("table{}", i + 1)
                            }
                        }),
                        source_path: spec.path.display().to_string(),
                        source_selector: spec.sheet_name.clone(),
                    })
                    .collect();

                let meta = output::QueryMetadata {
                    row_count: result.rows.len(),
                    columns: result.columns.clone(),
                    input_tables,
                    execution_time_ms: elapsed.as_millis(),
                };
                output::write_query_metadata(&meta, cmd.meta_format.as_ref());
            }
        }
        Commands::Tables(cmd) => inspect::run_tables_command(cmd)?,
        Commands::Schema(cmd) => inspect::run_schema_command(cmd)?,
        Commands::Inspect(cmd) => inspect::run_inspect_command(cmd)?,
    }

    Ok(())
}