tpchgen 3.0.0

//! CSV formatting support for the row struct objects generated by the library.

use crate::generators::{Customer, LineItem, Nation, Order, Part, PartSupp, Region, Supplier};
use core::fmt;
use std::fmt::Display;

/// Write [`Nation`]s in CSV format.
///
/// # Example
/// ```
/// # use tpchgen::generators::NationGenerator;
/// # use tpchgen::csv::NationCsv;
/// # use std::fmt::Write;
/// // Output the first 3 rows in CSV format
/// let generator = NationGenerator::default();
/// let mut csv = String::new();
/// writeln!(&mut csv, "{}", NationCsv::header()).unwrap(); // write header
/// for line in generator.iter().take(3) {
///   // write line using CSV formatter
///   writeln!(&mut csv, "{}", NationCsv::new(line)).unwrap();
/// }
/// assert_eq!(
///   csv,
///   "n_nationkey,n_name,n_regionkey,n_comment\n\
///    0,ALGERIA,0,\" haggle. carefully final deposits detect slyly agai\"\n\
///    1,ARGENTINA,1,\"al foxes promise slyly according to the regular accounts. bold requests alon\"\n\
///    2,BRAZIL,1,\"y alongside of the pending deposits. carefully special packages are about the ironic forges. slyly special \"\n"
/// );
/// ```
pub struct NationCsv<'a> {
    inner: Nation<'a>,
    delimiter: char,
}

impl<'a> NationCsv<'a> {
    pub fn new(inner: Nation<'a>) -> Self {
        Self {
            inner,
            delimiter: ',',
        }
    }

    /// Create a new NationCsv with a custom delimiter
    pub fn with_delimiter(inner: Nation<'a>, delimiter: char) -> Self {
        Self { inner, delimiter }
    }

    /// Returns the CSV header for the Nation table
    pub fn header() -> &'static str {
        "n_nationkey,n_name,n_regionkey,n_comment"
    }

    /// Returns the CSV header with a custom delimiter
    pub fn header_with_delimiter(delimiter: char) -> String {
        format!("n_nationkey{delimiter}n_name{delimiter}n_regionkey{delimiter}n_comment")
    }
}

impl Display for NationCsv<'_> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let d = self.delimiter;
        write!(
            f,
            // note must quote the comment field as it may contain the delimiter
            "{}{d}{}{d}{}{d}\"{}\"",
            self.inner.n_nationkey, self.inner.n_name, self.inner.n_regionkey, self.inner.n_comment
        )
    }
}

/// Write [`Region`]s in CSV format.
///
/// # Example
/// ```
/// # use tpchgen::generators::{RegionGenerator};
/// # use tpchgen::csv::{NationCsv, RegionCsv};
/// # use std::fmt::Write;
/// let generator = RegionGenerator::default();
/// // Output the first 3 rows in CSV format
/// let mut csv = String::new();
/// writeln!(&mut csv, "{}", RegionCsv::header()).unwrap(); // write header
/// for line in generator.iter().take(3) {
///   // write line using CSV formatter
///   writeln!(&mut csv, "{}", RegionCsv::new(line)).unwrap();
/// }
/// assert_eq!(
///   csv,
///   "r_regionkey,r_name,r_comment\n\
///    0,AFRICA,\"lar deposits. blithely final packages cajole. regular waters are final requests. regular accounts are according to \"\n\
///    1,AMERICA,\"hs use ironic, even requests. s\"\n\
///    2,ASIA,\"ges. thinly even pinto beans ca\"\n"
/// );
/// ```
pub struct RegionCsv<'a> {
    inner: Region<'a>,
    delimiter: char,
}

impl<'a> RegionCsv<'a> {
    pub fn new(inner: Region<'a>) -> Self {
        Self {
            inner,
            delimiter: ',',
        }
    }

    /// Create a new RegionCsv with a custom delimiter
    pub fn with_delimiter(inner: Region<'a>, delimiter: char) -> Self {
        Self { inner, delimiter }
    }

