public VoltTable[] run(short w_id, byte d_id, byte[] c_last) { voltQueueSQL(getCustomersByLastName, w_id, d_id, c_last); VoltTable customers = voltExecuteSQL()[0]; // Get the midpoint customer's id final int namecnt = customers.getRowCount(); final int index = (namecnt - 1) / 2; final VoltTableRow customer = customers.fetchRow(index); final long c_id = customer.getLong(C_ID_IDX); // Build an VoltTable with a single customer row final VoltTable customerResultTable = result_template.clone(1024); customerResultTable.addRow( c_id, customer.getStringAsBytes(1), customer.getStringAsBytes(2), customer.getStringAsBytes(3), customer.getDouble(4)); // Do the rest of the work return getOrderStatus(w_id, d_id, c_id, customerResultTable); }
public VoltTable[] run(long zip) throws VoltAbortException { Date timestamp = new Date(); // create a District, Warehouse, and 4 Customers (multiple, since we // want to test for correct behavior of paymentByCustomerName. final double initialYTD = 15241.45; voltQueueSQL( insertDistrict, 7L, 3L, "A District", "Street Addy", "meh", "westerfield", "BA", "99999", .0825, initialYTD, 21L); // check that a district was inserted long resultsl = voltExecuteSQL()[0].asScalarLong(); assert (resultsl == 1); voltQueueSQL( insertWarehouse, 3L, "EZ Street WHouse", "Headquarters", "77 Mass. Ave.", "Cambridge", "AZ", "12938", .1234, initialYTD); // check that a warehouse was inserted resultsl = voltExecuteSQL()[0].asScalarLong(); assert (resultsl == 1); final double initialBalance = 15.75; voltQueueSQL( insertCustomer, C_ID, D_ID, W_ID, "I", "Be", "lastname", "Place", "Place2", "BiggerPlace", "AL", "91083", "(193) 099 - 9082", new Date(), "BC", 19298943.12, .13, initialBalance, initialYTD, 0L, 15L, "Some History"); // check that a customer was inserted resultsl = voltExecuteSQL()[0].asScalarLong(); assert (resultsl == 1); voltQueueSQL( insertCustomer, C_ID + 1, D_ID, W_ID, "We", "Represent", "Customer", "Random Department", "Place2", "BiggerPlace", "AL", "13908", "(913) 909 - 0928", new Date(), "GC", 19298943.12, .13, initialBalance, initialYTD, 1L, 15L, "Some History"); // check that a customer was inserted resultsl = voltExecuteSQL()[0].asScalarLong(); assert (resultsl == 1); voltQueueSQL( insertCustomer, C_ID + 2, D_ID, W_ID, "Who", "Is", "Customer", "Receiving", "450 Mass F.X.", "BiggerPlace", "CI", "91083", "(541) 931 - 0928", new Date(), "GC", 19899324.21, .13, initialBalance, initialYTD, 2L, 15L, "Some History"); // check that a customer was inserted resultsl = voltExecuteSQL()[0].asScalarLong(); assert (resultsl == 1); voltQueueSQL( insertCustomer, C_ID + 3, D_ID, W_ID, "ICanBe", "", "Customer", "street", "place", "BiggerPlace", "MA", "91083", "(913) 909 - 0928", new Date(), "GC", 19298943.12, .13, initialBalance, initialYTD, 3L, 15L, "Some History"); // check that a customer was inserted resultsl = voltExecuteSQL()[0].asScalarLong(); assert (resultsl == 1); // long d_id, long w_id, double h_amount, String c_last, long c_w_id, // long c_d_id final double paymentAmount = 500.25; // VoltTable[] results = client.callProcedure("paymentByCustomerName", W_ID, // D_ID, paymentAmount, W_ID, D_ID, "Customer", new Date()); // assertEquals(3, results.length); // being proc voltQueueSQL(getCustomersByLastName, "Customer", D_ID, W_ID); final VoltTable customers = voltExecuteSQL()[0]; final int namecnt = customers.getRowCount(); if (namecnt == 0) { throw new VoltAbortException( "no customers with last name: " + "Customer" + " in warehouse: " + W_ID + " and in district " + D_ID); } try { System.out.println("PAYMENT FOUND CUSTOMERS: " + customers.toString()); } catch (Exception e) { e.printStackTrace(); } final int index = (namecnt - 1) / 2; final VoltTableRow customer = customers.fetchRow(index); final long c_id = customer.getLong(C_ID_IDX); voltQueueSQL(getWarehouse, W_ID); voltQueueSQL(getDistrict, W_ID, D_ID); final VoltTable[] results = voltExecuteSQL(); final VoltTable warehouse = results[0]; final VoltTable district = results[1]; try { System.out.println("WAREHOUSE PRE: " + warehouse.toString()); } catch (Exception e) { e.printStackTrace(); } voltQueueSQL(getWarehouses); VoltTable warehouses = voltExecuteSQL()[0]; try { System.out.println("WAREHOUSE PRE: " + warehouses.toString()); } catch (Exception e) { e.printStackTrace(); } voltQueueSQL(updateWarehouseBalance, paymentAmount, W_ID); voltQueueSQL(updateDistrictBalance, paymentAmount, W_ID, D_ID); voltExecuteSQL(); voltQueueSQL(getWarehouses); warehouses = voltExecuteSQL()[0]; try { System.out.println("WAREHOUSE PRE: " + warehouses.toString()); } catch (Exception e) { e.printStackTrace(); } // do stuff to extract district and warehouse info. // customer info final byte[] c_first = customer.getStringAsBytes(C_FIRST_IDX); final byte[] c_middle = customer.getStringAsBytes(C_MIDDLE_IDX); final byte[] c_last = customer.getStringAsBytes(C_LAST_IDX); final byte[] c_street_1 = customer.getStringAsBytes(C_STREET_1_IDX); final byte[] c_street_2 = customer.getStringAsBytes(C_STREET_2_IDX); final byte[] c_city = customer.getStringAsBytes(C_CITY_IDX); final byte[] c_state = customer.getStringAsBytes(C_STATE_IDX); final byte[] c_zip = customer.getStringAsBytes(C_ZIP_IDX); final byte[] c_phone = customer.getStringAsBytes(C_PHONE_IDX); final TimestampType c_since = customer.getTimestampAsTimestamp(C_SINCE_IDX); final byte[] c_credit = customer.getStringAsBytes(C_CREDIT_IDX); final double c_credit_lim = customer.getDouble(C_CREDIT_LIM_IDX); final double c_discount = customer.getDouble(C_DISCOUNT_IDX); final double c_balance = customer.getDouble(C_BALANCE_IDX) - paymentAmount; final double c_ytd_payment = customer.getDouble(C_YTD_PAYMENT_IDX) + paymentAmount; final long c_payment_cnt = customer.getLong(C_PAYMENT_CNT_IDX) + 1; byte[] c_data; if (Arrays.equals(c_credit, Constants.BAD_CREDIT_BYTES)) { c_data = customer.getStringAsBytes(C_DATA_IDX); byte[] newData = (c_id + " " + D_ID + " " + W_ID + " " + D_ID + " " + W_ID + " " + paymentAmount + "|") .getBytes(); int newLength = newData.length + c_data.length; if (newLength > Constants.MAX_C_DATA) { newLength = Constants.MAX_C_DATA; } ByteBuilder builder = new ByteBuilder(newLength); int minLength = newLength; if (newData.length < minLength) minLength = newData.length; builder.append(newData, 0, minLength); int remaining = newLength - minLength; builder.append(c_data, 0, remaining); c_data = builder.array(); voltQueueSQL( updateBCCustomer, c_balance, c_ytd_payment, c_payment_cnt, c_data, W_ID, D_ID, c_id); } else { c_data = new byte[0]; voltQueueSQL(updateGCCustomer, c_balance, c_ytd_payment, c_payment_cnt, W_ID, D_ID, c_id); } // Concatenate w_name, four spaces, d_name byte[] w_name = warehouse.fetchRow(0).getStringAsBytes(W_NAME_IDX); final byte[] FOUR_SPACES = {' ', ' ', ' ', ' '}; byte[] d_name = district.fetchRow(0).getStringAsBytes(D_NAME_IDX); ByteBuilder builder = new ByteBuilder(w_name.length + FOUR_SPACES.length + d_name.length); builder.append(w_name); builder.append(FOUR_SPACES); builder.append(d_name); byte[] h_data = builder.array(); // Create the history record voltQueueSQL(insertHistory, c_id, D_ID, W_ID, D_ID, W_ID, timestamp, paymentAmount, h_data); voltExecuteSQL(); // TPC-C 2.5.3.3: Must display the following fields: // W_ID, D_ID, C_ID, C_D_ID, C_W_ID, W_STREET_1, W_STREET_2, W_CITY, W_STATE, W_ZIP, // D_STREET_1, D_STREET_2, D_CITY, D_STATE, D_ZIP, C_FIRST, C_MIDDLE, C_LAST, C_STREET_1, // C_STREET_2, C_CITY, C_STATE, C_ZIP, C_PHONE, C_SINCE, C_CREDIT, C_CREDIT_LIM, // C_DISCOUNT, C_BALANCE, the first 200 characters of C_DATA (only if C_CREDIT = "BC"), // H_AMOUNT, and H_DATE. // Return the entire warehouse and district tuples. The client provided: // w_id, d_id, c_d_id, c_w_id, h_amount, h_data. // Build a table for the rest final VoltTable misc = misc_template.clone(8192); misc.addRow( c_id, c_first, c_middle, c_last, c_street_1, c_street_2, c_city, c_state, c_zip, c_phone, c_since, c_credit, c_credit_lim, c_discount, c_balance, c_data); // Hand back all the warehouse, district, and customer data VoltTable[] resultsX = new VoltTable[] {warehouse, district, misc}; // resume test code // check that the middle "Customer" was returned assert ((C_ID + 1) == (resultsX[2].fetchRow(0).getLong("c_id"))); assert ("".equals(resultsX[2].fetchRow(0).getString("c_data"))); // Verify that both warehouse, district and customer were updated // correctly // VoltTable[] allTables = client.callProcedure("SelectAll"); voltQueueSQL(getWarehouses); warehouses = voltExecuteSQL()[0]; try { System.out.println("WAREHOUSE POST: " + warehouses.toString()); } catch (Exception e) { e.printStackTrace(); } assert (1 == warehouses.getRowCount()); double amt1 = initialYTD + paymentAmount; double amt2 = warehouses.fetchRow(0).getDouble("W_YTD"); assert (amt1 == amt2); voltQueueSQL(getDistricts); VoltTable districts = voltExecuteSQL()[0]; assert (1 == districts.getRowCount()); assert ((initialYTD + paymentAmount) == districts.fetchRow(0).getDouble("D_YTD")); voltQueueSQL(getCustomers); VoltTable customersX = voltExecuteSQL()[0]; assert (4 == customersX.getRowCount()); assert ((C_ID + 1) == customersX.fetchRow(1).getLong("C_ID")); assert ((initialBalance - paymentAmount) == customersX.fetchRow(1).getDouble("C_BALANCE")); assert ((initialYTD + paymentAmount) == customersX.fetchRow(1).getDouble("C_YTD_PAYMENT")); assert (2 == customersX.fetchRow(1).getLong("C_PAYMENT_CNT")); return null; }
public VoltTable[] processPayment( short w_id, byte d_id, short c_w_id, byte c_d_id, int c_id, double h_amount, VoltTableRow customer, TimestampType timestamp) { // customer info final byte[] c_first = customer.getStringAsBytes(C_FIRST_IDX); final byte[] c_middle = customer.getStringAsBytes(C_MIDDLE_IDX); final byte[] c_last = customer.getStringAsBytes(C_LAST_IDX); final byte[] c_street_1 = customer.getStringAsBytes(C_STREET_1_IDX); final byte[] c_street_2 = customer.getStringAsBytes(C_STREET_2_IDX); final byte[] c_city = customer.getStringAsBytes(C_CITY_IDX); final byte[] c_state = customer.getStringAsBytes(C_STATE_IDX); final byte[] c_zip = customer.getStringAsBytes(C_ZIP_IDX); final byte[] c_phone = customer.getStringAsBytes(C_PHONE_IDX); final TimestampType c_since = customer.getTimestampAsTimestamp(C_SINCE_IDX); final byte[] c_credit = customer.getStringAsBytes(C_CREDIT_IDX); final double c_credit_lim = customer.getDouble(C_CREDIT_LIM_IDX); final double c_discount = customer.getDouble(C_DISCOUNT_IDX); final double c_balance = customer.getDouble(C_BALANCE_IDX) - h_amount; final double c_ytd_payment = customer.getDouble(C_YTD_PAYMENT_IDX) + h_amount; final int c_payment_cnt = (int) customer.getLong(C_PAYMENT_CNT_IDX) + 1; byte[] c_data; if (Arrays.equals(c_credit, Constants.BAD_CREDIT_BYTES)) { c_data = customer.getStringAsBytes(C_DATA_IDX); byte[] newData = (c_id + " " + c_d_id + " " + c_w_id + " " + d_id + " " + w_id + " " + h_amount + "|") .getBytes(); int newLength = newData.length + c_data.length; if (newLength > Constants.MAX_C_DATA) { newLength = Constants.MAX_C_DATA; } ByteBuilder builder = new ByteBuilder(newLength); int minLength = newLength; if (newData.length < minLength) minLength = newData.length; builder.append(newData, 0, minLength); int remaining = newLength - minLength; builder.append(c_data, 0, remaining); c_data = builder.array(); voltQueueSQL( updateBCCustomer, c_balance, c_ytd_payment, c_payment_cnt, c_data, c_w_id, c_d_id, c_id); } else { c_data = new byte[0]; voltQueueSQL(updateGCCustomer, c_balance, c_ytd_payment, c_payment_cnt, c_w_id, c_d_id, c_id); } voltExecuteSQL(); // TPC-C 2.5.3.3: Must display the following fields: // W_ID, D_ID, C_ID, C_D_ID, C_W_ID, W_STREET_1, W_STREET_2, W_CITY, W_STATE, W_ZIP, // D_STREET_1, D_STREET_2, D_CITY, D_STATE, D_ZIP, C_FIRST, C_MIDDLE, C_LAST, C_STREET_1, // C_STREET_2, C_CITY, C_STATE, C_ZIP, C_PHONE, C_SINCE, C_CREDIT, C_CREDIT_LIM, // C_DISCOUNT, C_BALANCE, the first 200 characters of C_DATA (only if C_CREDIT = "BC"), // H_AMOUNT, and H_DATE. // Return the entire warehouse and district tuples. The client provided: // w_id, d_id, c_d_id, c_w_id, h_amount, h_data. // Build a table for the rest final VoltTable misc = misc_template.clone(1024); misc.addRow( c_id, c_first, c_middle, c_last, c_street_1, c_street_2, c_city, c_state, c_zip, c_phone, c_since, c_credit, c_credit_lim, c_discount, c_balance, c_data); return new VoltTable[] {misc}; }
public VoltTable run(short w_id, int o_carrier_id, TimestampType timestamp) throws VoltAbortException { for (long d_id = 1; d_id <= Constants.DISTRICTS_PER_WAREHOUSE; ++d_id) { voltQueueSQL(getNewOrder, d_id, w_id); } final VoltTable[] neworderresults = voltExecuteSQL(); assert neworderresults.length == Constants.DISTRICTS_PER_WAREHOUSE; final Long[] no_o_ids = new Long[Constants.DISTRICTS_PER_WAREHOUSE]; int valid_neworders = 0; int[] result_offsets = new int[Constants.DISTRICTS_PER_WAREHOUSE]; for (long d_id = 1; d_id <= Constants.DISTRICTS_PER_WAREHOUSE; ++d_id) { final VoltTable newOrder = neworderresults[(int) d_id - 1]; if (newOrder.getRowCount() == 0) { // No orders for this district: skip it. Note: This must be reported if > 1% result_offsets[(int) d_id - 1] = -1; continue; } assert newOrder.getRowCount() == 1; result_offsets[(int) d_id - 1] = valid_neworders * 2; ++valid_neworders; final Long no_o_id = newOrder.asScalarLong(); no_o_ids[(int) d_id - 1] = no_o_id; voltQueueSQL(getCId, no_o_id, d_id, w_id); voltQueueSQL(sumOLAmount, no_o_id, d_id, w_id); } final VoltTable[] otherresults = voltExecuteSQL(); assert otherresults.length == valid_neworders * 2; for (long d_id = 1; d_id <= Constants.DISTRICTS_PER_WAREHOUSE; ++d_id) { final VoltTable newOrder = neworderresults[(int) d_id - 1]; if (newOrder.getRowCount() == 0) { // No orders for this district: skip it. Note: This must be reported if > 1% continue; } assert newOrder.getRowCount() == 1; final Long no_o_id = newOrder.asScalarLong(); no_o_ids[(int) d_id - 1] = no_o_id; voltQueueSQL(deleteNewOrder, d_id, w_id, no_o_id); voltQueueSQL(updateOrders, o_carrier_id, no_o_id, d_id, w_id); voltQueueSQL(updateOrderLine, timestamp, no_o_id, d_id, w_id); } voltExecuteSQL(); // these must be logged in the "result file" according to TPC-C 2.7.2.2 (page 39) // We remove the queued time, completed time, w_id, and o_carrier_id: the client can figure // them out final VoltTable result = result_template.clone(1024); for (long d_id = 1; d_id <= Constants.DISTRICTS_PER_WAREHOUSE; ++d_id) { int resultoffset = result_offsets[(int) d_id - 1]; if (resultoffset < 0) { continue; } assert otherresults[resultoffset + 0].getRowCount() == 1; assert otherresults[resultoffset + 1].getRowCount() == 1; final long c_id = (otherresults[resultoffset + 0].asScalarLong()); final VoltTableRow row = otherresults[resultoffset + 1].fetchRow(0); final double ol_total = row.getDouble(0); final boolean ol_total_wasnull = row.wasNull(); // If there are no order lines, SUM returns null. There should always be order lines. if (ol_total_wasnull) { throw new VoltAbortException( "ol_total is NULL: there are no order lines. This should not happen"); } assert ol_total > 0.0; voltQueueSQL(updateCustomer, ol_total, c_id, d_id, w_id); final Long no_o_id = no_o_ids[(int) d_id - 1]; result.addRow(d_id, no_o_id); } voltExecuteSQL(); return result; }