tscli.c

Mysql for Windows最新源码

	SDWORD	ol_i_ids_len;
	SDWORD	ol_quantities_len;
	SDWORD	c_last_len;
	SDWORD	c_credit_len;
	SDWORD	c_discount_len;
	SDWORD	w_tax_len;
	SDWORD	d_tax_len;
	SDWORD	o_ol_count_len;
	SDWORD	o_id_len;
	SDWORD	o_entry_d_len;
	SDWORD	total_len;
	SDWORD	i_names_len;
	SDWORD	s_quantities_len;
	SDWORD	bg_len;
	SDWORD	i_prices_len;
	SDWORD	ol_amounts_len;
	ulint	i;
	ulint	k;
	ulint	t;
	
	printf("Client thread %s\n", (UCHAR*)arg);

	ret = SQLAllocEnv(&env);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLAllocConnect(env, &conn);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLAllocStmt(conn, &new_order_query);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLAllocStmt(conn, &payment_query);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLAllocStmt(conn, &order_status_query);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLAllocStmt(conn, &delivery_query);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLAllocStmt(conn, &stock_level_query);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLAllocStmt(conn, &print_query);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLAllocStmt(conn, &commit_query);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLAllocStmt(conn, &lock_wait_query);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLAllocStmt(conn, &join_test_query);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLAllocStmt(conn, &test_group_commit_query);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLAllocStmt(conn, &rollback_query);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLAllocStmt(conn, &ibuf_query);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLConnect(conn, (UCHAR*)cli_srv_endpoint_name,
				(SWORD)ut_strlen(cli_srv_endpoint_name),
			(UCHAR*)arg, (SWORD)ut_strlen((char*)arg),
						(UCHAR*)"password", 8);
	ut_a(ret == SQL_SUCCESS);

	printf("Connection established\n");

	/*-----------------------------------------------------------*/		
	str =
	"{NEW_ORDER(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,"
							" ?, ?, ?, ?)}";
							
	ret = SQLPrepare(new_order_query, (UCHAR*)str, ut_strlen(str));

	ut_a(ret == SQL_SUCCESS);

	ret = SQLBindParameter(new_order_query, 1, SQL_PARAM_INPUT,
				SQL_C_CHAR, SQL_CHAR, 0, 0, c_w_id_buf,
				2, &c_w_id_len);
	ut_a(ret == SQL_SUCCESS);

	ret = SQLBindParameter(new_order_query, 2, SQL_PARAM_INPUT,
				SQL_C_CHAR, SQL_CHAR, 0, 0, c_d_id_buf,
				1, &c_d_id_len);
	ut_a(ret == SQL_SUCCESS);

	c_d_id_len = 1;

	ret = SQLBindParameter(new_order_query, 3, SQL_PARAM_INPUT,
				SQL_C_CHAR, SQL_CHAR, 0, 0, c_id_buf,
				3, &c_id_len);
	ut_a(ret == SQL_SUCCESS);

	c_id_len = 3;

	ret = SQLBindParameter(new_order_query, 4, SQL_PARAM_INPUT,
				SQL_C_CHAR, SQL_CHAR, 0, 0, ol_supply_w_ids_buf,
				30, &ol_supply_w_ids_len);
	ut_a(ret == SQL_SUCCESS);

	ret = SQLBindParameter(new_order_query, 5, SQL_PARAM_INPUT,
				SQL_C_CHAR, SQL_CHAR, 0, 0, ol_i_ids_buf,
				45, &ol_i_ids_len);
	ut_a(ret == SQL_SUCCESS);

	ret = SQLBindParameter(new_order_query, 6, SQL_PARAM_INPUT,
				SQL_C_CHAR, SQL_CHAR, 0, 0, ol_quantities_buf,
				15, &ol_quantities_len);
	ut_a(ret == SQL_SUCCESS);

	ret = SQLBindParameter(new_order_query, 7, SQL_PARAM_OUTPUT,
				SQL_C_CHAR, SQL_CHAR, 0, 0, c_last_buf,
				50, &c_last_len);
	ut_a(ret == SQL_SUCCESS);

	ret = SQLBindParameter(new_order_query, 8, SQL_PARAM_OUTPUT,
				SQL_C_CHAR, SQL_CHAR, 0, 0,
				(byte*)&c_credit_buf,
				2, &c_credit_len);
	ut_a(ret == SQL_SUCCESS);
	c_credit_buf[2] = '\0';
	
	ret = SQLBindParameter(new_order_query, 9, SQL_PARAM_OUTPUT,
				SQL_C_LONG, SQL_INTEGER, 0, 0,
				(byte*)&c_discount_buf,
				4, &c_discount_len);
	ut_a(ret == SQL_SUCCESS);

	ret = SQLBindParameter(new_order_query, 10, SQL_PARAM_OUTPUT,
				SQL_C_LONG, SQL_INTEGER, 0, 0,
				(byte*)&w_tax_buf,
				4, &w_tax_len);
	ut_a(ret == SQL_SUCCESS);
	
	ret = SQLBindParameter(new_order_query, 11, SQL_PARAM_OUTPUT,
				SQL_C_LONG, SQL_INTEGER, 0, 0,
				(byte*)&d_tax_buf,
				4, &d_tax_len);
	ut_a(ret == SQL_SUCCESS);
	
	ret = SQLBindParameter(new_order_query, 12, SQL_PARAM_OUTPUT,
				SQL_C_LONG, SQL_INTEGER, 0, 0,
				(byte*)&o_ol_count_buf,
				4, &o_ol_count_len);
	ut_a(ret == SQL_SUCCESS);
	
	ret = SQLBindParameter(new_order_query, 13, SQL_PARAM_OUTPUT,
				SQL_C_LONG, SQL_INTEGER, 0, 0,
				(byte*)&o_id_buf,
				4, &o_id_len);
	ut_a(ret == SQL_SUCCESS);
	
	ret = SQLBindParameter(new_order_query, 14, SQL_PARAM_OUTPUT,
				SQL_C_LONG, SQL_INTEGER, 0, 0,
				(byte*)&o_entry_d_buf,
				4, &o_entry_d_len);
	ut_a(ret == SQL_SUCCESS);
	
	ret = SQLBindParameter(new_order_query, 15, SQL_PARAM_OUTPUT,
				SQL_C_LONG, SQL_INTEGER, 0, 0,
				(byte*)&total_buf,
				4, &total_len);
	ut_a(ret == SQL_SUCCESS);

	ret = SQLBindParameter(new_order_query, 16, SQL_PARAM_OUTPUT,
				SQL_C_CHAR, SQL_CHAR, 0, 0, i_names_buf,
				360, &i_names_len);
	ut_a(ret == SQL_SUCCESS);
	i_names_buf[360] = '\0';

	ret = SQLBindParameter(new_order_query, 17, SQL_PARAM_OUTPUT,
				SQL_C_CHAR, SQL_CHAR, 0, 0, s_quantities_buf,
				60, &s_quantities_len);
	ut_a(ret == SQL_SUCCESS);

	ret = SQLBindParameter(new_order_query, 18, SQL_PARAM_OUTPUT,
				SQL_C_CHAR, SQL_CHAR, 0, 0, bg_buf,
				15, &bg_len);
	ut_a(ret == SQL_SUCCESS);
	bg_buf[15] = '\0';

	ret = SQLBindParameter(new_order_query, 19, SQL_PARAM_OUTPUT,
				SQL_C_CHAR, SQL_CHAR, 0, 0, i_prices_buf,
				60, &i_prices_len);
	ut_a(ret == SQL_SUCCESS);

	ret = SQLBindParameter(new_order_query, 20, SQL_PARAM_OUTPUT,
				SQL_C_CHAR, SQL_CHAR, 0, 0, ol_amounts_buf,
				60, &ol_amounts_len);
	ut_a(ret == SQL_SUCCESS);
	
	c_w_id_len = 2;
	c_w_id_buf[1] = (byte)(2 * atoi((char*)arg + 4));
	c_w_id_buf[0] = (byte)(2 * (atoi((char*)arg + 4) / 256));

	k = atoi((char*)arg + 4);

	printf("Client thread %lu starts\n", k); 

	/*-----------------------------------------------------------*/		
	str = "{PAYMENT(?)}";
	
	ret = SQLPrepare(payment_query, (UCHAR*)str, ut_strlen(str));

	ut_a(ret == SQL_SUCCESS);

	ret = SQLBindParameter(payment_query, 1, SQL_PARAM_INPUT,
				SQL_C_CHAR, SQL_CHAR, 0, 0, c_w_id_buf,
				2, &c_w_id_len);
	ut_a(ret == SQL_SUCCESS);

	/*-----------------------------------------------------------*/		
	str = "{ORDER_STATUS(?)}";
	
	ret = SQLPrepare(order_status_query, (UCHAR*)str, ut_strlen(str));

	ut_a(ret == SQL_SUCCESS);

	ret = SQLBindParameter(order_status_query, 1, SQL_PARAM_INPUT,
				SQL_C_CHAR, SQL_CHAR, 0, 0, c_w_id_buf,
				2, &c_w_id_len);
	ut_a(ret == SQL_SUCCESS);

	/*-----------------------------------------------------------*/		
	str = "{DELIVERY(?)}";
	
	ret = SQLPrepare(delivery_query, (UCHAR*)str, ut_strlen(str));

	ut_a(ret == SQL_SUCCESS);

	ret = SQLBindParameter(delivery_query, 1, SQL_PARAM_INPUT,
				SQL_C_CHAR, SQL_CHAR, 0, 0, c_w_id_buf,
				2, &c_w_id_len);
	ut_a(ret == SQL_SUCCESS);

	/*-----------------------------------------------------------*/		
	str = "{STOCK_LEVEL(?)}";
	
	ret = SQLPrepare(stock_level_query, (UCHAR*)str, ut_strlen(str));

	ut_a(ret == SQL_SUCCESS);

	ret = SQLBindParameter(stock_level_query, 1, SQL_PARAM_INPUT,
				SQL_C_CHAR, SQL_CHAR, 0, 0, c_w_id_buf,
				2, &c_w_id_len);
	ut_a(ret == SQL_SUCCESS);

	/*-----------------------------------------------------------*/		
	str = "{ROLLBACK_QUERY()}";
	
	ret = SQLPrepare(rollback_query, (UCHAR*)str, ut_strlen(str));

	ut_a(ret == SQL_SUCCESS);
	/*-----------------------------------------------------------*/		

	oldtm = ut_clock();

	for (i = k; i < k + n_rounds / n_users; i++) {

		/* execute_until_success(ibuf_query, rollback_query); */

		if (i % 100 == 0) {
			printf("User %s round %lu\n", (char*)arg, i);
		}

		if (!own_warehouse) {
			c_w_id_buf[1] = (byte)ut_rnd_interval(1, n_warehouses);
			c_w_id_buf[0] = (byte)(ut_rnd_interval(1, n_warehouses)
									/ 256);
		}

		mach_write_to_1(c_d_id_buf, (ut_rnd_interval(1, 10) + 47));
		mach_write_to_3(c_id_buf, ut_rnd_interval(1, n_customers));

		n_lines = ut_rnd_interval(5, 15);

		if ((15 * k + i) % 100 == 0) {
			put_invalid_item = TRUE;

			/* printf("Will put invalid item\n"); */
		} else {
			put_invalid_item = FALSE;
		}

		for (t = 0; t < n_lines; t++) {
			mach_write_to_3(ol_i_ids_buf + 3 * t,
						ut_rnd_interval(1, n_items));

			if (put_invalid_item && (t + 1 == n_lines)) {
				mach_write_to_3(ol_i_ids_buf + 3 * t,
								n_items + 1);
			}

			mach_write_to_1(ol_quantities_buf + t,
						ut_rnd_interval(10, 20));
			ut_memcpy(ol_supply_w_ids_buf + 2 * t, c_w_id_buf, 2);
		}

		ol_i_ids_len = 3 * n_lines;
		ol_quantities_len = n_lines;
		ol_supply_w_ids_len = 2 * n_lines;

		execute_until_success(new_order_query, rollback_query);

		if (put_invalid_item) {

			goto skip_prints;
		}
/*		
		c_last_buf[c_last_len] = '\0';

		printf(
	"C_LAST %s, c_credit %s, c_discount, %lu, w_tax %lu, d_tax %lu\n",
			c_last_buf, c_credit_buf, w_tax_buf, d_tax_buf);

		printf("o_ol_count %lu, o_id %lu, o_entry_d %lu, total %lu\n",
			o_ol_count_buf, o_id_buf, o_entry_d_buf,
			total_buf);

		ut_a(c_credit_len == 2);
		ut_a(c_discount_len == 4);
		ut_a(i_names_len == 360);
			
		printf("i_names %s, bg %s\n", i_names_buf, bg_buf);
		
		for (t = 0; t < n_lines; t++) {
			printf("s_quantity %lu, i_price %lu, ol_amount %lu\n",
				mach_read_from_4(s_quantities_buf + 4 * t),
				mach_read_from_4(i_prices_buf + 4 * t),
				mach_read_from_4(ol_amounts_buf + 4 * t));
		}
*/
	skip_prints:
		;
	
		execute_until_success(payment_query, rollback_query);

		if (i % 10 == 3) {
			execute_until_success(order_status_query,
							rollback_query);
		}

		if ((i % 10 == 6) || (i % 100 == 60)) {
			execute_until_success(delivery_query, rollback_query);
		}

		if (i % 10 == 9) {
			execute_until_success(stock_level_query,
							rollback_query);
		}
	}

	tm = ut_clock();

	printf("Wall time for %lu loops %lu milliseconds\n",
						(i - k), tm - oldtm);