    /// Returns the CSV header for the Region table
    pub fn header() -> &'static str {
        "r_regionkey,r_name,r_comment"
    }

    /// Returns the CSV header with a custom delimiter
    pub fn header_with_delimiter(delimiter: char) -> String {
        format!("r_regionkey{delimiter}r_name{delimiter}r_comment")
    }
}

impl Display for RegionCsv<'_> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let d = self.delimiter;
        write!(
            f,
            // note must quote the comment field as it may contain the delimiter
            "{}{d}{}{d}\"{}\"",
            self.inner.r_regionkey, self.inner.r_name, self.inner.r_comment
        )
    }
}

/// Write [`Part`]s in CSV format.
///
/// # Example
/// ```
/// # use tpchgen::generators::PartGenerator;
/// # use tpchgen::csv::PartCsv;
/// # use std::fmt::Write;
/// // Output the first 3 rows in CSV format
/// let generator = PartGenerator::new(1.0, 1, 1);
/// let mut csv = String::new();
/// writeln!(&mut csv, "{}", PartCsv::header()).unwrap(); // write header
/// for line in generator.iter().take(3) {
///   // write line using CSV formatter
///   writeln!(&mut csv, "{}", PartCsv::new(line)).unwrap();
/// }
/// assert_eq!(
///   csv,
///   "p_partkey,p_name,p_mfgr,p_brand,p_type,p_size,p_container,p_retailprice,p_comment\n\
///    1,goldenrod lavender spring chocolate lace,Manufacturer#1,Brand#13,PROMO BURNISHED COPPER,7,JUMBO PKG,901.00,\"ly. slyly ironi\"\n\
///    2,blush thistle blue yellow saddle,Manufacturer#1,Brand#13,LARGE BRUSHED BRASS,1,LG CASE,902.00,\"lar accounts amo\"\n\
///    3,spring green yellow purple cornsilk,Manufacturer#4,Brand#42,STANDARD POLISHED BRASS,21,WRAP CASE,903.00,\"egular deposits hag\"\n"
/// );
/// ```
pub struct PartCsv<'a> {
    inner: Part<'a>,
    delimiter: char,
}

impl<'a> PartCsv<'a> {
    pub fn new(inner: Part<'a>) -> Self {
        Self {
            inner,
            delimiter: ',',
        }
    }

    /// Create a new PartCsv with a custom delimiter
    pub fn with_delimiter(inner: Part<'a>, delimiter: char) -> Self {
        Self { inner, delimiter }
    }

    /// Returns the CSV header for the Part table
    pub fn header() -> &'static str {
        "p_partkey,p_name,p_mfgr,p_brand,p_type,p_size,p_container,p_retailprice,p_comment"
    }

    /// Returns the CSV header with a custom delimiter
    pub fn header_with_delimiter(delimiter: char) -> String {
        format!("p_partkey{delimiter}p_name{delimiter}p_mfgr{delimiter}p_brand{delimiter}p_type{delimiter}p_size{delimiter}p_container{delimiter}p_retailprice{delimiter}p_comment")
    }
}

impl Display for PartCsv<'_> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let d = self.delimiter;
        write!(
            f,
            // note must quote the comment field as it may contain the delimiter
            "{}{d}{}{d}{}{d}{}{d}{}{d}{}{d}{}{d}{}{d}\"{}\"",
            self.inner.p_partkey,
            self.inner.p_name,
            self.inner.p_mfgr,
            self.inner.p_brand,
            self.inner.p_type,
            self.inner.p_size,
            self.inner.p_container,
            self.inner.p_retailprice,
            self.inner.p_comment
        )
    }
}

