tscli.c

Mysql for Windows最新源码

""
"	ROLLBACK WORK;"
""	
"	END;"
	;

	rollback_str = str;
	/*-----------------------------------------------------------*/
	str =
	
"	PROCEDURE TEST_LOCK_WAIT () IS"
""
"	w_id CHAR;"
"	BEGIN"
""
"	w_id := TO_BINARY(1, 2);"
"	UPDATE WAREHOUSE SET W_YTD = W_YTD + 1 WHERE W_ID = w_id;"
""	
"	END;"
	;

	lock_wait_str = str;
	/*-----------------------------------------------------------*/
	str =
	
"	PROCEDURE TEST_IBUF () IS"
""
"	i INT;"
"	rnd INT;"
"	j INT;"
"	found INT;"
""
"	DECLARE CURSOR desc_cursor IS"
"		SELECT IB_A"
"		FROM IBUF_TEST"
"			WHERE IB_A >= rnd AND IB_A < rnd + 50"
"			ORDER BY IB_A DESC;"
""
"	BEGIN"
""
"	PRINTF('Ibuf QUERY starts!!!!!!');"
"	rnd := RND(1, 1000);"
""
"	FOR i IN 1 .. 50 LOOP"
"		INSERT INTO IBUF_TEST VALUES (rnd + i,"
"						RND_STR(RND(1, 2000)));"
"	END LOOP;"
"	IF (RND(1, 100) < 30) THEN"
"		PRINTF('Ibuf rolling back ---!!!');"
"		ROLLBACK WORK;"
"	END IF;"
""
""
"	IF (RND(1, 100) < 101) THEN"
"		rnd := RND(1, 1000);"
"		DELETE FROM IBUF_TEST WHERE IB_A >= rnd "
"						AND IB_A <= rnd + 50;"
"	END IF;"
""
"	rnd := RND(1, 1000);"
"	SELECT COUNT(*) INTO j"
"		FROM IBUF_TEST"
"		WHERE IB_A >= rnd AND IB_A < rnd + 50;"
""
"	PRINTF('Count: ', j);"
""
"	rnd := RND(1, 1000);"
"	UPDATE IBUF_TEST"
"		SET IB_B = RND_STR(RND(1, 2000))"
"		WHERE IB_A >= rnd AND IB_A < rnd + 50;"
""
"	OPEN desc_cursor;"
""
"	rnd := RND(1, 1000);"
"	found := 1;"
"	WHILE (found > 0) LOOP"
""
"		FETCH desc_cursor INTO j;"
""
"		IF (desc_cursor % NOTFOUND) THEN"
"			found := 0;"
"		END IF;"
"	END LOOP;"
""
"	CLOSE desc_cursor;"
""
"	IF (RND(1, 100) < 30) THEN"
"		PRINTF('Ibuf rolling back!!!');"
"		ROLLBACK WORK;"
"	ELSE"
"		COMMIT WORK;"
"	END IF;"
""
"	PRINTF('Ibuf QUERY ends!!!!!!');"
"	END;"
	;

	ibuf_test_str = str;
	/*-----------------------------------------------------------*/
	str =
	
"	PROCEDURE TEST_GROUP_COMMIT (w_id IN CHAR) IS"
""
"	i INT;"
""
"	BEGIN"
""
"	FOR i IN 1 .. 200 LOOP"
"		UPDATE WAREHOUSE SET W_YTD = W_YTD + 1 WHERE W_ID = w_id;"
"		COMMIT WORK;"
"	END LOOP;"
"	END;"
	;

	test_group_commit_str = str;
	/*-----------------------------------------------------------*/
	str =
	
"	PROCEDURE TEST_SINGLE_ROW_SELECT ("
"				i_id IN CHAR,"
"				i_name OUT CHAR) IS"
"	BEGIN"
"	SELECT I_NAME INTO i_name"
"	FROM ITEM"
"		WHERE I_ID = i_id"
"		CONSISTENT READ;"
"	END;"
	;

	test_single_row_select_str = str;
	/*-----------------------------------------------------------*/
	str =
	
