png-db 0.1.2

A database that stores JSON data rows as compressed text within the zTXt chunks of PNG image files
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

#[cfg(feature = "cli")]
mod cli {
    use clap::{Parser, Subcommand};
    use color_eyre::Result;
    use png_db::{PngDatabase, Schema};
    use serde_json::Value;
    use std::collections::HashMap;

    #[derive(Parser)]
    #[command(name = "png-db")]
    #[command(about = "A simple database that stores JSON data in PNG files")]
    struct Cli {
        #[command(subcommand)]
        command: Commands,
    }

    #[derive(Subcommand)]
    enum Commands {
        Create {
            #[arg(short, long)]
            file: String,
            #[arg(short, long, default_value = "256")]
            width: u32,
            #[arg(long, default_value = "256")]
            height: u32,
            #[arg(short, long)]
            schema: String,
        },
        Insert {
            #[arg(short, long)]
            file: String,
            #[arg(short, long)]
            x: u32,
            #[arg(short, long)]
            y: u32,
            #[arg(short, long)]
            data: String,
        },
        Query {
            #[arg(short, long)]
            file: String,
            #[arg(short, long)]
            where_clause: String,
        },
        List {
            #[arg(short, long)]
            file: String,
        },
    }

    pub fn run() -> Result<()> {
        color_eyre::install()?;

        let cli = Cli::parse();

        match cli.command {
            Commands::Create { file, width, height, schema } => {
                let schema_map = parse_schema(&schema)?;
                let schema = Schema { fields: schema_map };
                PngDatabase::create_empty_png(width, height, schema, &file)?;
                println!("Created database: {}", file);
            }
            Commands::Insert { file, x, y, data } => {
                let mut db = PngDatabase::load_from_png(&file)?;
                let json_data: Value = serde_json::from_str(&data)?;
                db.insert(x, y, json_data)?;
                db.save_to_png(&file)?;
                println!("Inserted data at ({}, {})", x, y);
            }
            Commands::Query { file, where_clause } => {
                let db = PngDatabase::load_from_png(&file)?;
                let results = db.query(&where_clause)?;

                if results.is_empty() {
                    println!("No results found");
                } else {
                    println!("Found {} result(s):", results.len());
                    for row in results {
                        println!("  Position ({}, {}): {}", row.x, row.y, serde_json::to_string_pretty(&row.data)?);
                    }
                }
            }
            Commands::List { file } => {
                let db = PngDatabase::load_from_png(&file)?;
                println!("Database: {} ({}x{})", file, db.width, db.height);
                println!("Schema: {:?}", db.schema.fields);
                println!("Rows: {}", db.rows.len());

                for row in &db.rows {
                    println!("  Position ({}, {}): {}", row.x, row.y, serde_json::to_string(&row.data)?);
                }
            }
        }

        Ok(())
    }

    fn parse_schema(schema_str: &str) -> Result<HashMap<String, String>> {
        let mut schema = HashMap::new();

        for field_def in schema_str.split(',') {
            let parts: Vec<&str> = field_def.trim().split(':').collect();
            if parts.len() == 2 {
                schema.insert(parts[0].trim().to_string(), parts[1].trim().to_string());
            }
        }

        Ok(schema)
    }
}

#[cfg(feature = "cli")]
fn main() -> Result<(), Box<dyn std::error::Error>> {
    cli::run().map_err(|e| e.into())
}

#[cfg(not(feature = "cli"))]
fn main() {
    // This binary is not meant to be run without the CLI feature
    eprintln!("This binary requires the 'cli' feature to be enabled.");
    std::process::exit(1);
}