/// Write [`Supplier`]s in CSV format.
///
/// # Example
/// ```
/// # use tpchgen::generators::SupplierGenerator;
/// # use tpchgen::csv::SupplierCsv;
/// # use std::fmt::Write;
/// // Output the first 3 rows in CSV format
/// let generator = SupplierGenerator::new(1.0, 1, 1);
/// let mut csv = String::new();
/// writeln!(&mut csv, "{}", SupplierCsv::header()).unwrap(); // write header
///   for line in generator.iter().take(3) {
///   // write line using CSV formatter
///   writeln!(&mut csv, "{}", SupplierCsv::new(line)).unwrap();
/// }
/// assert_eq!(
///   csv,
///   "s_suppkey,s_name,s_address,s_nationkey,s_phone,s_acctbal,s_comment\n\
///    1,Supplier#000000001,\" N kD4on9OM Ipw3,gf0JBoQDd7tgrzrddZ\",17,27-918-335-1736,5755.94,\"each slyly above the careful\"\n\
///    2,Supplier#000000002,\"89eJ5ksX3ImxJQBvxObC,\",5,15-679-861-2259,4032.68,\" slyly bold instructions. idle dependen\"\n\
///    3,Supplier#000000003,\"q1,G3Pj6OjIuUYfUoH18BFTKP5aU9bEV3\",1,11-383-516-1199,4192.40,\"blithely silent requests after the express dependencies are sl\"\n"
/// );
/// ```
pub struct SupplierCsv {
    inner: Supplier,
    delimiter: char,
}

impl SupplierCsv {
    pub fn new(inner: Supplier) -> Self {
        Self {
            inner,
            delimiter: ',',
        }
    }

    /// Create a new SupplierCsv with a custom delimiter
    pub fn with_delimiter(inner: Supplier, delimiter: char) -> Self {
        Self { inner, delimiter }
    }

    /// Returns the CSV header for the Supplier table
    pub fn header() -> &'static str {
        "s_suppkey,s_name,s_address,s_nationkey,s_phone,s_acctbal,s_comment"
    }

    /// Returns the CSV header with a custom delimiter
    pub fn header_with_delimiter(delimiter: char) -> String {
        format!("s_suppkey{delimiter}s_name{delimiter}s_address{delimiter}s_nationkey{delimiter}s_phone{delimiter}s_acctbal{delimiter}s_comment")
    }
}

impl Display for SupplierCsv {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let d = self.delimiter;
        write!(
            f,
            // note must quote the address and comment fields as they may contain the delimiter
            "{}{d}{}{d}\"{}\"{d}{}{d}{}{d}{}{d}\"{}\"",
            self.inner.s_suppkey,
            self.inner.s_name,
            self.inner.s_address,
            self.inner.s_nationkey,
            self.inner.s_phone,
            self.inner.s_acctbal,
            self.inner.s_comment
        )
    }
}

/// Write [`Customer`]s in CSV format.
///
/// # Example
/// ```
/// # use tpchgen::generators::CustomerGenerator;
/// # use tpchgen::csv::CustomerCsv;
/// # use std::fmt::Write;
/// // Output the first 3 rows in CSV format
/// let generator = CustomerGenerator::new(1.0, 1, 1);
/// let mut csv = String::new();
/// writeln!(&mut csv, "{}", CustomerCsv::header()).unwrap(); // write header
/// for line in generator.iter().take(3) {
///   // write line using CSV formatter
///   writeln!(&mut csv, "{}", CustomerCsv::new(line)).unwrap();
/// }
/// assert_eq!(
///   csv,
///   "c_custkey,c_name,c_address,c_nationkey,c_phone,c_acctbal,c_mktsegment,c_comment\n\
///    1,Customer#000000001,\"IVhzIApeRb ot,c,E\",15,25-989-741-2988,711.56,BUILDING,\"to the even, regular platelets. regular, ironic epitaphs nag e\"\n\
///    2,Customer#000000002,\"XSTf4,NCwDVaWNe6tEgvwfmRchLXak\",13,23-768-687-3665,121.65,AUTOMOBILE,\"l accounts. blithely ironic theodolites integrate boldly: caref\"\n\
///    3,Customer#000000003,\"MG9kdTD2WBHm\",1,11-719-748-3364,7498.12,AUTOMOBILE,\" deposits eat slyly ironic, even instructions. express foxes detect slyly. blithely even accounts abov\"\n"
/// );
/// ```
pub struct CustomerCsv<'a> {
    inner: Customer<'a>,
    delimiter: char,
}