"	PROCEDURE JOIN_TEST () IS"
""
" 	n_rows INT;"
"	i INT;"
""
"	BEGIN"
""
"	FOR i IN 0 .. 0 LOOP"
"		SELECT COUNT(*) INTO n_rows"
"		FROM JTEST1, JTEST2"
"			WHERE JT2_A = JT1_B"
"			CONSISTENT READ;"
"		PRINTF(n_rows);"
""
"		COMMIT WORK;"
"	END LOOP;"
""
"	END;"
	;

	join_test_str = str;

	/*-----------------------------------------------------------*/
	str =
	
"	PROCEDURE TEST_ERRORS (switch IN CHAR) IS"
""
"	count	INT;"
"	val	INT;"
""
"	BEGIN"
""
"	IF (switch = '01') THEN"
"		/* Test duplicate key error: run this first */"
"		ROW_PRINTF SELECT * FROM JTEST1;"
"		PRINTF('To insert first');"
"		INSERT INTO JTEST1 VALUES (1, 1);"
"		PRINTF('To insert second');"
"		INSERT INTO JTEST1 VALUES (2, 2);"
"	END IF;"
""
"	IF (switch = '02') THEN"
"		/* Test duplicate key error: run this second */"
"		ROW_PRINTF SELECT * FROM JTEST1;"
"		PRINTF('To insert third');"
"		INSERT INTO JTEST1 VALUES (3, 3);"
"		ROW_PRINTF SELECT * FROM JTEST1;"
"		PRINTF('To insert fourth');"
"		INSERT INTO JTEST1 VALUES (1, 1);"
"	END IF;"
""
"	IF (switch = '03') THEN"
"		/* Test duplicate key error: run this third */"
"		ROW_PRINTF SELECT * FROM JTEST1;"
"		PRINTF('Testing assert');"
"		SELECT COUNT(*) INTO count FROM JTEST1;"
"		ASSERT(count = 2);"
"	END IF;"
""
"	IF (switch = '04') THEN"
"		/* Test duplicate key error: run this fourth */"
"		ROW_PRINTF SELECT * FROM JTEST1;"
"		PRINTF('Testing update');"
"		UPDATE JTEST1 SET JT1_A = 3 WHERE JT1_A = 2;" 
"		PRINTF('Testing update');"
"		UPDATE JTEST1 SET JT1_A = 1 WHERE JT1_A = 3;" 
"	END IF;"
""	
"	IF (switch = '05') THEN"
"		/* Test deadlock error: run this fifth in thread 1 */"
"		COMMIT WORK;"
"		PRINTF('Testing update in thread 1');"
"		UPDATE JTEST1 SET JT1_B = 3 WHERE JT1_A = 1;" 
"	END IF;"
""
"	IF (switch = '06') THEN"
"		/* Test deadlock error: run this sixth in thread 2 */"
"		PRINTF('Testing update in thread 2');"
"		UPDATE JTEST1 SET JT1_B = 10 WHERE JT1_A = 2;" 
"		PRINTF('Testing update in thread 2');"
"		UPDATE JTEST1 SET JT1_B = 11 WHERE JT1_A = 1;" 
"		PRINTF('Update in thread 2 completed');"
"		SELECT JT1_B INTO val FROM JTEST1 WHERE JT1_A = 1;"
"		ASSERT(val = 11);"
"		SELECT JT1_B INTO val FROM JTEST1 WHERE JT1_A = 2;"
"		ASSERT(val = 10);"		
"		COMMIT WORK;"
"	END IF;"
""
"	IF (switch = '07') THEN"
"		/* Test deadlock error: run this seventh in thread 1 */"
"		PRINTF('Testing update in thread 1: deadlock');"
"		UPDATE JTEST1 SET JT1_B = 4 WHERE JT1_A = 2;" 
"	END IF;"
""	
"	IF (switch = '08') THEN"
"		/* Test deadlock error: run this eighth in thread 1 */"
"		PRINTF('Testing update in thread 1: commit');"
"		SELECT JT1_B INTO val FROM JTEST1 WHERE JT1_A = 1;"
"		ASSERT(val = 3);"
"		COMMIT WORK;"
"	END IF;"
""	
"	END;"
	;

	test_errors_str = str;
	/*-----------------------------------------------------------*/
	ret = SQLAllocEnv(&env);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLAllocConnect(env, &conn);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLAllocStmt(conn, &stat);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLAllocStmt(conn, &create_query);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLAllocStmt(conn, &populate_query);

	ut_a(ret == SQL_SUCCESS);

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

	printf("Connection established\n");

	/*-----------------------------------------------------------*/
	ret = SQLPrepare(stat, (UCHAR*)create_str, ut_strlen(create_str));

	ut_a(ret == SQL_SUCCESS);

	ret = SQLExecute(stat);

	ut_a(ret == SQL_SUCCESS);

	str = "{CREATE_TABLES()}";
	
	ret = SQLPrepare(create_query, (UCHAR*)str, ut_strlen(str));

	ut_a(ret == SQL_SUCCESS);

	ret = SQLExecute(create_query);

	ut_a(ret == SQL_SUCCESS);

	/*-----------------------------------------------------------*/
	ret = SQLPrepare(stat, (UCHAR*)populate_str, ut_strlen(populate_str));

	ut_a(ret == SQL_SUCCESS);

	ret = SQLExecute(stat);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLPrepare(stat, (UCHAR*)lock_wait_str,
						ut_strlen(lock_wait_str));
	ut_a(ret == SQL_SUCCESS);

	ret = SQLExecute(stat);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLPrepare(stat, (UCHAR*)commit_str,
						ut_strlen(commit_str));
	ut_a(ret == SQL_SUCCESS);

	ret = SQLExecute(stat);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLPrepare(stat, (UCHAR*)print_str,
						ut_strlen(print_str));
	ut_a(ret == SQL_SUCCESS);

	ret = SQLExecute(stat);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLPrepare(stat, (UCHAR*)new_order_str,
						ut_strlen(new_order_str));
	ut_a(ret == SQL_SUCCESS);

	ret = SQLExecute(stat);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLPrepare(stat, (UCHAR*)payment_str,
						ut_strlen(payment_str));
	ut_a(ret == SQL_SUCCESS);

	ret = SQLExecute(stat);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLPrepare(stat, (UCHAR*)order_status_str,
						ut_strlen(order_status_str));
	ut_a(ret == SQL_SUCCESS);

	ret = SQLExecute(stat);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLPrepare(stat, (UCHAR*)delivery_str,
						ut_strlen(delivery_str));
	ut_a(ret == SQL_SUCCESS);

	ret = SQLExecute(stat);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLPrepare(stat, (UCHAR*)stock_level_str,
						ut_strlen(stock_level_str));
	ut_a(ret == SQL_SUCCESS);

	ret = SQLExecute(stat);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLPrepare(stat, (UCHAR*)query_5_str,
						ut_strlen(query_5_str));
	ut_a(ret == SQL_SUCCESS);

	ret = SQLExecute(stat);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLPrepare(stat, (UCHAR*)consistency_str,
						ut_strlen(consistency_str));
	ut_a(ret == SQL_SUCCESS);

	ret = SQLExecute(stat);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLPrepare(stat, (UCHAR*)rollback_str, ut_strlen(rollback_str));

	ut_a(ret == SQL_SUCCESS);

	ret = SQLExecute(stat);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLPrepare(stat, (UCHAR*)join_test_str,
						ut_strlen(join_test_str));
	ut_a(ret == SQL_SUCCESS);

	ret = SQLExecute(stat);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLPrepare(stat, (UCHAR*)test_errors_str,
						ut_strlen(test_errors_str));
	ut_a(ret == SQL_SUCCESS);

	ret = SQLExecute(stat);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLPrepare(stat, (UCHAR*)test_single_row_select_str,
				ut_strlen(test_single_row_select_str));
	ut_a(ret == SQL_SUCCESS);

	ret = SQLExecute(stat);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLPrepare(stat, (UCHAR*)test_group_commit_str,
					ut_strlen(test_group_commit_str));
	ut_a(ret == SQL_SUCCESS);

	ret = SQLExecute(stat);

	ut_a(ret == SQL_SUCCESS);

	ret = SQLPrepare(stat, (UCHAR*)ibuf_test_str,
					ut_strlen(ibuf_test_str));
	ut_a(ret == SQL_SUCCESS);

	ret = SQLExecute(stat);

	ut_a(ret == SQL_SUCCESS);

	str = "{POPULATE_TABLES(?, ?)}";
	
	ret = SQLPrepare(populate_query, (UCHAR*)str, ut_strlen(str));

	ut_a(ret == SQL_SUCCESS);

	ret = SQLBindParameter(populate_query, 1, SQL_PARAM_INPUT,
				SQL_C_LONG, SQL_INTEGER, 0, 0,
				(byte*)&n_warehouses_buf,
				4, &n_warehouses_len);
	ut_a(ret == SQL_SUCCESS);

	n_warehouses_buf = n_warehouses;
	n_warehouses_len = 4;

	ret = SQLBindParameter(populate_query, 2, SQL_PARAM_INPUT,
				SQL_C_LONG, SQL_INTEGER, 0, 0,
				(byte*)&n_customers_d_buf,
				4, &n_customers_d_len);
	ut_a(ret == SQL_SUCCESS);

	n_customers_d_buf = n_customers_d;
	n_customers_d_len = 4;

	ret = SQLExecute(populate_query);

	ut_a(ret == SQL_SUCCESS);

	/*-----------------------------------------------------------*/		
	printf("TPC-C test database initialized\n");

	return(0);
}