/*	execute_until_success(print_query, rollback_query); */

	n_exited++;

	printf("Client thread %lu exits as the %luth\n", k, n_exited);
	
	return(0);
}

/*********************************************************************
Test for single row select. */

ulint
test_single_row_select(
/*===================*/
	void*	arg)	/* in: user name as a null-terminated string */
{
	ulint	n_items = 200;
	HENV	env;
	HDBC	conn;
	RETCODE	ret;
	HSTMT	single_row_select_query;
	ulint	tm, oldtm;
	char*	str;
	byte	i_id_buf[3];
	byte	i_name_buf[25];
	SDWORD	i_id_len;
	SDWORD	i_name_len;
	ulint	i;
	
	ret = SQLAllocEnv(&env);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLAllocConnect(env, &conn);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLAllocStmt(conn, &single_row_select_query);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLConnect(conn, (UCHAR*)cli_srv_endpoint_name,
				(SWORD)ut_strlen(cli_srv_endpoint_name),
					(UCHAR*)arg,
					(SWORD)ut_strlen((char*)arg),
						(UCHAR*)"password", 8);
	ut_a(ret == SQL_SUCCESS);

	printf("Connection established\n");

	/*-----------------------------------------------------------*/		
	str =
	"{TEST_SINGLE_ROW_SELECT(?, ?)}";
							
	ret = SQLPrepare(single_row_select_query, (UCHAR*)str,
							ut_strlen(str));
	ut_a(ret == SQL_SUCCESS);

	ret = SQLBindParameter(single_row_select_query, 1, SQL_PARAM_INPUT,
				SQL_C_CHAR, SQL_CHAR, 0, 0, i_id_buf,
				3, &i_id_len);
	ut_a(ret == SQL_SUCCESS);
	i_id_len = 3;
	
	ret = SQLBindParameter(single_row_select_query, 2, SQL_PARAM_OUTPUT,
				SQL_C_CHAR, SQL_CHAR, 0, 0, i_name_buf,
				24, &i_name_len);
	ut_a(ret == SQL_SUCCESS);
	i_name_buf[24] = '\0';

	oldtm = ut_clock();

	for (i = 0; i < 10000; i++) {

		mach_write_to_3(i_id_buf, ut_rnd_interval(1, n_items));

		ret = SQLExecute(single_row_select_query);
		
		ut_a(ret == SQL_SUCCESS);
	}

	tm = ut_clock();

	printf("Wall time for %lu single row selects %lu milliseconds\n",
							i, tm - oldtm);
	return(0);
}