impl<'a> CustomerCsv<'a> {
    pub fn new(inner: Customer<'a>) -> Self {
        Self {
            inner,
            delimiter: ',',
        }
    }

    /// Create a new CustomerCsv with a custom delimiter
    pub fn with_delimiter(inner: Customer<'a>, delimiter: char) -> Self {
        Self { inner, delimiter }
    }

    /// Returns the CSV header for the Customer table
    pub fn header() -> &'static str {
        "c_custkey,c_name,c_address,c_nationkey,c_phone,c_acctbal,c_mktsegment,c_comment"
    }

    /// Returns the CSV header with a custom delimiter
    pub fn header_with_delimiter(delimiter: char) -> String {
        format!("c_custkey{delimiter}c_name{delimiter}c_address{delimiter}c_nationkey{delimiter}c_phone{delimiter}c_acctbal{delimiter}c_mktsegment{delimiter}c_comment")
    }
}

impl Display for CustomerCsv<'_> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let d = self.delimiter;
        write!(
            f,
            // note must quote the address and comment fields as they may contain the delimiter
            "{}{d}{}{d}\"{}\"{d}{}{d}{}{d}{}{d}{}{d}\"{}\"",
            self.inner.c_custkey,
            self.inner.c_name,
            self.inner.c_address,
            self.inner.c_nationkey,
            self.inner.c_phone,
            self.inner.c_acctbal,
            self.inner.c_mktsegment,
            self.inner.c_comment
        )
    }
}

/// Write [`PartSupp`]s in CSV format.
///
/// # Example
/// ```
/// # use tpchgen::generators::PartSuppGenerator;
/// # use tpchgen::csv::PartSuppCsv;
/// # use std::fmt::Write;
/// // Output the first 3 rows in CSV format
/// let generator = PartSuppGenerator::new(1.0, 1, 1);
/// let mut csv = String::new();
/// writeln!(&mut csv, "{}", PartSuppCsv::header()).unwrap(); // write header
/// for line in generator.iter().take(3) {
///   // write line using CSV formatter
///   writeln!(&mut csv, "{}", PartSuppCsv::new(line)).unwrap();
/// }
/// assert_eq!(
///   csv,
///   "ps_partkey,ps_suppkey,ps_availqty,ps_supplycost,ps_comment\n\
///    1,2,3325,771.64,\", even theodolites. regular, final theodolites eat after the carefully pending foxes. furiously regular deposits sleep slyly. carefully bold realms above the ironic dependencies haggle careful\"\n\
///    1,2502,8076,993.49,\"ven ideas. quickly even packages print. pending multipliers must have to are fluff\"\n\
///    1,5002,3956,337.09,\"after the fluffily ironic deposits? blithely special dependencies integrate furiously even excuses. blithely silent theodolites could have to haggle pending, express requests; fu\"\n"
/// );
/// ```
pub struct PartSuppCsv<'a> {
    inner: PartSupp<'a>,
    delimiter: char,
}

impl<'a> PartSuppCsv<'a> {
    pub fn new(inner: PartSupp<'a>) -> Self {
        Self {
            inner,
            delimiter: ',',
        }
    }

    /// Create a new PartSuppCsv with a custom delimiter
    pub fn with_delimiter(inner: PartSupp<'a>, delimiter: char) -> Self {
        Self { inner, delimiter }
    }

