Add another tpc_c transaction implementation

Author: LHolten

tests/tpc_c/main.rs

@@ -6,6 +6,7 @@ use rust_query::{
 };
 
 mod new_order;
+mod order_status;
 mod payment;
 
 #[schema(Schema)]
@@ -71,6 +72,7 @@ pub mod vN {
     }
     pub struct Order {
         pub customer: Customer,
+        pub number: i64,
         pub entry_d: i64,
         pub carrier_id: Option<i64>,
         pub order_line_cnt: i64,
@@ -81,7 +83,7 @@ pub mod vN {
         pub order: Order,
         pub number: i64,
         pub stock: Stock,
-        pub derlivery_d: Option<i64>,
+        pub delivery_d: Option<i64>,
         pub quantity: i64,
         pub amount: i64, // total cost of this line
         pub dist_info: String,
@@ -142,3 +144,50 @@ pub fn random_to_last_name(num: i64) -> String {
     }
     out
 }
+
+enum CustomerIdent<'a> {
+    Number(TableRow<'a, Customer>),
+    Name(TableRow<'a, District>, String),
+}
+
+impl<'a> CustomerIdent<'a> {
+    pub fn lookup_customer(self, txn: &Transaction<'a, Schema>) -> TableRow<'a, Customer> {
+        match self {
+            CustomerIdent::Number(customer) => customer,
+            CustomerIdent::Name(district, last_name) => {
+                let mut customers = txn.query(|rows| {
+                    let customer = Customer::join(rows);
+                    rows.filter(customer.district().eq(district));
+                    rows.filter(customer.last().eq(last_name));
+                    rows.into_vec((customer.first(), customer))
+                });
+                customers.sort_by(|a, b| a.0.cmp(&b.0));
+
+                let count = customers.len();
+                let id = count.div_ceil(2) - 1;
+                customers.swap_remove(id).1
+            }
+        }
+    }
+}
+
+fn customer_ident<'a>(
+    txn: &Transaction<'a, Schema>,
+    rng: &mut ThreadRng,
+    customer_district: TableRow<'a, District>,
+) -> CustomerIdent<'a> {
+    if rng.random_ratio(60, 100) {
+        CustomerIdent::Name(
+            customer_district,
+            random_to_last_name(rng.nurand(255, 0, 999)),
+        )
+    } else {
+        let customer = txn
+            .query_one(Customer::unique(
+                customer_district,
+                rng.nurand(1023, 1, 3000),
+            ))
+            .unwrap();
+        CustomerIdent::Number(customer)
+    }
+}

tests/tpc_c/new_order.rs

@@ -57,7 +57,7 @@ pub fn new_order<'a>(
 ) -> OutputData<'a> {
     let district = txn.query_one(input.customer.district());
 