/*********************************************************************
TPC-D query 5. */

ulint
test_tpc_d_client(
/*==============*/
	void*	arg)	/* in: pointer to an array of startdate and enddate */
{
	char	buf[20];
	HENV	env;
	HDBC	conn1;
	RETCODE	ret;
	HSTMT	query5;
	HSTMT	join_test;
	char*	str;
	SDWORD	len1;
	SDWORD	len2;
	ulint	i;
	ulint	tm, oldtm;
	
	UT_NOT_USED(arg);
	
	ret = SQLAllocEnv(&env);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLAllocConnect(env, &conn1);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLAllocStmt(conn1, &query5);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLAllocStmt(conn1, &join_test);

	ut_a(ret == SQL_SUCCESS);

	sprintf(buf, "Use2%5lu", *((ulint*)arg));
	
	ret = SQLConnect(conn1, (UCHAR*)cli_srv_endpoint_name,
				(SWORD)ut_strlen(cli_srv_endpoint_name),
					(UCHAR*)buf,
					(SWORD)9, (UCHAR*)"password", 8);
	ut_a(ret == SQL_SUCCESS);

	printf("Connection established\n");

	/*-----------------------------------------------------------*/		
	str = "{TPC_D_QUERY_5(?, ?)}";
	
	ret = SQLPrepare(query5, (UCHAR*)str, ut_strlen(str));

	ut_a(ret == SQL_SUCCESS);

	ret = SQLBindParameter(query5, 1, SQL_PARAM_INPUT,
				SQL_C_LONG, SQL_INTEGER, 0, 0,
				(byte*)arg,
				4, &len1);
	ut_a(ret == SQL_SUCCESS);

	len1 = 4;

	ret = SQLBindParameter(query5, 2, SQL_PARAM_INPUT,
				SQL_C_LONG, SQL_INTEGER, 0, 0,
				(byte*)arg + sizeof(ulint),
				4, &len2);
	ut_a(ret == SQL_SUCCESS);

	len2 = 4;

	str = "{JOIN_TEST()}";
	
	ret = SQLPrepare(join_test, (UCHAR*)str, ut_strlen(str));

	ut_a(ret == SQL_SUCCESS);

	for (i = 0; i < n_rounds; i++) {
	
		oldtm = ut_clock();

		ret = SQLExecute(query5);

		/* ret = SQLExecute(join_test); */

		ut_a(ret == SQL_SUCCESS);

		tm = ut_clock(