    /// Returns the CSV header for the PartSupp table
    pub fn header() -> &'static str {
        "ps_partkey,ps_suppkey,ps_availqty,ps_supplycost,ps_comment"
    }

    /// Returns the CSV header with a custom delimiter
    pub fn header_with_delimiter(delimiter: char) -> String {
        format!("ps_partkey{delimiter}ps_suppkey{delimiter}ps_availqty{delimiter}ps_supplycost{delimiter}ps_comment")
    }
}

impl Display for PartSuppCsv<'_> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let d = self.delimiter;
        write!(
            f,
            // note must quote the comment field as it may contain the delimiter
            "{}{d}{}{d}{}{d}{}{d}\"{}\"",
            self.inner.ps_partkey,
            self.inner.ps_suppkey,
            self.inner.ps_availqty,
            self.inner.ps_supplycost,
            self.inner.ps_comment
        )
    }
}

/// Write [`Order`]s in CSV format.
///
/// # Example
/// ```
/// # use tpchgen::generators::OrderGenerator;
/// # use tpchgen::csv::OrderCsv;
/// # use std::fmt::Write;
/// // Output the first 3 rows in CSV format
/// let generator = OrderGenerator::new(1.0, 1, 1);
/// let mut csv = String::new();
/// writeln!(&mut csv, "{}", OrderCsv::header()).unwrap(); // write header
/// for line in generator.iter().take(3) {
///   // write line using CSV formatter
///   writeln!(&mut csv, "{}", OrderCsv::new(line)).unwrap();
/// }
/// assert_eq!(
///   csv,
///   "o_orderkey,o_custkey,o_orderstatus,o_totalprice,o_orderdate,o_orderpriority,o_clerk,o_shippriority,o_comment\n\
///    1,36901,O,173665.47,1996-01-02,5-LOW,Clerk#000000951,0,\"nstructions sleep furiously among \"\n\
///    2,78002,O,46929.18,1996-12-01,1-URGENT,Clerk#000000880,0,\" foxes. pending accounts at the pending, silent asymptot\"\n\
///    3,123314,F,193846.25,1993-10-14,5-LOW,Clerk#000000955,0,\"sly final accounts boost. carefully regular ideas cajole carefully. depos\"\n"
/// );
/// ```
pub struct OrderCsv<'a> {
    inner: Order<'a>,
    delimiter: char,
}

impl<'a> OrderCsv<'a> {
    pub fn new(inner: Order<'a>) -> Self {
        Self {
            inner,
            delimiter: ',',
        }
    }

    /// Create a new OrderCsv with a custom delimiter
    pub fn with_delimiter(inner: Order<'a>, delimiter: char) -> Self {
        Self { inner, delimiter }
    }

    /// Returns the CSV header for the Order table
    pub fn header() -> &'static str {
        "o_orderkey,o_custkey,o_orderstatus,o_totalprice,o_orderdate,o_orderpriority,o_clerk,o_shippriority,o_comment"
    }

    /// Returns the CSV header with a custom delimiter
    pub fn header_with_delimiter(delimiter: char) -> String {
        format!("o_orderkey{delimiter}o_custkey{delimiter}o_orderstatus{delimiter}o_totalprice{delimiter}o_orderdate{delimiter}o_orderpriority{delimiter}o_clerk{delimiter}o_shippriority{delimiter}o_comment")
    }
}

impl Display for OrderCsv<'_> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let d = self.delimiter;
        write!(
            f,
            // note must quote the comment field as it may contain the delimiter
            "{}{d}{}{d}{}{d}{}{d}{}{d}{}{d}{}{d}{}{d}\"{}\"",
            self.inner.o_orderkey,
            self.inner.o_custkey,
            self.inner.o_orderstatus,
            self.inner.o_totalprice,
            self.inner.o_orderdate,
            self.inner.o_orderpriority,
            self.inner.o_clerk,
            self.inner.o_shippriority,
            self.inner.o_comment
        )
    }
}

