This is an automated email from the ASF dual-hosted git repository. jiayu pushed a commit to branch main in repository https://gitbox.apache.org/repos/asf/sedona-spatialbench.git
commit a85c8f5c2bc626dcf8943830b1893a32f753226f Author: Pranav Toggi <[email protected]> AuthorDate: Mon Jun 16 18:33:04 2025 -0700 Add Vehicle --- tpchgen-arrow/src/lib.rs | 6 +- tpchgen-arrow/src/{part.rs => vehicle.rs} | 78 ++-- tpchgen-arrow/tests/reparse.rs | 12 +- tpchgen-cli/src/csv.rs | 7 +- tpchgen-cli/src/main.rs | 40 +- tpchgen-cli/src/tbl.rs | 4 +- tpchgen/src/csv.rs | 105 +---- tpchgen/src/generators.rs | 713 +++++++++--------------------- tpchgen/tests/integration_tests.rs | 25 +- 9 files changed, 288 insertions(+), 702 deletions(-) diff --git a/tpchgen-arrow/src/lib.rs b/tpchgen-arrow/src/lib.rs index 1c0c335..c3924fa 100644 --- a/tpchgen-arrow/src/lib.rs +++ b/tpchgen-arrow/src/lib.rs @@ -19,7 +19,7 @@ //! let formatted_batches = pretty_format_batches(&[batch]).unwrap().to_string(); //! assert_eq!(formatted_batches.lines().collect::<Vec<_>>(), vec![ //! "+------------+-----------+-----------+--------------+------------+-----------------+------------+-------+--------------+--------------+------------+--------------+---------------+-------------------+------------+-------------------------------------+", -//! "| 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 |", +//! "| l_orderkey | l_vehiclekey | 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 |", //! "+------------+-----------+-----------+--------------+------------+-----------------+------------+-------+--------------+--------------+------------+--------------+---------------+-------------------+------------+-------------------------------------+", //! "| 1 | 155190 | 7706 | 1 | 17.00 | 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 |", //! "| 1 | 67310 | 7311 | 2 | 36.00 | 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 |", @@ -39,7 +39,7 @@ mod customer; mod lineitem; mod nation; mod order; -mod part; +mod vehicle; mod region; mod driver; @@ -49,7 +49,7 @@ pub use customer::CustomerArrow; pub use lineitem::LineItemArrow; pub use nation::NationArrow; pub use order::OrderArrow; -pub use part::PartArrow; +pub use vehicle::VehicleArrow; pub use region::RegionArrow; pub use driver::DriverArrow; diff --git a/tpchgen-arrow/src/part.rs b/tpchgen-arrow/src/vehicle.rs similarity index 60% rename from tpchgen-arrow/src/part.rs rename to tpchgen-arrow/src/vehicle.rs index 4c52a2c..84991e2 100644 --- a/tpchgen-arrow/src/part.rs +++ b/tpchgen-arrow/src/vehicle.rs @@ -3,20 +3,20 @@ use crate::{DEFAULT_BATCH_SIZE, RecordBatchIterator}; use arrow::array::{Int32Array, Int64Array, RecordBatch, StringViewArray}; use arrow::datatypes::{DataType, Field, Schema, SchemaRef}; use std::sync::{Arc, LazyLock}; -use tpchgen::generators::{PartGenerator, PartGeneratorIterator}; +use tpchgen::generators::{VehicleGenerator, VehicleGeneratorIterator}; -/// Generate [`Part`]s in [`RecordBatch`] format +/// Generate [`Vehicle`]s in [`RecordBatch`] format /// -/// [`Part`]: tpchgen::generators::Part +/// [`Vehicle`]: tpchgen::generators::Vehicle /// /// # Example /// ``` -/// # use tpchgen::generators::{PartGenerator}; -/// # use tpchgen_arrow::PartArrow; +/// # use tpchgen::generators::{VehicleGenerator}; +/// # use tpchgen_arrow::VehicleArrow; /// /// // Create a SF=1.0 generator and wrap it in an Arrow generator -/// let generator = PartGenerator::new(1.0, 1, 1); -/// let mut arrow_generator = PartArrow::new(generator) +/// let generator = VehicleGenerator::new(1.0, 1, 1); +/// let mut arrow_generator = VehicleArrow::new(generator) /// .with_batch_size(10); /// // Read the first 10 batches /// let batch = arrow_generator.next().unwrap(); @@ -27,7 +27,7 @@ use tpchgen::generators::{PartGenerator, PartGeneratorIterator}; /// let lines = formatted_batches.lines().collect::<Vec<_>>(); /// assert_eq!(lines, vec![ /// "+-----------+------------------------------------------+----------------+----------+-------------------------+--------+-------------+---------------+----------------------+", -/// "| p_partkey | p_name | p_mfgr | p_brand | p_type | p_size | p_container | p_retailprice | p_comment |", +/// "| v_vehiclekey | v_name | v_mfgr | v_brand | v_type | v_size | v_container | v_retailprice | v_comment |", /// "+-----------+------------------------------------------+----------------+----------+-------------------------+--------+-------------+---------------+----------------------+", /// "| 1 | goldenrod lavender spring chocolate lace | Manufacturer#1 | Brand#13 | PROMO BURNISHED COPPER | 7 | JUMBO PKG | 901.00 | ly. slyly ironi |", /// "| 2 | blush thistle blue yellow saddle | Manufacturer#1 | Brand#13 | LARGE BRUSHED BRASS | 1 | LG CASE | 902.00 | lar accounts amo |", @@ -42,13 +42,13 @@ use tpchgen::generators::{PartGenerator, PartGeneratorIterator}; /// "+-----------+------------------------------------------+----------------+----------+-------------------------+--------+-------------+---------------+----------------------+" /// ]); /// ``` -pub struct PartArrow { - inner: PartGeneratorIterator<'static>, +pub struct VehicleArrow { + inner: VehicleGeneratorIterator<'static>, batch_size: usize, } -impl PartArrow { - pub fn new(generator: PartGenerator<'static>) -> Self { +impl VehicleArrow { + pub fn new(generator: VehicleGenerator<'static>) -> Self { Self { inner: generator.iter(), batch_size: DEFAULT_BATCH_SIZE, @@ -62,13 +62,13 @@ impl PartArrow { } } -impl RecordBatchIterator for PartArrow { +impl RecordBatchIterator for VehicleArrow { fn schema(&self) -> &SchemaRef { - &PART_SCHEMA + &VEHICLE_SCHEMA } } -impl Iterator for PartArrow { +impl Iterator for VehicleArrow { type Item = RecordBatch; fn next(&mut self) -> Option<Self::Item> { @@ -78,28 +78,20 @@ impl Iterator for PartArrow { return None; } - let p_partkey = Int64Array::from_iter_values(rows.iter().map(|r| r.p_partkey)); - let p_name = string_view_array_from_display_iter(rows.iter().map(|r| &r.p_name)); - let p_mfgr = string_view_array_from_display_iter(rows.iter().map(|r| r.p_mfgr)); - let p_brand = string_view_array_from_display_iter(rows.iter().map(|r| r.p_brand)); - let p_type = StringViewArray::from_iter_values(rows.iter().map(|r| r.p_type)); - let p_size = Int32Array::from_iter_values(rows.iter().map(|r| r.p_size)); - let p_container = StringViewArray::from_iter_values(rows.iter().map(|r| r.p_container)); - let p_retailprice = decimal128_array_from_iter(rows.iter().map(|r| r.p_retailprice)); - let p_comment = StringViewArray::from_iter_values(rows.iter().map(|r| r.p_comment)); + let v_vehiclekey = Int64Array::from_iter_values(rows.iter().map(|r| r.v_vehiclekey)); + let v_mfgr = string_view_array_from_display_iter(rows.iter().map(|r| r.v_mfgr)); + let v_brand = string_view_array_from_display_iter(rows.iter().map(|r| r.v_brand)); + let v_type = StringViewArray::from_iter_values(rows.iter().map(|r| r.v_type)); + let v_license = StringViewArray::from_iter_values(rows.iter().map(|r| r.v_license)); let batch = RecordBatch::try_new( Arc::clone(self.schema()), vec![ - Arc::new(p_partkey), - Arc::new(p_name), - Arc::new(p_mfgr), - Arc::new(p_brand), - Arc::new(p_type), - Arc::new(p_size), - Arc::new(p_container), - Arc::new(p_retailprice), - Arc::new(p_comment), + Arc::new(v_vehiclekey), + Arc::new(v_mfgr), + Arc::new(v_brand), + Arc::new(v_type), + Arc::new(v_license), ], ) .unwrap(); @@ -107,18 +99,14 @@ impl Iterator for PartArrow { } } -/// Schema for the Part -static PART_SCHEMA: LazyLock<SchemaRef> = LazyLock::new(make_part_schema); -fn make_part_schema() -> SchemaRef { +/// Schema for the Vehicle +static VEHICLE_SCHEMA: LazyLock<SchemaRef> = LazyLock::new(make_vehicle_schema); +fn make_vehicle_schema() -> SchemaRef { Arc::new(Schema::new(vec![ - Field::new("p_partkey", DataType::Int64, false), - Field::new("p_name", DataType::Utf8View, false), - Field::new("p_mfgr", DataType::Utf8View, false), - Field::new("p_brand", DataType::Utf8View, false), - Field::new("p_type", DataType::Utf8View, false), - Field::new("p_size", DataType::Int32, false), - Field::new("p_container", DataType::Utf8View, false), - Field::new("p_retailprice", DataType::Decimal128(15, 2), false), - Field::new("p_comment", DataType::Utf8View, false), + Field::new("v_vehiclekey", DataType::Int64, false), + Field::new("v_mfgr", DataType::Utf8View, false), + Field::new("v_brand", DataType::Utf8View, false), + Field::new("v_type", DataType::Utf8View, false), + Field::new("v_comment", DataType::Utf8View, false), ])) } diff --git a/tpchgen-arrow/tests/reparse.rs b/tpchgen-arrow/tests/reparse.rs index 899c084..acd0ae7 100644 --- a/tpchgen-arrow/tests/reparse.rs +++ b/tpchgen-arrow/tests/reparse.rs @@ -6,15 +6,15 @@ use arrow::datatypes::SchemaRef; use std::io::Write; use std::sync::Arc; use tpchgen::csv::{ - CustomerCsv, LineItemCsv, NationCsv, OrderCsv, PartCsv, PartSuppCsv, RegionCsv, DriverCsv, + CustomerCsv, LineItemCsv, NationCsv, OrderCsv, VehicleCsv, RegionCsv, DriverCsv, }; use tpchgen::generators::{ Customer, CustomerGenerator, LineItem, LineItemGenerator, Nation, NationGenerator, Order, - OrderGenerator, Part, PartGenerator, PartSupp, PartSuppGenerator, Region, RegionGenerator, + OrderGenerator, Vehicle, VehicleGenerator, Region, RegionGenerator, Driver, DriverGenerator, }; use tpchgen_arrow::{ - CustomerArrow, LineItemArrow, NationArrow, OrderArrow, PartArrow, + CustomerArrow, LineItemArrow, NationArrow, OrderArrow, VehicleArrow, RecordBatchIterator, RegionArrow, DriverArrow, }; @@ -44,8 +44,8 @@ test_row_type!(nation_tbl, NationGenerator, NationArrow, Test::tbl()); test_row_type!(nation_csv, NationGenerator, NationArrow, Test::csv()); test_row_type!(order_tbl, OrderGenerator, OrderArrow, Test::tbl()); test_row_type!(order_csv, OrderGenerator, OrderArrow, Test::csv()); -test_row_type!(part_tbl, PartGenerator, PartArrow, Test::tbl()); -test_row_type!(part_csv, PartGenerator, PartArrow, Test::csv()); +test_row_type!(part_tbl, VehicleGenerator, VehicleArrow, Test::tbl()); +test_row_type!(part_csv, VehicleGenerator, VehicleArrow, Test::csv()); test_row_type!(region_tbl, RegionGenerator, RegionArrow, Test::tbl()); test_row_type!(region_csv, RegionGenerator, RegionArrow, Test::csv()); test_row_type!(driver_tbl, DriverGenerator, DriverArrow, Test::tbl()); @@ -82,7 +82,7 @@ impl_row_type!(Customer<'_>, CustomerCsv); impl_row_type!(LineItem<'_>, LineItemCsv); impl_row_type!(Nation<'_>, NationCsv); impl_row_type!(Order<'_>, OrderCsv); -impl_row_type!(Part<'_>, PartCsv); +impl_row_type!(Vehicle<'_>, VehicleCsv); impl_row_type!(Region<'_>, RegionCsv); impl_row_type!(Driver, DriverCsv); diff --git a/tpchgen-cli/src/csv.rs b/tpchgen-cli/src/csv.rs index 6e78108..77f7229 100644 --- a/tpchgen-cli/src/csv.rs +++ b/tpchgen-cli/src/csv.rs @@ -2,11 +2,10 @@ use super::generate::Source; use std::io::Write; use tpchgen::csv::{ - CustomerCsv, LineItemCsv, NationCsv, OrderCsv, PartCsv, PartSuppCsv, RegionCsv, DriverCsv, + CustomerCsv, LineItemCsv, NationCsv, OrderCsv, PartCsv, RegionCsv, DriverCsv, }; use tpchgen::generators::{ - CustomerGenerator, LineItemGenerator, NationGenerator, OrderGenerator, PartGenerator, - PartSuppGenerator, RegionGenerator, DriverGenerator, + CustomerGenerator, LineItemGenerator, NationGenerator, OrderGenerator, VehicleGenerator, RegionGenerator, DriverGenerator, }; /// Define a Source that writes the table in CSV format @@ -44,7 +43,7 @@ macro_rules! define_csv_source { // Define .csv sources for all tables define_csv_source!(NationCsvSource, NationGenerator<'static>, NationCsv); define_csv_source!(RegionCsvSource, RegionGenerator<'static>, RegionCsv); -define_csv_source!(PartCsvSource, PartGenerator<'static>, PartCsv); +define_csv_source!(VehicleCsvSource, VehicleGenerator<'static>, VehicleCsv); define_csv_source!(DriverCsvSource, DriverGenerator<'static>, DriverCsv); define_csv_source!(CustomerCsvSource, CustomerGenerator<'static>, CustomerCsv); define_csv_source!(OrderCsvSource, OrderGenerator<'static>, OrderCsv); diff --git a/tpchgen-cli/src/main.rs b/tpchgen-cli/src/main.rs index c3b6fc8..110fe10 100644 --- a/tpchgen-cli/src/main.rs +++ b/tpchgen-cli/src/main.rs @@ -62,12 +62,11 @@ use std::str::FromStr; use std::time::Instant; use tpchgen::distribution::Distributions; use tpchgen::generators::{ - CustomerGenerator, LineItemGenerator, NationGenerator, OrderGenerator, PartGenerator, - PartSuppGenerator, RegionGenerator, DriverGenerator, + CustomerGenerator, LineItemGenerator, NationGenerator, OrderGenerator, VehicleGenerator, RegionGenerator, DriverGenerator, }; use tpchgen::text::TextPool; use tpchgen_arrow::{ - CustomerArrow, LineItemArrow, NationArrow, OrderArrow, PartArrow, + CustomerArrow, LineItemArrow, NationArrow, OrderArrow, VehicleArrow, RecordBatchIterator, RegionArrow, DriverArrow, }; @@ -133,7 +132,7 @@ struct Cli { enum Table { Nation, Region, - Part, + Vehicle, Driver, Customer, Orders, @@ -175,8 +174,7 @@ impl TypedValueParser for TableValueParser { clap::builder::PossibleValue::new("nation").help("Nation table (alias: n)"), clap::builder::PossibleValue::new("Driver").help("Driver table (alias: s)"), clap::builder::PossibleValue::new("customer").help("Customer table (alias: c)"), - clap::builder::PossibleValue::new("part").help("Part table (alias: P)"), - clap::builder::PossibleValue::new("partsupp").help("PartSupp table (alias: S)"), + clap::builder::PossibleValue::new("vehicle").help("Vehicle table (alias: P)"), clap::builder::PossibleValue::new("orders").help("Orders table (alias: O)"), clap::builder::PossibleValue::new("lineitem").help("LineItem table (alias: L)"), ] @@ -199,7 +197,7 @@ impl FromStr for Table { "n" | "nation" => Ok(Table::Nation), "r" | "region" => Ok(Table::Region), "d" | "Driver" => Ok(Table::Driver), - "P" | "part" => Ok(Table::Part), + "V" | "vehicle" => Ok(Table::Vehicle), "c" | "customer" => Ok(Table::Customer), "O" | "orders" => Ok(Table::Orders), "L" | "lineitem" => Ok(Table::Lineitem), @@ -213,9 +211,8 @@ impl Table { match self { Table::Nation => "nation", Table::Region => "region", - Table::Part => "part", + Table::Vehicle => "vehicle", Table::Driver => "Driver", - Table::Partsupp => "partsupp", Table::Customer => "customer", Table::Orders => "orders", Table::Lineitem => "lineitem", @@ -292,7 +289,7 @@ impl Cli { vec![ Table::Nation, Table::Region, - Table::Part, + Table::Vehicle, Table::Driver, Table::Customer, Table::Orders, @@ -314,9 +311,8 @@ impl Cli { match table { Table::Nation => self.generate_nation().await?, Table::Region => self.generate_region().await?, - Table::Part => self.generate_part().await?, - Table::Driver => self.generate_Driver().await?, - Table::Partsupp => self.generate_partsupp().await?, + Table::Vehicle => self.generate_part().await?, + Table::Driver => self.generate_driver().await?, Table::Customer => self.generate_customer().await?, Table::Orders => self.generate_orders().await?, Table::Lineitem => self.generate_lineitem().await?, @@ -345,11 +341,11 @@ impl Cli { ); define_generate!( generate_part, - Table::Part, - PartGenerator, - PartTblSource, - PartCsvSource, - PartArrow + Table::Vehicle, + VehicleGenerator, + VehicleTblSource, + VehicleCsvSource, + VehicleArrow ); define_generate!( generate_driver, @@ -419,18 +415,14 @@ impl Cli { let (avg_row_size_bytes, row_count) = match table { Table::Nation => (88, 1), Table::Region => (77, 1), - Table::Part => ( + Table::Vehicle => ( 115, - PartGenerator::calculate_row_count(self.scale_factor, 1, 1), + VehicleGenerator::calculate_row_count(self.scale_factor, 1, 1), ), Table::Driver => ( 140, DriverGenerator::calculate_row_count(self.scale_factor, 1, 1), ), - Table::Partsupp => ( - 148, - PartSuppGenerator::calculate_row_count(self.scale_factor, 1, 1), - ), Table::Customer => ( 160, CustomerGenerator::calculate_row_count(self.scale_factor, 1, 1), diff --git a/tpchgen-cli/src/tbl.rs b/tpchgen-cli/src/tbl.rs index f60c598..50abbd6 100644 --- a/tpchgen-cli/src/tbl.rs +++ b/tpchgen-cli/src/tbl.rs @@ -3,7 +3,7 @@ use super::generate::Source; use std::io::Write; use tpchgen::generators::{ - CustomerGenerator, LineItemGenerator, NationGenerator, OrderGenerator, PartGenerator, RegionGenerator, DriverGenerator, + CustomerGenerator, LineItemGenerator, NationGenerator, OrderGenerator, VehicleGenerator, RegionGenerator, DriverGenerator, }; /// Define a Source that writes the table in TBL format @@ -39,7 +39,7 @@ macro_rules! define_tbl_source { // Define .tbl sources for all tables define_tbl_source!(NationTblSource, NationGenerator<'static>); define_tbl_source!(RegionTblSource, RegionGenerator<'static>); -define_tbl_source!(PartTblSource, PartGenerator<'static>); +define_tbl_source!(VehicleTblSource, VehicleGenerator<'static>); define_tbl_source!(DriverTblSource, DriverGenerator<'static>); define_tbl_source!(CustomerTblSource, CustomerGenerator<'static>); define_tbl_source!(OrderTblSource, OrderGenerator<'static>); diff --git a/tpchgen/src/csv.rs b/tpchgen/src/csv.rs index 87d7560..5652573 100644 --- a/tpchgen/src/csv.rs +++ b/tpchgen/src/csv.rs @@ -1,6 +1,6 @@ //! CSV formatting support for the row struct objects generated by the library. -use crate::generators::{Customer, LineItem, Nation, Order, Part, PartSupp, Region, Driver}; +use crate::generators::{Customer, LineItem, Nation, Order, Vehicle, Region, Driver}; use core::fmt; use std::fmt::Display; @@ -102,59 +102,55 @@ impl Display for RegionCsv<'_> { } } -/// Write [`Part`]s in CSV format. +/// Write [`Vehicle`]s in CSV format. /// /// # Example /// ``` -/// # use tpchgen::generators::PartGenerator; -/// # use tpchgen::csv::PartCsv; +/// # use tpchgen::generators::VehicleGenerator; +/// # use tpchgen::csv::VehicleCsv; /// # use std::fmt::Write; /// // Output the first 3 rows in CSV format -/// let generator = PartGenerator::new(1.0, 1, 1); +/// let generator = VehicleGenerator::new(1.0, 1, 1); /// let mut csv = String::new(); -/// writeln!(&mut csv, "{}", PartCsv::header()).unwrap(); // write header +/// writeln!(&mut csv, "{}", VehicleCsv::header()).unwrap(); // write header /// for line in generator.iter().take(3) { /// // write line using CSV formatter -/// writeln!(&mut csv, "{}", PartCsv::new(line)).unwrap(); +/// writeln!(&mut csv, "{}", VehicleCsv::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\ +/// "v_vehiclekey,v_name,v_mfgr,v_brand,v_type,v_size,v_container,v_retailprice,v_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>, +pub struct VehicleCsv<'a> { + inner: Vehicle<'a>, } -impl<'a> PartCsv<'a> { - pub fn new(inner: Part<'a>) -> Self { +impl<'a> VehicleCsv<'a> { + pub fn new(inner: Vehicle<'a>) -> Self { Self { inner } } - /// Returns the CSV header for the Part table + /// Returns the CSV header for the Vehicle table pub fn header() -> &'static str { - "p_partkey,p_name,p_mfgr,p_brand,p_type,p_size,p_container,p_retailprice,p_comment" + "v_vehiclekey,v_name,v_mfgr,v_brand,v_type, v_licence" } } -impl Display for PartCsv<'_> { +impl Display for VehicleCsv<'_> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, // note must quote the comment field as it may contain commas - "{},{},{},{},{},{},{},{},\"{}\"", - 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 + "{},{},{},{},\"{}\"", + self.inner.v_vehiclekey, + self.inner.v_mfgr, + self.inner.v_brand, + self.inner.v_type, + self.inner.v_license ) } } @@ -267,59 +263,6 @@ impl Display for CustomerCsv<'_> { } } -/// 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>, -} - -impl<'a> PartSuppCsv<'a> { - pub fn new(inner: PartSupp<'a>) -> Self { - Self { inner } - } - - /// Returns the CSV header for the PartSupp table - pub fn header() -> &'static str { - "ps_partkey,ps_suppkey,ps_availqty,ps_supplycost,ps_comment" - } -} - -impl Display for PartSuppCsv<'_> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!( - f, - // note must quote the comment field as it may contain commas - "{},{},{},{},\"{}\"", - 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 @@ -394,7 +337,7 @@ impl Display for OrderCsv<'_> { /// } /// 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\ +/// "l_orderkey,l_vehiclekey,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" @@ -412,7 +355,7 @@ impl<'a> LineItemCsv<'a> { /// 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" + "l_orderkey,l_vehiclekey,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" } } @@ -423,7 +366,7 @@ impl Display for LineItemCsv<'_> { // note must quote the comment field as it may contain commas "{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},\"{}\"", self.inner.l_orderkey, - self.inner.l_partkey, + self.inner.l_vehiclekey, self.inner.l_suppkey, self.inner.l_linenumber, self.inner.l_quantity, diff --git a/tpchgen/src/generators.rs b/tpchgen/src/generators.rs index 4b5566f..c9efbff 100644 --- a/tpchgen/src/generators.rs +++ b/tpchgen/src/generators.rs @@ -5,7 +5,7 @@ use crate::distribution::Distribution; use crate::distribution::Distributions; use crate::random::RandomPhoneNumber; use crate::random::RowRandomInt; -use crate::random::{PhoneNumberInstance, RandomBoundedLong, StringSequenceInstance}; +use crate::random::{PhoneNumberInstance, RandomBoundedLong}; use crate::random::{RandomAlphaNumeric, RandomAlphaNumericInstance}; use crate::text::TextPool; use core::fmt; @@ -31,14 +31,14 @@ impl Default for NationGenerator<'_> { impl<'a> NationGenerator<'a> { /// Creates a new NationGenerator with default distributions and text pool /// - /// Nations does not depend on the scale factor or the part number. The signature of + /// Nations does not depend on the scale factor or the vehicle number. The signature of /// this method is provided to be consistent with the other generators, but the /// parameters are ignored. You can use [`NationGenerator::default`] to create a /// default generator. /// /// The generator's lifetime is `&'static` because it references global /// [`Distribution]`s and thus can be shared safely between threads. - pub fn new(_scale_factor: f64, _part: i32, _part_count: i32) -> NationGenerator<'static> { + pub fn new(_scale_factor: f64, _vehicle: i32, _vehicle_count: i32) -> NationGenerator<'static> { // Note: use explicit lifetime to ensure this remains `&'static` Self::new_with_distributions_and_text_pool( Distributions::static_default(), @@ -222,14 +222,14 @@ impl Default for RegionGenerator<'_> { impl<'a> RegionGenerator<'a> { /// Creates a new RegionGenerator with default distributions and text pool /// - /// Regions does not depend on the scale factor or the part number. The signature of + /// Regions does not depend on the scale factor or the vehicle number. The signature of /// this method is provided to be consistent with the other generators, but the /// parameters are ignored. You can use [`RegionGenerator::default`] to create a /// default generator. /// /// Note the generator's lifetime is `&'static`. See [`NationGenerator`] for /// more details. - pub fn new(_scale_factor: f64, _part: i32, _part_count: i32) -> RegionGenerator<'static> { + pub fn new(_scale_factor: f64, _vehicle: i32, _vehicle_count: i32) -> RegionGenerator<'static> { // Note: use explicit lifetime to ensure this remains `&'static` Self::new_with_distributions_and_text_pool( Distributions::static_default(), @@ -308,33 +308,33 @@ impl<'a> Iterator for RegionGeneratorIterator<'a> { } } -/// A Part Manufacturer, formatted as `"Manufacturer#<n>"` +/// A Vehicle Manufacturer, formatted as `"Manufacturer#<n>"` #[derive(Debug, Clone, Copy, PartialEq)] -pub struct PartManufacturerName(i32); +pub struct VehicleManufacturerName(i32); -impl PartManufacturerName { +impl VehicleManufacturerName { pub fn new(value: i32) -> Self { - PartManufacturerName(value) + VehicleManufacturerName(value) } } -impl fmt::Display for PartManufacturerName { +impl fmt::Display for VehicleManufacturerName { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "Manufacturer#{}", self.0) } } -/// A Part brand name, formatted as `"Brand#<n>"` +/// A Vehicle brand name, formatted as `"Brand#<n>"` #[derive(Debug, Clone, Copy, PartialEq)] -pub struct PartBrandName(i32); +pub struct VehicleBrandName(i32); -impl PartBrandName { +impl VehicleBrandName { pub fn new(value: i32) -> Self { - PartBrandName(value) + VehicleBrandName(value) } } -impl fmt::Display for PartBrandName { +impl fmt::Display for VehicleBrandName { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "Brand#{}", self.0) } @@ -350,60 +350,48 @@ impl fmt::Display for PartBrandName { /// 2|blush thistle blue yellow saddle|Manufacturer#1|Brand#13|LARGE BRUSHED BRASS|1|LG CASE|902.00|lar accounts amo| /// ``` #[derive(Debug, Clone, PartialEq)] -pub struct Part<'a> { +pub struct Vehicle<'a> { /// Primary key - pub p_partkey: i64, - /// Part name - pub p_name: StringSequenceInstance<'a>, - /// Part manufacturer. - pub p_mfgr: PartManufacturerName, - /// Part brand. - pub p_brand: PartBrandName, - /// Part type - pub p_type: &'a str, - /// Part size - pub p_size: i32, - /// Part container - pub p_container: &'a str, - /// Part retail price - pub p_retailprice: TPCHDecimal, + pub v_vehiclekey: i64, + /// Vehicle manufacturer. + pub v_mfgr: VehicleManufacturerName, + /// Vehicle brand. + pub v_brand: VehicleBrandName, + /// Vehicle type + pub v_type: &'a str, /// Variable length comment - pub p_comment: &'a str, + pub v_license: &'a str, } -impl fmt::Display for Part<'_> { +impl fmt::Display for Vehicle<'_> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, - "{}|{}|{}|{}|{}|{}|{}|{}|{}|", - self.p_partkey, - self.p_name, - self.p_mfgr, - self.p_brand, - self.p_type, - self.p_size, - self.p_container, - self.p_retailprice, - self.p_comment + "{}|{}|{}|{}|{}|", + self.v_vehiclekey, + self.v_mfgr, + self.v_brand, + self.v_type, + self.v_license ) } } -/// Generator for Part table data +/// Generator for Vehicle table data #[derive(Debug, Clone)] -pub struct PartGenerator<'a> { +pub struct VehicleGenerator<'a> { scale_factor: f64, - part: i32, - part_count: i32, + vehicle: i32, + vehicle_count: i32, distributions: &'a Distributions, text_pool: &'a TextPool, } -impl<'a> PartGenerator<'a> { - /// Base scale for part generation +impl<'a> VehicleGenerator<'a> { + /// Base scale for vehicle generation const SCALE_BASE: i32 = 200_000; - // Constants for part generation + // Constants for vehicle generation const NAME_WORDS: i32 = 5; const MANUFACTURER_MIN: i32 = 1; const MANUFACTURER_MAX: i32 = 5; @@ -413,71 +401,71 @@ impl<'a> PartGenerator<'a> { const SIZE_MAX: i32 = 50; const COMMENT_AVERAGE_LENGTH: i32 = 14; - /// Creates a new PartGenerator with the given scale factor + /// Creates a new VehicleGenerator with the given scale factor /// /// Note the generator's lifetime is `&'static`. See [`NationGenerator`] for /// more details. - pub fn new(scale_factor: f64, part: i32, part_count: i32) -> PartGenerator<'static> { + pub fn new(scale_factor: f64, vehicle: i32, vehicle_count: i32) -> VehicleGenerator<'static> { // Note: use explicit lifetime to ensure this remains `&'static` Self::new_with_distributions_and_text_pool( scale_factor, - part, - part_count, + vehicle, + vehicle_count, Distributions::static_default(), TextPool::get_or_init_default(), ) } - /// Creates a PartGenerator with specified distributions and text pool + /// Creates a VehicleGenerator with specified distributions and text pool pub fn new_with_distributions_and_text_pool<'b>( scale_factor: f64, - part: i32, - part_count: i32, + vehicle: i32, + vehicle_count: i32, distributions: &'b Distributions, text_pool: &'b TextPool, - ) -> PartGenerator<'b> { - PartGenerator { + ) -> VehicleGenerator<'b> { + VehicleGenerator { scale_factor, - part, - part_count, + vehicle, + vehicle_count, distributions, text_pool, } } - /// Return the row count for the given scale factor and generator part count - pub fn calculate_row_count(scale_factor: f64, part: i32, part_count: i32) -> i64 { - GenerateUtils::calculate_row_count(Self::SCALE_BASE, scale_factor, part, part_count) + /// Return the row count for the given scale factor and generator vehicle count + pub fn calculate_row_count(scale_factor: f64, vehicle: i32, vehicle_count: i32) -> i64 { + GenerateUtils::calculate_row_count(Self::SCALE_BASE, scale_factor, vehicle, vehicle_count) } - /// Returns an iterator over the part rows - pub fn iter(&self) -> PartGeneratorIterator<'a> { - PartGeneratorIterator::new( + /// Returns an iterator over the vehicle rows + pub fn iter(&self) -> VehicleGeneratorIterator<'a> { + VehicleGeneratorIterator::new( self.distributions, self.text_pool, GenerateUtils::calculate_start_index( Self::SCALE_BASE, self.scale_factor, - self.part, - self.part_count, + self.vehicle, + self.vehicle_count, ), - Self::calculate_row_count(self.scale_factor, self.part, self.part_count), + Self::calculate_row_count(self.scale_factor, self.vehicle, self.vehicle_count), ) } } -impl<'a> IntoIterator for &'a PartGenerator<'a> { - type Item = Part<'a>; - type IntoIter = PartGeneratorIterator<'a>; +impl<'a> IntoIterator for &'a VehicleGenerator<'a> { + type Item = Vehicle<'a>; + type IntoIter = VehicleGeneratorIterator<'a>; fn into_iter(self) -> Self::IntoIter { self.iter() } } -/// Iterator that generates Part rows +/// Iterator that generates Vehicle rows #[derive(Debug)] -pub struct PartGeneratorIterator<'a> { +pub struct VehicleGeneratorIterator<'a> { name_random: RandomStringSequence<'a>, manufacturer_random: RandomBoundedInt, brand_random: RandomBoundedInt, @@ -491,7 +479,7 @@ pub struct PartGeneratorIterator<'a> { index: i64, } -impl<'a> PartGeneratorIterator<'a> { +impl<'a> VehicleGeneratorIterator<'a> { fn new( distributions: &'a Distributions, text_pool: &'a TextPool, @@ -500,24 +488,24 @@ impl<'a> PartGeneratorIterator<'a> { ) -> Self { let mut name_random = RandomStringSequence::new( 709314158, - PartGenerator::NAME_WORDS, + VehicleGenerator::NAME_WORDS, distributions.part_colors(), ); let mut manufacturer_random = RandomBoundedInt::new( 1, - PartGenerator::MANUFACTURER_MIN, - PartGenerator::MANUFACTURER_MAX, + VehicleGenerator::MANUFACTURER_MIN, + VehicleGenerator::MANUFACTURER_MAX, ); let mut brand_random = - RandomBoundedInt::new(46831694, PartGenerator::BRAND_MIN, PartGenerator::BRAND_MAX); + RandomBoundedInt::new(46831694, VehicleGenerator::BRAND_MIN, VehicleGenerator::BRAND_MAX); let mut type_random = RandomString::new(1841581359, distributions.part_types()); let mut size_random = - RandomBoundedInt::new(1193163244, PartGenerator::SIZE_MIN, PartGenerator::SIZE_MAX); + RandomBoundedInt::new(1193163244, VehicleGenerator::SIZE_MIN, VehicleGenerator::SIZE_MAX); let mut container_random = RandomString::new(727633698, distributions.part_containers()); let mut comment_random = RandomText::new( 804159733, text_pool, - PartGenerator::COMMENT_AVERAGE_LENGTH as f64, + VehicleGenerator::COMMENT_AVERAGE_LENGTH as f64, ); // Advance all generators to the starting position @@ -529,7 +517,7 @@ impl<'a> PartGeneratorIterator<'a> { container_random.advance_rows(start_index); comment_random.advance_rows(start_index); - PartGeneratorIterator { + VehicleGeneratorIterator { name_random, manufacturer_random, brand_random, @@ -543,47 +531,41 @@ impl<'a> PartGeneratorIterator<'a> { } } - /// Creates a part with the given key - fn make_part(&mut self, part_key: i64) -> Part<'a> { - let name = self.name_random.next_value(); - + /// Creates a vehicle with the given key + fn make_vehicle(&mut self, vehicle_key: i64) -> Vehicle<'a> { let manufacturer = self.manufacturer_random.next_value(); let brand = manufacturer * 10 + self.brand_random.next_value(); - Part { - p_partkey: part_key, - p_name: name, - p_mfgr: PartManufacturerName::new(manufacturer), - p_brand: PartBrandName::new(brand), - p_type: self.type_random.next_value(), - p_size: self.size_random.next_value(), - p_container: self.container_random.next_value(), - p_retailprice: TPCHDecimal(Self::calculate_part_price(part_key)), - p_comment: self.comment_random.next_value(), + Vehicle { + v_vehiclekey: vehicle_key, + v_mfgr: VehicleManufacturerName::new(manufacturer), + v_brand: VehicleBrandName::new(brand), + v_type: self.type_random.next_value(), + v_license: self.comment_random.next_value(), } } - /// Calculates the price for a part - pub fn calculate_part_price(part_key: i64) -> i64 { + /// Calculates the price for a vehicle + pub fn calculate_vehicle_price(vehicle_key: i64) -> i64 { let mut price = 90000; // limit contribution to $200 - price += (part_key / 10) % 20001; - price += (part_key % 1000) * 100; + price += (vehicle_key / 10) % 20001; + price += (vehicle_key % 1000) * 100; price } } -impl<'a> Iterator for PartGeneratorIterator<'a> { - type Item = Part<'a>; +impl<'a> Iterator for VehicleGeneratorIterator<'a> { + type Item = Vehicle<'a>; fn next(&mut self) -> Option<Self::Item> { if self.index >= self.row_count { return None; } - let part = self.make_part(self.start_index + self.index + 1); + let vehicle = self.make_vehicle(self.start_index + self.index + 1); self.name_random.row_finished(); self.manufacturer_random.row_finished(); @@ -595,7 +577,7 @@ impl<'a> Iterator for PartGeneratorIterator<'a> { self.index += 1; - Some(part) + Some(vehicle) } } @@ -660,8 +642,8 @@ impl fmt::Display for Driver { #[derive(Debug, Clone)] pub struct DriverGenerator<'a> { scale_factor: f64, - part: i32, - part_count: i32, + vehicle: i32, + vehicle_count: i32, distributions: &'a Distributions, text_pool: &'a TextPool, } @@ -689,12 +671,12 @@ impl<'a> DriverGenerator<'a> { /// /// Note the generator's lifetime is `&'static`. See [`NationGenerator`] for /// more details. - pub fn new(scale_factor: f64, part: i32, part_count: i32) -> DriverGenerator<'static> { + pub fn new(scale_factor: f64, vehicle: i32, vehicle_count: i32) -> DriverGenerator<'static> { // Note: use explicit lifetime to ensure this remains `&'static` Self::new_with_distributions_and_text_pool( scale_factor, - part, - part_count, + vehicle, + vehicle_count, Distributions::static_default(), TextPool::get_or_init_default(), ) @@ -703,23 +685,23 @@ impl<'a> DriverGenerator<'a> { /// Creates a DriverGenerator with specified distributions and text pool pub fn new_with_distributions_and_text_pool<'b>( scale_factor: f64, - part: i32, - part_count: i32, + vehicle: i32, + vehicle_count: i32, distributions: &'b Distributions, text_pool: &'b TextPool, ) -> DriverGenerator<'b> { DriverGenerator { scale_factor, - part, - part_count, + vehicle, + vehicle_count, distributions, text_pool, } } - /// Return the row count for the given scale factor and generator part count - pub fn calculate_row_count(scale_factor: f64, part: i32, part_count: i32) -> i64 { - GenerateUtils::calculate_row_count(Self::SCALE_BASE, scale_factor, part, part_count) + /// Return the row count for the given scale factor and generator vehicle count + pub fn calculate_row_count(scale_factor: f64, vehicle: i32, vehicle_count: i32) -> i64 { + GenerateUtils::calculate_row_count(Self::SCALE_BASE, scale_factor, vehicle, vehicle_count) } /// Returns an iterator over the Driver rows @@ -730,10 +712,10 @@ impl<'a> DriverGenerator<'a> { GenerateUtils::calculate_start_index( Self::SCALE_BASE, self.scale_factor, - self.part, - self.part_count, + self.vehicle, + self.vehicle_count, ), - Self::calculate_row_count(self.scale_factor, self.part, self.part_count), + Self::calculate_row_count(self.scale_factor, self.vehicle, self.vehicle_count), ) } } @@ -844,6 +826,17 @@ impl<'a> DriverGeneratorIterator<'a> { d_phone: self.phone_random.next_value(nation_key as i64), } } + + /// Selects a driver for a vehicle, with drivers table 5x the size of vehicles table + pub fn select_driver(vehicle_key: i64, scale_factor: f64) -> i64 { + // Calculate driver count as 5 times the vehicle count + let driver_count = 5 * (VehicleGenerator::SCALE_BASE as f64 * scale_factor) as i64; + + // Map each vehicle to a specific driver + // Using the formula that ensures the driver key is within valid range + // and maintains a one-to-one relationship between vehicles and drivers + ((vehicle_key - 1) % driver_count) + 1 + } } impl Iterator for DriverGeneratorIterator<'_> { @@ -933,8 +926,8 @@ impl fmt::Display for Customer<'_> { #[derive(Debug, Clone)] pub struct CustomerGenerator<'a> { scale_factor: f64, - part: i32, - part_count: i32, + vehicle: i32, + vehicle_count: i32, distributions: &'a Distributions, text_pool: &'a TextPool, } @@ -953,12 +946,12 @@ impl<'a> CustomerGenerator<'a> { /// /// Note the generator's lifetime is `&'static`. See [`NationGenerator`] for /// more details. - pub fn new(scale_factor: f64, part: i32, part_count: i32) -> CustomerGenerator<'static> { + pub fn new(scale_factor: f64, vehicle: i32, vehicle_count: i32) -> CustomerGenerator<'static> { // Note: use explicit lifetime to ensure this remains `&'static` Self::new_with_distributions_and_text_pool( scale_factor, - part, - part_count, + vehicle, + vehicle_count, Distributions::static_default(), TextPool::get_or_init_default(), ) @@ -967,23 +960,23 @@ impl<'a> CustomerGenerator<'a> { /// Creates a CustomerGenerator with specified distributions and text pool pub fn new_with_distributions_and_text_pool<'b>( scale_factor: f64, - part: i32, - part_count: i32, + vehicle: i32, + vehicle_count: i32, distributions: &'b Distributions, text_pool: &'b TextPool, ) -> CustomerGenerator<'b> { CustomerGenerator { scale_factor, - part, - part_count, + vehicle, + vehicle_count, distributions, text_pool, } } - /// Return the row count for the given scale factor and generator part count - pub fn calculate_row_count(scale_factor: f64, part: i32, part_count: i32) -> i64 { - GenerateUtils::calculate_row_count(Self::SCALE_BASE, scale_factor, part, part_count) + /// Return the row count for the given scale factor and generator vehicle count + pub fn calculate_row_count(scale_factor: f64, vehicle: i32, vehicle_count: i32) -> i64 { + GenerateUtils::calculate_row_count(Self::SCALE_BASE, scale_factor, vehicle, vehicle_count) } /// Returns an iterator over the customer rows @@ -994,10 +987,10 @@ impl<'a> CustomerGenerator<'a> { GenerateUtils::calculate_start_index( Self::SCALE_BASE, self.scale_factor, - self.part, - self.part_count, + self.vehicle, + self.vehicle_count, ), - Self::calculate_row_count(self.scale_factor, self.part, self.part_count), + Self::calculate_row_count(self.scale_factor, self.vehicle, self.vehicle_count), ) } } @@ -1105,240 +1098,6 @@ impl<'a> Iterator for CustomerGeneratorIterator<'a> { } } -/// The PARTSUPP (part Driver) table -/// -/// The Display trait is implemented to format the line item data as a string -/// in the default TPC-H 'tbl' format. -/// -/// ```text -/// 1|2|3325|771.64|, even theodolites. regular, final theodolites eat after the carefully pending foxes. ... -/// 1|4|8076|993.49|ven ideas. quickly even packages print. pending multipliers must have to are fluff| -/// ``` -#[derive(Debug, Clone, PartialEq)] -pub struct PartSupp<'a> { - /// Primary key, foreign key to PART - pub ps_partkey: i64, - /// Primary key, foreign key to Driver - pub ps_suppkey: i64, - /// Available quantity - pub ps_availqty: i32, - /// Driver cost - pub ps_supplycost: TPCHDecimal, - /// Variable length comment - pub ps_comment: &'a str, -} - -impl fmt::Display for PartSupp<'_> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!( - f, - "{}|{}|{}|{}|{}|", - self.ps_partkey, self.ps_suppkey, self.ps_availqty, self.ps_supplycost, self.ps_comment - ) - } -} - -/// Generator for PartSupp table data -#[derive(Debug, Clone)] -pub struct PartSuppGenerator<'a> { - scale_factor: f64, - part: i32, - part_count: i32, - text_pool: &'a TextPool, -} - -impl<'a> PartSuppGenerator<'a> { - /// Base scale for part-Driver generation - const DriverS_PER_PART: i32 = 4; - - // Constants for part-Driver generation - const AVAILABLE_QUANTITY_MIN: i32 = 1; - const AVAILABLE_QUANTITY_MAX: i32 = 9999; - const SUPPLY_COST_MIN: i32 = 100; - const SUPPLY_COST_MAX: i32 = 100000; - const COMMENT_AVERAGE_LENGTH: i32 = 124; - - /// Creates a new PartSuppGenerator with the given scale factor - /// - /// Note the generator's lifetime is `&'static`. See [`NationGenerator`] for - /// more details. - pub fn new(scale_factor: f64, part: i32, part_count: i32) -> PartSuppGenerator<'static> { - // Note: use explicit lifetime to ensure this remains `&'static` - Self::new_with_text_pool( - scale_factor, - part, - part_count, - TextPool::get_or_init_default(), - ) - } - - /// Creates a PartSuppGenerator with specified text pool - pub fn new_with_text_pool( - scale_factor: f64, - part: i32, - part_count: i32, - text_pool: &TextPool, - ) -> PartSuppGenerator<'_> { - PartSuppGenerator { - scale_factor, - part, - part_count, - text_pool, - } - } - - /// Return the row count for the given scale factor and generator part count - pub fn calculate_row_count(scale_factor: f64, part: i32, part_count: i32) -> i64 { - // Use the part generator's scale base for start/row calculation - GenerateUtils::calculate_row_count( - PartGenerator::SCALE_BASE, - scale_factor, - part, - part_count, - ) - } - - /// Returns an iterator over the part Driver rows - pub fn iter(&self) -> PartSuppGeneratorIterator<'a> { - let scale_base = PartGenerator::SCALE_BASE; - - PartSuppGeneratorIterator::new( - self.text_pool, - self.scale_factor, - GenerateUtils::calculate_start_index( - scale_base, - self.scale_factor, - self.part, - self.part_count, - ), - Self::calculate_row_count(self.scale_factor, self.part, self.part_count), - ) - } -} - -impl<'a> IntoIterator for &'a PartSuppGenerator<'a> { - type Item = PartSupp<'a>; - type IntoIter = PartSuppGeneratorIterator<'a>; - - fn into_iter(self) -> Self::IntoIter { - self.iter() - } -} - -/// Iterator that generates PartSupp rows -#[derive(Debug)] -pub struct PartSuppGeneratorIterator<'a> { - scale_factor: f64, - start_index: i64, - row_count: i64, - - available_quantity_random: RandomBoundedInt, - supply_cost_random: RandomBoundedInt, - comment_random: RandomText<'a>, - - index: i64, - part_Driver_number: i32, -} - -impl<'a> PartSuppGeneratorIterator<'a> { - fn new(text_pool: &'a TextPool, scale_factor: f64, start_index: i64, row_count: i64) -> Self { - let mut available_quantity_random = RandomBoundedInt::new_with_seeds_per_row( - 1671059989, - PartSuppGenerator::AVAILABLE_QUANTITY_MIN, - PartSuppGenerator::AVAILABLE_QUANTITY_MAX, - PartSuppGenerator::DriverS_PER_PART, - ); - let mut supply_cost_random = RandomBoundedInt::new_with_seeds_per_row( - 1051288424, - PartSuppGenerator::SUPPLY_COST_MIN, - PartSuppGenerator::SUPPLY_COST_MAX, - PartSuppGenerator::DriverS_PER_PART, - ); - let mut comment_random = RandomText::new_with_expected_row_count( - 1961692154, - text_pool, - PartSuppGenerator::COMMENT_AVERAGE_LENGTH as f64, - PartSuppGenerator::DriverS_PER_PART, - ); - - // Advance all generators to the starting position - available_quantity_random.advance_rows(start_index); - supply_cost_random.advance_rows(start_index); - comment_random.advance_rows(start_index); - - PartSuppGeneratorIterator { - scale_factor, - start_index, - row_count, - available_quantity_random, - supply_cost_random, - comment_random, - index: 0, - part_Driver_number: 0, - } - } - - /// Creates a part-Driver entry with the given part key - fn make_part_Driver(&mut self, part_key: i64) -> PartSupp<'a> { - let Driver_key = Self::select_part_Driver( - part_key, - self.part_Driver_number as i64, - self.scale_factor, - ); - - let ps_availqty = self.available_quantity_random.next_value(); - let ps_supplycost = TPCHDecimal(self.supply_cost_random.next_value() as i64); - let ps_comment = self.comment_random.next_value(); - - PartSupp { - ps_partkey: part_key, - ps_suppkey: Driver_key, - ps_availqty, - ps_supplycost, - ps_comment, - } - } - - /// Selects a Driver for a given part and Driver number - pub fn select_part_Driver(part_key: i64, Driver_number: i64, scale_factor: f64) -> i64 { - // Use Driver generator's scale base - let Driver_count = (DriverGenerator::SCALE_BASE as f64 * scale_factor) as i64; - - ((part_key - + (Driver_number - * ((Driver_count / PartSuppGenerator::DriverS_PER_PART as i64) - + ((part_key - 1) / Driver_count)))) - % Driver_count) - + 1 - } -} - -impl<'a> Iterator for PartSuppGeneratorIterator<'a> { - type Item = PartSupp<'a>; - - fn next(&mut self) -> Option<Self::Item> { - if self.index >= self.row_count { - return None; - } - - let part_key = self.start_index + self.index + 1; - let part_Driver = self.make_part_Driver(part_key); - self.part_Driver_number += 1; - - // advance next row only when all Drivers for the part have been produced - if self.part_Driver_number >= PartSuppGenerator::DriverS_PER_PART { - self.available_quantity_random.row_finished(); - self.supply_cost_random.row_finished(); - self.comment_random.row_finished(); - - self.index += 1; - self.part_Driver_number = 0; - } - - Some(part_Driver) - } -} - /// A clerk name, formatted as `"Clerk#<n>"` #[derive(Debug, Clone, Copy, PartialEq)] pub struct ClerkName(i32); @@ -1436,8 +1195,8 @@ impl fmt::Display for Order<'_> { #[derive(Debug, Clone)] pub struct OrderGenerator<'a> { scale_factor: f64, - part: i32, - part_count: i32, + vehicle: i32, + vehicle_count: i32, distributions: &'a Distributions, text_pool: &'a TextPool, } @@ -1464,12 +1223,12 @@ impl<'a> OrderGenerator<'a> { /// /// Note the generator's lifetime is `&'static`. See [`NationGenerator`] for /// more details. - pub fn new(scale_factor: f64, part: i32, part_count: i32) -> OrderGenerator<'static> { + pub fn new(scale_factor: f64, vehicle: i32, vehicle_count: i32) -> OrderGenerator<'static> { // Note: use explicit lifetime to ensure this remains `&'static` Self::new_with_distributions_and_text_pool( scale_factor, - part, - part_count, + vehicle, + vehicle_count, Distributions::static_default(), TextPool::get_or_init_default(), ) @@ -1478,23 +1237,23 @@ impl<'a> OrderGenerator<'a> { /// Creates a OrderGenerator with specified distributions and text pool pub fn new_with_distributions_and_text_pool<'b>( scale_factor: f64, - part: i32, - part_count: i32, + vehicle: i32, + vehicle_count: i32, distributions: &'b Distributions, text_pool: &'b TextPool, ) -> OrderGenerator<'b> { OrderGenerator { scale_factor, - part, - part_count, + vehicle, + vehicle_count, distributions, text_pool, } } - /// Return the row count for the given scale factor and generator part count - pub fn calculate_row_count(scale_factor: f64, part: i32, part_count: i32) -> i64 { - GenerateUtils::calculate_row_count(Self::SCALE_BASE, scale_factor, part, part_count) + /// Return the row count for the given scale factor and generator vehicle count + pub fn calculate_row_count(scale_factor: f64, vehicle: i32, vehicle_count: i32) -> i64 { + GenerateUtils::calculate_row_count(Self::SCALE_BASE, scale_factor, vehicle, vehicle_count) } /// Returns an iterator over the order rows @@ -1506,10 +1265,10 @@ impl<'a> OrderGenerator<'a> { GenerateUtils::calculate_start_index( Self::SCALE_BASE, self.scale_factor, - self.part, - self.part_count, + self.vehicle, + self.vehicle_count, ), - Self::calculate_row_count(self.scale_factor, self.part, self.part_count), + Self::calculate_row_count(self.scale_factor, self.vehicle, self.vehicle_count), ) } @@ -1560,7 +1319,7 @@ pub struct OrderGeneratorIterator<'a> { line_quantity_random: RandomBoundedInt, line_discount_random: RandomBoundedInt, line_tax_random: RandomBoundedInt, - line_part_key_random: RandomBoundedLong, + line_vehicle_key_random: RandomBoundedLong, line_ship_date_random: RandomBoundedInt, start_index: i64, @@ -1602,7 +1361,7 @@ impl<'a> OrderGeneratorIterator<'a> { let mut line_quantity_random = LineItemGenerator::create_quantity_random(); let mut line_discount_random = LineItemGenerator::create_discount_random(); let mut line_tax_random = LineItemGenerator::create_tax_random(); - let mut line_part_key_random = LineItemGenerator::create_part_key_random(scale_factor); + let mut line_vehicle_key_random = LineItemGenerator::create_vehicle_key_random(scale_factor); let mut line_ship_date_random = LineItemGenerator::create_ship_date_random(); // Advance all generators to the starting position @@ -1616,7 +1375,7 @@ impl<'a> OrderGeneratorIterator<'a> { line_quantity_random.advance_rows(start_index); line_discount_random.advance_rows(start_index); line_tax_random.advance_rows(start_index); - line_part_key_random.advance_rows(start_index); + line_vehicle_key_random.advance_rows(start_index); line_ship_date_random.advance_rows(start_index); OrderGeneratorIterator { @@ -1629,7 +1388,7 @@ impl<'a> OrderGeneratorIterator<'a> { line_quantity_random, line_discount_random, line_tax_random, - line_part_key_random, + line_vehicle_key_random, line_ship_date_random, start_index, row_count, @@ -1662,10 +1421,10 @@ impl<'a> OrderGeneratorIterator<'a> { let discount = self.line_discount_random.next_value(); let tax = self.line_tax_random.next_value(); - let part_key = self.line_part_key_random.next_value(); + let vehicle_key = self.line_vehicle_key_random.next_value(); - let part_price = PartGeneratorIterator::calculate_part_price(part_key); - let extended_price = part_price * quantity as i64; + let vehicle_price = VehicleGeneratorIterator::calculate_vehicle_price(vehicle_key); + let extended_price = vehicle_price * quantity as i64; let discounted_price = extended_price * (100 - discount as i64); total_price += ((discounted_price / 100) * (100 + tax as i64)) / 100; @@ -1720,7 +1479,7 @@ impl<'a> Iterator for OrderGeneratorIterator<'a> { self.line_quantity_random.row_finished(); self.line_discount_random.row_finished(); self.line_tax_random.row_finished(); - self.line_part_key_random.row_finished(); + self.line_vehicle_key_random.row_finished(); self.line_ship_date_random.row_finished(); self.index += 1; @@ -1744,7 +1503,7 @@ pub struct LineItem<'a> { /// Foreign key to ORDERS pub l_orderkey: i64, /// Foreign key to PART - pub l_partkey: i64, + pub l_vehiclekey: i64, /// Foreign key to Driver pub l_suppkey: i64, /// Line item number within order @@ -1782,7 +1541,7 @@ impl fmt::Display for LineItem<'_> { f, "{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|", self.l_orderkey, - self.l_partkey, + self.l_vehiclekey, self.l_suppkey, self.l_linenumber, self.l_quantity, @@ -1805,8 +1564,8 @@ impl fmt::Display for LineItem<'_> { #[derive(Debug, Clone)] pub struct LineItemGenerator<'a> { scale_factor: f64, - part: i32, - part_count: i32, + vehicle: i32, + vehicle_count: i32, distributions: &'a Distributions, text_pool: &'a TextPool, } @@ -1836,11 +1595,11 @@ impl<'a> LineItemGenerator<'a> { /// /// Note the generator's lifetime is `&'static`. See [`NationGenerator`] for /// more details. - pub fn new(scale_factor: f64, part: i32, part_count: i32) -> LineItemGenerator<'static> { + pub fn new(scale_factor: f64, vehicle: i32, vehicle_count: i32) -> LineItemGenerator<'static> { Self::new_with_distributions_and_text_pool( scale_factor, - part, - part_count, + vehicle, + vehicle_count, Distributions::static_default(), TextPool::get_or_init_default(), ) @@ -1849,15 +1608,15 @@ impl<'a> LineItemGenerator<'a> { /// Creates a LineItemGenerator with specified distributions and text pool pub fn new_with_distributions_and_text_pool<'b>( scale_factor: f64, - part: i32, - part_count: i32, + vehicle: i32, + vehicle_count: i32, distributions: &'b Distributions, text_pool: &'b TextPool, ) -> LineItemGenerator<'b> { LineItemGenerator { scale_factor, - part, - part_count, + vehicle, + vehicle_count, distributions, text_pool, } @@ -1872,14 +1631,14 @@ impl<'a> LineItemGenerator<'a> { GenerateUtils::calculate_start_index( OrderGenerator::SCALE_BASE, self.scale_factor, - self.part, - self.part_count, + self.vehicle, + self.vehicle_count, ), GenerateUtils::calculate_row_count( OrderGenerator::SCALE_BASE, self.scale_factor, - self.part, - self.part_count, + self.vehicle, + self.vehicle_count, ), ) } @@ -1914,15 +1673,15 @@ impl<'a> LineItemGenerator<'a> { ) } - /// Creates a part key random generator - pub fn create_part_key_random(scale_factor: f64) -> RandomBoundedLong { + /// Creates a vehicle key random generator + pub fn create_vehicle_key_random(scale_factor: f64) -> RandomBoundedLong { // If scale_factor >= 30000, use long `RandomBoundedLong` otherwise // use `RandomBoundedInt` to avoid overflow. RandomBoundedLong::new_with_seeds_per_row( 1808217256, scale_factor >= 30000.0, Self::PART_KEY_MIN as i64, - (PartGenerator::SCALE_BASE as f64 * scale_factor) as i64, + (VehicleGenerator::SCALE_BASE as f64 * scale_factor) as i64, OrderGenerator::LINE_COUNT_MAX, ) } @@ -1957,9 +1716,9 @@ pub struct LineItemGeneratorIterator<'a> { discount_random: RandomBoundedInt, tax_random: RandomBoundedInt, - line_part_key_random: RandomBoundedLong, + line_vehicle_key_random: RandomBoundedLong, - Driver_number_random: RandomBoundedInt, + driver_number_random: RandomBoundedInt, ship_date_random: RandomBoundedInt, commit_date_random: RandomBoundedInt, @@ -1996,9 +1755,9 @@ impl<'a> LineItemGeneratorIterator<'a> { let mut discount_random = LineItemGenerator::create_discount_random(); let mut tax_random = LineItemGenerator::create_tax_random(); - let mut line_part_key_random = LineItemGenerator::create_part_key_random(scale_factor); + let mut line_vehicle_key_random = LineItemGenerator::create_vehicle_key_random(scale_factor); - let mut Driver_number_random = RandomBoundedInt::new_with_seeds_per_row( + let mut driver_number_random = RandomBoundedInt::new_with_seeds_per_row( 2095021727, 0, 3, @@ -2049,9 +1808,9 @@ impl<'a> LineItemGeneratorIterator<'a> { discount_random.advance_rows(start_index); tax_random.advance_rows(start_index); - line_part_key_random.advance_rows(start_index); + line_vehicle_key_random.advance_rows(start_index); - Driver_number_random.advance_rows(start_index); + driver_number_random.advance_rows(start_index); ship_date_random.advance_rows(start_index); commit_date_random.advance_rows(start_index); @@ -2073,8 +1832,8 @@ impl<'a> LineItemGeneratorIterator<'a> { quantity_random, discount_random, tax_random, - line_part_key_random, - Driver_number_random, + line_vehicle_key_random, + driver_number_random, ship_date_random, commit_date_random, receipt_date_random, @@ -2100,17 +1859,16 @@ impl<'a> LineItemGeneratorIterator<'a> { let discount = self.discount_random.next_value(); let tax = self.tax_random.next_value(); - let part_key = self.line_part_key_random.next_value(); + let vehicle_key = self.line_vehicle_key_random.next_value(); - let Driver_number = self.Driver_number_random.next_value() as i64; - let Driver_key = PartSuppGeneratorIterator::select_part_Driver( - part_key, - Driver_number, + // let driver_number = self.driver_number_random.next_value() as i64; + let driver_key = DriverGeneratorIterator::select_driver( + vehicle_key, self.scale_factor, ); - let part_price = PartGeneratorIterator::calculate_part_price(part_key); - let extended_price = part_price * quantity as i64; + let vehicle_price = VehicleGeneratorIterator::calculate_vehicle_price(vehicle_key); + let extended_price = vehicle_price * quantity as i64; let mut ship_date = self.ship_date_random.next_value(); ship_date += self.order_date; @@ -2137,8 +1895,8 @@ impl<'a> LineItemGeneratorIterator<'a> { LineItem { l_orderkey: order_key, - l_partkey: part_key, - l_suppkey: Driver_key, + l_vehiclekey: vehicle_key, + l_suppkey: driver_key, l_linenumber: (self.line_number + 1), l_quantity: quantity as i64, l_extendedprice: TPCHDecimal(extended_price), @@ -2176,8 +1934,8 @@ impl<'a> Iterator for LineItemGeneratorIterator<'a> { self.discount_random.row_finished(); self.tax_random.row_finished(); - self.line_part_key_random.row_finished(); - self.Driver_number_random.row_finished(); + self.line_vehicle_key_random.row_finished(); + self.driver_number_random.row_finished(); self.ship_date_random.row_finished(); self.commit_date_random.row_finished(); @@ -2224,22 +1982,18 @@ mod tests { } #[test] - fn test_part_generation() { + fn test_vehicle_generation() { // Create a generator with a small scale factor - let generator = PartGenerator::new(0.01, 1, 1); - let parts: Vec<_> = generator.iter().collect(); + let generator = VehicleGenerator::new(0.01, 1, 1); + let vehicles: Vec<_> = generator.iter().collect(); - // Should have 0.01 * 200,000 = 2,000 parts - assert_eq!(parts.len(), 2000); - } + // Should have 0.01 * 200,000 = 2,000 vehicles + assert_eq!(vehicles.len(), 2000); - #[test] - fn test_calculate_part_price() { - // Test with a few part keys - assert_eq!(PartGeneratorIterator::calculate_part_price(1), 90100); - assert_eq!(PartGeneratorIterator::calculate_part_price(10), 91001); - assert_eq!(PartGeneratorIterator::calculate_part_price(100), 100010); - assert_eq!(PartGeneratorIterator::calculate_part_price(1000), 90100); + // Check first Driver + let first = &vehicles[0]; + assert_eq!(first.v_vehiclekey, 1); + assert_eq!(first.to_string(), "1|Manufacturer#1|Brand#13|PROMO BURNISHED COPPER|ly. slyly ironi|") } #[test] @@ -2288,76 +2042,6 @@ mod tests { assert_eq!(first.to_string(), expected_pattern); } - #[test] - fn test_part_Driver_generation() { - // Create a generator with a small scale factor - let generator = PartSuppGenerator::new(0.01, 1, 1); - let part_Drivers: Vec<_> = generator.iter().collect(); - - // Should have 0.01 * 200,000 * 4 = 8,000 part-Driver relationships - assert_eq!(part_Drivers.len(), 8000); - - // Each part should have DriverS_PER_PART Drivers - let part_keys: std::collections::HashSet<_> = - part_Drivers.iter().map(|ps| ps.ps_partkey).collect(); - - assert_eq!(part_keys.len(), 2000); // 8,000 / 4 = 2,000 parts - - // Check first part Driver - let first = &part_Drivers[0]; - assert_eq!(first.ps_partkey, 1); - assert_ne!(first.ps_suppkey, 0); // Should have a valid Driver key - assert!(first.ps_availqty > 0); - assert!(first.ps_supplycost > TPCHDecimal::ZERO); - assert!(!first.ps_comment.is_empty()); - - // Verify Driver distribution - let Drivers_for_first_part: Vec<_> = part_Drivers - .iter() - .filter(|ps| ps.ps_partkey == 1) - .map(|ps| ps.ps_suppkey) - .collect(); - - assert_eq!( - Drivers_for_first_part.len(), - PartSuppGenerator::DriverS_PER_PART as usize - ); - - // Driver keys should be unique for each part - let unique_Drivers: std::collections::HashSet<_> = - Drivers_for_first_part.iter().collect(); - assert_eq!( - unique_Drivers.len(), - PartSuppGenerator::DriverS_PER_PART as usize - ); - } - - #[test] - fn test_select_part_Driver() { - // Test the Driver selection logic for consistency - let scale_factor = 1.0; - - // Same part with different Driver numbers should yield different Drivers - let Driver1 = PartSuppGeneratorIterator::select_part_Driver(1, 0, scale_factor); - let Driver2 = PartSuppGeneratorIterator::select_part_Driver(1, 1, scale_factor); - let Driver3 = PartSuppGeneratorIterator::select_part_Driver(1, 2, scale_factor); - let Driver4 = PartSuppGeneratorIterator::select_part_Driver(1, 3, scale_factor); - - // All Drivers should be different - let Drivers = vec![Driver1, Driver2, Driver3, Driver4]; - let unique_Drivers: std::collections::HashSet<_> = Drivers.iter().collect(); - assert_eq!( - unique_Drivers.len(), - PartSuppGenerator::DriverS_PER_PART as usize - ); - - // All Driver keys should be within valid range (1 to Driver_count) - let Driver_count = (DriverGenerator::SCALE_BASE as f64 * scale_factor) as i64; - for Driver in Drivers { - assert!(Driver >= 1 && Driver <= Driver_count); - } - } - #[test] fn test_order_generation() { // Create a generator with a small scale factor @@ -2418,7 +2102,7 @@ mod tests { let first = &line_items[0]; assert_eq!(first.l_orderkey, OrderGenerator::make_order_key(1)); assert_eq!(first.l_linenumber, 1); - assert!(first.l_partkey > 0); + assert!(first.l_vehiclekey > 0); assert!(first.l_suppkey > 0); assert!(first.l_quantity >= LineItemGenerator::QUANTITY_MIN as i64); @@ -2469,10 +2153,9 @@ mod tests { let _iter: NationGeneratorIterator<'static> = NationGenerator::default().iter(); let _iter: RegionGeneratorIterator<'static> = RegionGenerator::default().iter(); - let _iter: PartGeneratorIterator<'static> = PartGenerator::new(0.1, 1, 1).iter(); + let _iter: VehicleGeneratorIterator<'static> = VehicleGenerator::new(0.1, 1, 1).iter(); let _iter: DriverGeneratorIterator<'static> = DriverGenerator::new(0.1, 1, 1).iter(); let _iter: CustomerGeneratorIterator<'static> = CustomerGenerator::new(0.1, 1, 1).iter(); - let _iter: PartSuppGeneratorIterator<'static> = PartSuppGenerator::new(0.1, 1, 1).iter(); let _iter: OrderGeneratorIterator<'static> = OrderGenerator::new(0.1, 1, 1).iter(); let _iter: LineItemGeneratorIterator<'static> = LineItemGenerator::new(0.1, 1, 1).iter(); } diff --git a/tpchgen/tests/integration_tests.rs b/tpchgen/tests/integration_tests.rs index 83e8c11..ac53a1d 100644 --- a/tpchgen/tests/integration_tests.rs +++ b/tpchgen/tests/integration_tests.rs @@ -5,8 +5,7 @@ use std::fs::File; use std::io::{BufRead, BufReader}; use std::path::{Path, PathBuf}; use tpchgen::generators::{ - CustomerGenerator, LineItemGenerator, NationGenerator, OrderGenerator, PartGenerator, - PartSuppGenerator, RegionGenerator, DriverGenerator, + CustomerGenerator, LineItemGenerator, NationGenerator, OrderGenerator, VehicleGenerator, RegionGenerator, DriverGenerator, }; fn read_tbl_gz<P: AsRef<Path>>(path: P) -> Vec<String> { @@ -74,7 +73,7 @@ fn test_region_sf_0_001() { #[test] fn test_part_sf_0_001() { let sf = 0.001; - let generator = PartGenerator::new(sf, 1, 1); + let generator = VehicleGenerator::new(sf, 1, 1); test_generator(generator.iter(), "data/sf-0.001/part.tbl.gz", |part| { part.to_string() }); @@ -91,15 +90,6 @@ fn test_supplier_sf_0_001() { ); } -#[test] -fn test_partsupp_sf_0_001() { - let sf = 0.001; - let generator = PartSuppGenerator::new(sf, 1, 1); - test_generator(generator.iter(), "data/sf-0.001/partsupp.tbl.gz", |ps| { - ps.to_string() - }); -} - #[test] fn test_customer_sf_0_001() { let sf = 0.001; @@ -150,7 +140,7 @@ fn test_region_sf_0_01() { #[test] fn test_part_sf_0_01() { let sf = 0.01; - let generator = PartGenerator::new(sf, 1, 1); + let generator = VehicleGenerator::new(sf, 1, 1); test_generator(generator.iter(), "data/sf-0.01/part.tbl.gz", |part| { part.to_string() }); @@ -167,15 +157,6 @@ fn test_supplier_sf_0_01() { ); } -#[test] -fn test_partsupp_sf_0_01() { - let sf = 0.01; - let generator = PartSuppGenerator::new(sf, 1, 1); - test_generator(generator.iter(), "data/sf-0.01/partsupp.tbl.gz", |ps| { - ps.to_string() - }); -} - #[test] fn test_customer_sf_0_01() { let sf = 0.01;
