CLI

.gitignore

@@ -12,6 +12,7 @@
 !/.github
 !/LICENSE.txt
 !/.gitattributes
+!/cli
 
 __pycache__
 *.so

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["core", "py", "json"]
+members = ["core", "py", "json", "cli"]
 resolver = "2"
 
 [profile.bench.package.pgpq]

Makefile

@@ -1,4 +1,4 @@
-PHONY: init build test
+PHONY: init build-develop build-cli test
 
 .init:
 	rm -rf .venv
@@ -15,10 +15,17 @@ init: .clean .init
 build-develop: .init
 	. ./.venv/bin/activate && maturin develop -m py/Cargo.toml
 	. ./.venv/bin/activate && maturin develop -m json/Cargo.toml
+	cargo build --package pgpq-cli
 
 test: build-develop
 	cargo test
 	./.venv/bin/python -m pytest
 
 lint: build-develop
 	./.venv/bin/pre-commit run --all-files
+
+build-cli:
+	cargo build --package pgpq-cli --release
+
+install-cli: build-cli
+	cp target/release/pgpq /usr/local/bin/

cli/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "pgpq-cli"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+pgpq = { path = "../core" }
+clap = "3.0"
+arrow = "46.0.0"
+parquet = "46.0.0"
+bytes = "1.7.1"
+
+[[bin]]
+name = "pgpq"
+path = "src/main.rs"

cli/src/main.rs

@@ -0,0 +1,72 @@
+use arrow::record_batch::RecordBatch;
+use bytes::BytesMut;
+use clap::{App, Arg};
+use parquet::arrow::arrow_reader::ParquetRecordBatchReader;
+use pgpq::ArrowToPostgresBinaryEncoder;
+use std::fs::File;
+use std::io::{self, Read, Write};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let matches = App::new("pgpq")
+        .version("0.1.0")
+        .about("Converts Parquet files to PostgreSQL binary format")
+        .arg(
+            Arg::with_name("input")
+                .short('i')
+                .long("input")
+                .value_name("FILE")
+                .help("Input Parquet file (use '-' for stdin)")
+                .takes_value(true)
+                .required(true),
+        )
+        .get_matches();
+
+    let input = matches.value_of("input").unwrap();
+
+    let record_batches = if input == "-" {
+        read_parquet_from_stdin()?
+    } else {
+        read_parquet_from_file(input)?
+    };
+
+    let mut encoder = ArrowToPostgresBinaryEncoder::try_new(&record_batches[0].schema())?;
+    let mut buffer = BytesMut::new();
+
+    // Write header
+    encoder.write_header(&mut buffer);
+    io::stdout().write_all(&buffer)?;
+    buffer.clear();
+
+    // Write batches
+    for batch in record_batches {
+        encoder.write_batch(&batch, &mut buffer)?;
+        io::stdout().write_all(&buffer)?;
+        buffer.clear();
+    }
+
+    Ok(())
+}
+
+fn read_parquet_from_stdin() -> Result<Vec<RecordBatch>, Box<dyn std::error::Error>> {
+    let mut buffer = Vec::new();
+    io::stdin().read_to_end(&mut buffer)?;
+    // Implement Parquet reading from buffer
+    // This part needs to be implemented using the parquet crate
+    unimplemented!()
+}
+
+fn read_parquet_from_file(path: &str) -> Result<Vec<RecordBatch>, Box<dyn std::error::Error>> {
+    // Open the file
+    let file = File::open(path)?;
+
+    // Create a ParquetRecordBatchReader directly from the file
+    let record_batch_reader = ParquetRecordBatchReader::try_new(file, 8192)?;
+
+    // Read all record batches
+    let mut record_batches = Vec::new();
+    for batch in record_batch_reader {
+        record_batches.push(batch?);
+    }
+
+    Ok(record_batches)
+}