/// Write [`LineItem`]s in CSV format.
///
/// # Example
/// ```
/// # use tpchgen::generators::LineItemGenerator;
/// # use tpchgen::csv::LineItemCsv;
/// # use std::fmt::Write;
/// // Output the first 3 rows in CSV format
/// let generator = LineItemGenerator::new(1.0, 1, 1);
/// let mut csv = String::new();
/// writeln!(&mut csv, "{}", LineItemCsv::header()).unwrap(); // write header
/// for line in generator.iter().take(3) {
///   // write line using CSV formatter
///   writeln!(&mut csv, "{}", LineItemCsv::new(line)).unwrap();
/// }
///  assert_eq!(
///   csv,
///   "l_orderkey,l_partkey,l_suppkey,l_linenumber,l_quantity,l_extendedprice,l_discount,l_tax,l_returnflag,l_linestatus,l_shipdate,l_commitdate,l_receiptdate,l_shipinstruct,l_shipmode,l_comment\n\
///    1,155190,7706,1,17,21168.23,0.04,0.02,N,O,1996-03-13,1996-02-12,1996-03-22,DELIVER IN PERSON,TRUCK,\"egular courts above the\"\n\
///    1,67310,7311,2,36,45983.16,0.09,0.06,N,O,1996-04-12,1996-02-28,1996-04-20,TAKE BACK RETURN,MAIL,\"ly final dependencies: slyly bold \"\n\
///    1,63700,3701,3,8,13309.60,0.10,0.02,N,O,1996-01-29,1996-03-05,1996-01-31,TAKE BACK RETURN,REG AIR,\"riously. regular, express dep\"\n"
///   );
/// ```
///
/// [crate documentation]: crate
pub struct LineItemCsv<'a> {
    inner: LineItem<'a>,
    delimiter: char,
}
impl<'a> LineItemCsv<'a> {
    pub fn new(inner: LineItem<'a>) -> Self {
        Self {
            inner,
            delimiter: ',',
        }
    }

    /// Create a new LineItemCsv with a custom delimiter
    pub fn with_delimiter(inner: LineItem<'a>, delimiter: char) -> Self {
        Self { inner, delimiter }
    }

    /// Returns the CSV header for the LineItem table
    pub fn header() -> &'static str {
        "l_orderkey,l_partkey,l_suppkey,l_linenumber,l_quantity,l_extendedprice,l_discount,l_tax,l_returnflag,l_linestatus,l_shipdate,l_commitdate,l_receiptdate,l_shipinstruct,l_shipmode,l_comment"
    }

    /// Returns the CSV header with a custom delimiter
    pub fn header_with_delimiter(delimiter: char) -> String {
        format!("l_orderkey{delimiter}l_partkey{delimiter}l_suppkey{delimiter}l_linenumber{delimiter}l_quantity{delimiter}l_extendedprice{delimiter}l_discount{delimiter}l_tax{delimiter}l_returnflag{delimiter}l_linestatus{delimiter}l_shipdate{delimiter}l_commitdate{delimiter}l_receiptdate{delimiter}l_shipinstruct{delimiter}l_shipmode{delimiter}l_comment")
    }
}

impl Display for LineItemCsv<'_> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let d = self.delimiter;
        write!(
            f,
            // note must quote the comment field as it may contain the delimiter
            "{}{d}{}{d}{}{d}{}{d}{}{d}{}{d}{}{d}{}{d}{}{d}{}{d}{}{d}{}{d}{}{d}{}{d}{}{d}\"{}\"",
            self.inner.l_orderkey,
            self.inner.l_partkey,
            self.inner.l_suppkey,
            self.inner.l_linenumber,
            self.inner.l_quantity,
            self.inner.l_extendedprice,
            self.inner.l_discount,
            self.inner.l_tax,
            self.inner.l_returnflag,
            self.inner.l_linestatus,
            self.inner.l_shipdate,
            self.inner.l_commitdate,
            self.inner.l_receiptdate,
            self.inner.l_shipinstruct,
            self.inner.l_shipmode,
            self.inner.l_comment
        )
    }
}