/*********************************************************************
Iterates an SQL query until it returns SQL_SUCCESS. If it returns other
value, rolls back the trx, prints an error message, and tries again. */

void
execute_until_success(
/*==================*/
	HSTMT	query,		/* in: query */
	HSTMT	rollback_query)	/* in: trx rollback query to run if error */
{
	RETCODE	ret;
	UCHAR	sql_state[6];
	SDWORD	native_error;
	UCHAR	error_msg[512];
	SWORD	error_msg_max	= 512;
	SWORD	error_msg_len;

	for (;;) {
		ret = SQLExecute(query);

		if (ret != SQL_SUCCESS) {
			ut_a(ret == SQL_ERROR);
			
			ret = SQLError(SQL_NULL_HENV, SQL_NULL_HDBC, query,
					sql_state, &native_error, error_msg,
					error_msg_max, &error_msg_len);

			ut_a(ret == SQL_SUCCESS);

			printf("%s\n", error_msg);

			/* Roll back to release trx locks, and try again */

			ret = SQLExecute(rollback_query);
			ut_a(ret == SQL_SUCCESS);

			os_thread_sleep(ut_rnd_gen_ulint() / 1000);
		} else {

			return;
		}
	}
}

/*********************************************************************
Test for TPC-C. */

ulint
test_client(
/*=========*/
	void*	arg)	/* in: user name as a null-terminated string */
{
	ulint	n_customers = 20;
	ulint	n_items = 200;
	ulint	n_lines;
	bool	put_invalid_item;
	HENV	env;
	HDBC	conn;
	RETCODE	ret;
	HSTMT	commit_query;
	HSTMT	new_order_query;
	HSTMT	payment_query;
	HSTMT	order_status_query;
	HSTMT	delivery_query;
	HSTMT	stock_level_query;
	HSTMT	print_query;
	HSTMT	lock_wait_query;
	HSTMT	join_test_query;
	HSTMT	test_group_commit_query;
	HSTMT	rollback_query;
	HSTMT	ibuf_query;
	ulint	tm, oldtm;
	char*	str;
	byte	c_w_id_buf[2];
	byte	c_d_id_buf[1];
	byte	c_id_buf[3];
	byte	ol_supply_w_ids_buf[30];
	byte	ol_i_ids_buf[45];
	byte	ol_quantities_buf[15];
	byte	c_last_buf[51];
	byte	c_credit_buf[3];
	ulint	c_discount_buf;
	ulint	w_tax_buf;
	ulint	d_tax_buf;
	ulint	o_ol_count_buf;
	ulint	o_id_buf;
	ulint	o_entry_d_buf;
	ulint	total_buf;
	byte	i_names_buf[361];
	byte	s_quantities_buf[60];
	byte	bg_buf[16];
	byte	i_prices_buf[60];
	byte	ol_amounts_buf[60];
	SDWORD	c_w_id_len;
	SDWORD	c_d_id_len;
	SDWORD	c_id_len;
	SDWORD	ol_supply_w_ids_len;