-    let district_info: District!(warehouse<'_>, number, tax) =
+    let district_info: District!(warehouse<'_>, number, tax, next_order) =
         txn.query_one(FromExpr::from_expr(district));
 
     let warehouse_tax = txn.query_one(district.warehouse().tax());
@@ -79,6 +79,7 @@ pub fn new_order<'a>(
         .all(|item| item.supplying_warehouse == district_info.warehouse);
 
     let order = txn.insert_ok(Order {
+        number: district_info.next_order,
         customer: input.customer,
         entry_d: input.entry_date,
         carrier_id: None::<i64>,
@@ -167,7 +168,7 @@ pub fn new_order<'a>(
             order,
             number: number as i64,
             stock,
-            derlivery_d: None::<i64>,
+            delivery_d: None::<i64>,
             quantity,
             amount,
             dist_info: stock_info.dist_xx,

tests/tpc_c/order_status.rs

@@ -0,0 +1,57 @@
+use super::*;
+use rust_query::{FromExpr, TableRow, Transaction, aggregate};
+
+pub fn generate_order_status<'a>(
+    txn: &Transaction<'a, Schema>,
+    warehouse: TableRow<'a, Warehouse>,
+) -> CustomerIdent<'a> {
+    let mut rng = rand::rng();
+    let district = txn
+        .query_one(District::unique(warehouse, rng.random_range(1..=10)))
+        .unwrap();
+
+    customer_ident(txn, &mut rng, district)
+}
+
+pub fn order_status<'a>(
+    txn: &Transaction<'a, Schema>,
+    input: CustomerIdent<'a>,
+) -> OrderStatus<'a> {
+    let customer = input.lookup_customer(txn);
+    let last_order = txn.query(|rows| {
+        let order = Order::join(rows);
+        rows.filter(order.customer().eq(customer));
+        let max_number = rows.filter_some(aggregate(|rows| {
+            let order = Order::join(rows);
+            rows.filter_on(order.customer(), customer);
+            rows.max(order.number())
+        }));
+        rows.filter(order.number().eq(max_number));
+        rows.into_vec(order).swap_remove(0)
+    });
+
+    let order_lines_info = txn.query(|rows| {
+        let order_line = OrderLine::join(rows);
+        rows.filter(order_line.order().eq(last_order));
+        rows.into_vec(FromExpr::from_expr(order_line))
+    });
+
+    OrderStatus {
+        customer_info: txn.query_one(FromExpr::from_expr(customer)),
+        order_info: txn.query_one(FromExpr::from_expr(last_order)),
+        order_lines_info,
+    }
+}
+
+struct OrderStatus<'a> {
+    customer_info: Customer!(balance, first, middle, last),
+    order_info: Order!(number, entry_d, carrier_id),
+    order_lines_info: Vec<OrderLineInfo<'a>>,
+}
+
+type OrderLineInfo<'a> = OrderLine!(
+    stock as Stock!(item<'a>, warehouse<'a>),
+    quantity,
+    amount,
+    delivery_d
+);

tests/tpc_c/payment.rs

@@ -19,20 +19,7 @@ pub fn generate_payment<'a>(
             .unwrap()
     };
 
-    let customer = if rng.random_ratio(60, 100) {
-        CustomerIdent::Name(
-            customer_district,
-            random_to_last_name(rng.nurand(255, 0, 999)),
-        )
-    } else {
-        let customer = txn
-            .query_one(Customer::unique(
-                customer_district,
-                rng.nurand(1023, 1, 3000),
-            ))
-            .unwrap();
-        CustomerIdent::Number(customer)
-    };
+    let customer = customer_ident(txn, &mut rng, customer_district);
 
     PaymentInput {
         district,
@@ -42,11 +29,6 @@ pub fn generate_payment<'a>(
     }
 }
 
-enum CustomerIdent<'a> {
-    Number(TableRow<'a, Customer>),
-    Name(TableRow<'a, District>, String),
-}
-
 struct PaymentInput<'a> {
     district: TableRow<'a, District>,
     customer: CustomerIdent<'a>,
@@ -108,22 +90,8 @@ fn payment<'a>(mut txn: TransactionMut<'a, Schema>, input: PaymentInput<'a>) ->
         },
     );
 
-    let (customer, customer_info) = match input.customer {
-        CustomerIdent::Number(row) => (row, txn.query_one(CustomerInfo::from_expr(row))),
-        CustomerIdent::Name(customer_district, name) => {
-            let mut customers = txn.query(|rows| {
-                let customer = Customer::join(rows);
-                rows.filter(customer.district().eq(customer_district));
-                rows.filter(customer.last().eq(name));
-                rows.into_vec((&customer, CustomerInfo::from_expr(&customer)))
-            });
-            customers.sort_by(|a, b| a.1.first.cmp(&b.1.first));
-
-            let count = customers.len();
-            let id = count.div_ceil(2) - 1;
-            customers.swap_remove(id)
-        }
-    };
+    let customer = input.customer.lookup_customer(&txn);
+    let customer_info: CustomerInfo = txn.query_one(FromExpr::from_expr(customer));
 
     txn.update_ok(
         customer,