PageRenderTime 56ms CodeModel.GetById 18ms RepoModel.GetById 0ms app.codeStats 0ms

/hphp/test/zend/bad/ext/mysqli/tests/mysqli_get_client_stats.php

http://github.com/facebook/hiphop-php
PHP | 940 lines | 656 code | 199 blank | 85 comment | 185 complexity | 91b13b44b3ed7d4223f4688369da301e MD5 | raw file
Possible License(s): LGPL-2.1, BSD-2-Clause, BSD-3-Clause, MPL-2.0-no-copyleft-exception, MIT, LGPL-2.0, Apache-2.0 
    

  1. <?php
    2. 

  2. 	/*
    3. 

  3. 	TODO
    4. 

  4. 	no_index_used - difficult to simulate because server/engine dependent
    5. 

  5. 	bad_index_used - difficult to simulate because server/engine dependent
    6. 

  6. 	flushed_normal_sets
    7. 

  7. 	flushed_ps_sets
    8. 

  8. 	explicit_close
    9. 

  9. 	implicit_close
    10. 

  10. 	disconnect_close
    11. 

  11. 	in_middle_of_command_close
    12. 

  12. 	explicit_free_result
    13. 

  13. 	implicit_free_result
    14. 

  14. 	explicit_stmt_close
    15. 

  15. 	implicit_stmt_close
    16. 

  16. 	*/
    17. 

  17. 

  18. 	function mysqli_get_client_stats_assert_eq($field, $current, $expected, &$test_counter, $desc = "") {
    19. 

  19. 

  20. 		$test_counter++;
    21. 

  21. 		if (is_array($current) && is_array($expected)) {
    22. 

  22. 			if ($current[$field] !== $expected[$field]) {
    23. 

  23. 				printf("[%03d] %s Expecting %s = %s/%s, got %s/%s\n",
    24. 

  24. 					$test_counter, $desc,
    25. 

  25. 					$field, $expected[$field], gettype($expected[$field]),
    26. 

  26. 					$current[$field], gettype($current[$field]));
    27. 

  27. 			}
    28. 

  28. 		} else if (is_array($current)) {
    29. 

  29. 			if ($current[$field] !== $expected) {
    30. 

  30. 				printf("[%03d] %s Expecting %s = %s/%s, got %s/%s\n",
    31. 

  31. 					$test_counter, $desc,
    32. 

  32. 					$field, $expected, gettype($expected),
    33. 

  33. 					$current[$field], gettype($current[$field]));
    34. 

  34. 			}
    35. 

  35. 		} else {
    36. 

  36. 			if ($current !== $expected) {
    37. 

  37. 				printf("[%03d] %s Expecting %s = %s/%s, got %s/%s\n",
    38. 

  38. 					$test_counter, $desc,
    39. 

  39. 					$field, $expected, gettype($expected),
    40. 

  40. 					$current, gettype($current));
    41. 

  41. 			}
    42. 

  42. 		}
    43. 

  43. 

  44. 	}
    45. 

  45. 

  46. 	function mysqli_get_client_stats_assert_gt($field, $current, $expected, &$test_counter, $desc = "") {
    47. 

  47. 

  48. 		$test_counter++;
    49. 

  49. 		if (is_array($current) && is_array($expected)) {
    50. 

  50. 			if ($current[$field] <= $expected[$field]) {
    51. 

  51. 				printf("[%03d] %s Expecting %s > %s/%s, got %s/%s\n",
    52. 

  52. 					$test_counter, $desc,
    53. 

  53. 					$field, $expected[$field], gettype($expected[$field]),
    54. 

  54. 					$current[$field], gettype($current[$field]));
    55. 

  55. 				}
    56. 

  56. 		} else {
    57. 

  57. 			if ($current <= $expected) {
    58. 

  58. 				printf("[%03d] %s Expecting %s > %s/%s, got %s/%s\n",
    59. 

  59. 					$test_counter, $desc, $field,
    60. 

  60. 					$expected, gettype($expected),
    61. 

  61. 					$current, gettype($current));
    62. 

  62. 			}
    63. 

  63. 		}
    64. 

  64. 

  65. 	}
    66. 

  66. 

  67. 

  68. 	$tmp = $link = null;
    69. 

  69. 	require_once("connect.inc");
    70. 

  70. 

  71. 	if (!is_array($info = mysqli_get_client_stats()) || empty($info))
    72. 

  72. 		printf("[002] Expecting array/any_non_empty, got %s/%s\n", gettype($info), $info);
    73. 

  73. 

  74. 	var_dump($info);
    75. 

  75. 

  76. 	if (!$link = my_mysqli_connect($host, $user, $passwd, $db, $port, $socket)) {
    77. 

  77. 		printf("[003] Cannot connect to the server using host=%s, user=%s, passwd=***, dbname=%s, port=%s, socket=%s\n",
    78. 

  78. 			$host, $user, $db, $port, $socket);
    79. 

  79. 		exit(1);
    80. 

  80. 	}
    81. 

  81. 

  82. 	if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    83. 

  83. 		printf("[004] Expecting array/any_non_empty, got %s/%s\n", gettype($new_info), $new_info);
    84. 

  84. 

  85. 	if (count($info) != count($new_info)) {
    86. 

  86. 		printf("[005] Expecting the same number of entries in the arrays\n");
    87. 

  87. 		var_dump($info);
    88. 

  88. 		var_dump($new_info);
    89. 

  89. 	}
    90. 

  90. 

  91. 	$test_counter = 6;
    92. 

  92. 

  93. 	mysqli_get_client_stats_assert_gt('bytes_sent', $new_info, $info, $test_counter);
    94. 

  94. 	mysqli_get_client_stats_assert_gt('bytes_received', $new_info, $info, $test_counter);
    95. 

  95. 	mysqli_get_client_stats_assert_gt('packets_sent', $new_info, $info, $test_counter);
    96. 

  96. 	mysqli_get_client_stats_assert_gt('packets_received', $new_info, $info, $test_counter);
    97. 

  97. 	mysqli_get_client_stats_assert_gt('protocol_overhead_in', $new_info, $info, $test_counter);
    98. 

  98. 	mysqli_get_client_stats_assert_gt('protocol_overhead_out', $new_info, $info, $test_counter);
    99. 

  99. 

  100. 	// we assume the above as test_mysqli_get_client_stats_table_1ed and in the following we check only those
    101. 

  101. 	mysqli_get_client_stats_assert_eq('result_set_queries', $new_info, $info, $test_counter);
    102. 

  102. 

  103. 	/* we need to skip this test_mysqli_get_client_stats_table_1 in unicode - we send set names utf8 during mysql_connect */
    104. 

  104. 	if (!(version_compare(PHP_VERSION, '5.9.9', '>') == 1))
    105. 

  105. 		mysqli_get_client_stats_assert_eq('non_result_set_queries', $new_info, $info, $test_counter);
    106. 

  106. 	mysqli_get_client_stats_assert_eq('buffered_sets', $new_info, $info, $test_counter);
    107. 

  107. 	mysqli_get_client_stats_assert_eq('unbuffered_sets', $new_info, $info, $test_counter);
    108. 

  108. 	mysqli_get_client_stats_assert_eq('ps_buffered_sets', $new_info, $info, $test_counter);
    109. 

  109. 	mysqli_get_client_stats_assert_eq('ps_unbuffered_sets', $new_info, $info, $test_counter);
    110. 

  110. 

  111. 	mysqli_get_client_stats_assert_eq('rows_skipped_ps', $new_info, $info, $test_counter);
    112. 

  112. 	mysqli_get_client_stats_assert_eq('copy_on_write_saved', $new_info, $info, $test_counter);
    113. 

  113. 	mysqli_get_client_stats_assert_eq('copy_on_write_performed', $new_info, $info, $test_counter);
    114. 

  114. 	mysqli_get_client_stats_assert_eq('command_buffer_too_small', $new_info, $info, $test_counter);
    115. 

  115. 	// This is not a mistake that I use %unicode|string%(1) "1" here! Andrey did not go for int to avoid any
    116. 

  116. 	// issues for very large numbers and 32 vs. 64bit systems
    117. 

  117. 	mysqli_get_client_stats_assert_eq('connect_success', $new_info, "1", $test_counter);
    118. 

  118. 	mysqli_get_client_stats_assert_eq('connect_failure', $new_info, $info, $test_counter);
    119. 

  119. 	mysqli_get_client_stats_assert_eq('connection_reused', $new_info, $info, $test_counter);
    120. 

  120. 

  121. 	// No data fetched so far
    122. 

  122. 	mysqli_get_client_stats_assert_eq('bytes_received_real_data_normal', $new_info, "0", $test_counter);
    123. 

  123. 	mysqli_get_client_stats_assert_eq('bytes_received_real_data_ps', $new_info, "0", $test_counter);
    124. 

  124. 

  125. 	$test_table_name = 'test_mysqli_get_client_stats_table_1'; require('table.inc');
    126. 

  126. 	if (!is_array($info = mysqli_get_client_stats()) || empty($info))
    127. 

  127. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    128. 

  128. 			++$test_counter, gettype($info), $info);
    129. 

  129. 

  130. 	// fetch stats
    131. 

  131. 	$expected = $info;
    132. 

  132. 

  133. 	// buffered normal
    134. 

  134. 	print "Testing buffered normal...\n";
    135. 

  135. 	if (!$res = mysqli_query($link, 'SELECT COUNT(*) AS _num FROM test_mysqli_get_client_stats_table_1', MYSQLI_STORE_RESULT))
    136. 

  136. 		printf("[%03d] SELECT COUNT() FROM test_mysqli_get_client_stats_table_1 failed, [%d] %s\n",
    137. 

  137. 			++$test_counter, mysqli_errno($link), mysqli_error($link));
    138. 

  138. 

  139. 	$expected['rows_fetched_from_server_normal'] = (string)($expected['rows_fetched_from_server_normal'] + 1);
    140. 

  140. 	$expected['buffered_sets'] = (string)($expected['buffered_sets'] + 1);
    141. 

  141. 	$expected['result_set_queries'] = (string)($expected['result_set_queries'] + 1);
    142. 

  142. 	$expected['rows_buffered_from_client_normal'] = (string)($expected['rows_buffered_from_client_normal'] + 1);
    143. 

  143. 

  144. 	if (!is_array($info = mysqli_get_client_stats()) || empty($info))
    145. 

  145. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    146. 

  146. 			++$test_counter, gettype($info), $info);
    147. 

  147. 

  148. 	mysqli_get_client_stats_assert_gt('bytes_sent', $info, $expected, $test_counter);
    149. 

  149. 	mysqli_get_client_stats_assert_gt('bytes_received', $info, $expected, $test_counter);
    150. 

  150. 

  151. 	// real_data_* get incremented after mysqli_*fetch*()
    152. 

  152.     mysqli_get_client_stats_assert_eq('bytes_received_real_data_normal', $info, "0", $test_counter);
    153. 

  153. 	mysqli_get_client_stats_assert_eq('bytes_received_real_data_ps', $info, "0", $test_counter);
    154. 

  154. 

  155. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_server_normal', $info, $expected, $test_counter);
    156. 

  156. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_client_normal_buffered', $info, $expected, $test_counter);
    157. 

  157. 	mysqli_get_client_stats_assert_eq('buffered_sets', $info, $expected, $test_counter);
    158. 

  158. 	mysqli_get_client_stats_assert_eq('result_set_queries', $info, $expected, $test_counter);
    159. 

  159. 	mysqli_get_client_stats_assert_eq('rows_buffered_from_client_normal', $info, $expected, $test_counter);
    160. 

  160. 

  161. 	/* no change to rows_fetched_from_client_normal_buffered! */
    162. 

  162. 	if (!$row = mysqli_fetch_assoc($res))
    163. 

  163. 		printf("[%03d] fetch_assoc - SELECT COUNT() FROM test_mysqli_get_client_stats_table_1 failed, [%d] %s\n",
    164. 

  164. 			++$test_counter, mysqli_errno($link), mysqli_error($link));
    165. 

  165. 

  166. 	$expected['rows_fetched_from_client_normal_buffered'] = (string)($expected['rows_fetched_from_client_normal_buffered'] + 1);
    167. 

  167. 

  168. 	if (!is_array($info = mysqli_get_client_stats()) || empty($info))
    169. 

  169. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    170. 

  170. 			++$test_counter, gettype($info), $info);
    171. 

  171. 

  172. 	// fetch will increment
    173. 

  173. 	mysqli_get_client_stats_assert_gt('bytes_received_real_data_normal', $info, $expected, $test_counter);
    174. 

  174. 	$expected['bytes_received_real_data_normal'] = $info['bytes_received_real_data_normal'];
    175. 

  175. 	mysqli_get_client_stats_assert_eq('bytes_received_real_data_ps', $info, "0", $test_counter);
    176. 

  176. 

  177. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_server_normal', $info, $expected, $test_counter);
    178. 

  178. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_client_normal_buffered', $info, $expected, $test_counter);
    179. 

  179. 	mysqli_get_client_stats_assert_eq('rows_buffered_from_client_normal', $info, $expected, $test_counter);
    180. 

  180. 

  181. 	$num_rows = $row['_num'];
    182. 

  182. 	mysqli_free_result($res);
    183. 

  183. 

  184. 	print "Testing buffered normal... - SELECT id, label FROM test_mysqli_get_client_stats_table_1\n";
    185. 

  185. 	if (!$res = mysqli_query($link, 'SELECT id, label FROM test_mysqli_get_client_stats_table_1', MYSQLI_STORE_RESULT))
    186. 

  186. 		printf("[%03d] SELECT id, label FROM test_mysqli_get_client_stats_table_1 failed, [%d] %s\n",
    187. 

  187. 			++$test_counter, mysqli_errno($link), mysqli_error($link));
    188. 

  188. 

  189. 

  190. 	assert(mysqli_num_rows($res) == $num_rows);
    191. 

  191. 

  192. 	if (!is_array($info = mysqli_get_client_stats()) || empty($info))
    193. 

  193. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    194. 

  194. 			++$test_counter, gettype($info), $info);
    195. 

  195. 

  196. 

  197. 	$expected['rows_fetched_from_server_normal'] = (string)($expected['rows_fetched_from_server_normal'] + $num_rows);
    198. 

  198. 	$expected['rows_buffered_from_client_normal'] = (string)($expected['rows_buffered_from_client_normal'] + $num_rows);
    199. 

  199. 	$expected['buffered_sets'] = (string)($expected['buffered_sets'] + 1);
    200. 

  200. 	$expected['result_set_queries'] = (string)($expected['result_set_queries'] + 1);
    201. 

  201. 

  202. 	mysqli_get_client_stats_assert_eq('bytes_received_real_data_normal', $info, $expected, $test_counter);
    203. 

  203. 

  204. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_server_normal', $info, $expected, $test_counter);
    205. 

  205. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_client_normal_buffered', $info, $expected, $test_counter);
    206. 

  206. 	mysqli_get_client_stats_assert_eq('buffered_sets', $info, $expected, $test_counter);
    207. 

  207. 	mysqli_get_client_stats_assert_eq('result_set_queries', $info, $expected, $test_counter);
    208. 

  208. 	mysqli_get_client_stats_assert_eq('rows_buffered_from_client_normal', $info, $expected, $test_counter);
    209. 

  209. 	mysqli_get_client_stats_assert_eq('rows_buffered_from_client_normal', $info, $expected, $test_counter);
    210. 

  210. 

  211. 	/* fetching none, but stats should not be affected - current implementation */
    212. 

  212. 	mysqli_free_result($res);
    213. 

  213. 

  214. 	if (!is_array($info = mysqli_get_client_stats()) || empty($info))
    215. 

  215. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    216. 

  216. 			++$test_counter, gettype($info), $info);
    217. 

  217. 

  218. 

  219. 	mysqli_get_client_stats_assert_eq('bytes_received_real_data_normal', $info, $expected, $test_counter);
    220. 

  220. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_server_normal', $info, $expected, $test_counter);
    221. 

  221. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_client_normal_buffered', $info, $expected, $test_counter);
    222. 

  222. 

  223. 	print "Testing unbuffered normal...\n";
    224. 

  224. 	if (!$res = mysqli_query($link, 'SELECT id, label FROM test_mysqli_get_client_stats_table_1', MYSQLI_USE_RESULT))
    225. 

  225. 		printf("[%03d] SELECT id, label FROM test_mysqli_get_client_stats_table_1 failed, [%d] %s\n",
    226. 

  226. 			++$test_counter, mysqli_errno($link), mysqli_error($link));
    227. 

  227. 

  228. 	if (!is_array($info = mysqli_get_client_stats()) || empty($info))
    229. 

  229. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    230. 

  230. 			++$test_counter, gettype($info), $info);
    231. 

  231. 

  232. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_server_normal', $info, $expected, $test_counter);
    233. 

  233. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_client_normal_unbuffered', $info, $expected, $test_counter);
    234. 

  234. 	mysqli_get_client_stats_assert_eq('bytes_received_real_data_normal', $info, $expected, $test_counter);
    235. 

  235. 

  236. 	while ($row = mysqli_fetch_assoc($res))
    237. 

  237. 		;
    238. 

  238. 	mysqli_free_result($res);
    239. 

  239. 

  240. 	$expected['rows_fetched_from_server_normal'] = (string)($expected['rows_fetched_from_server_normal'] + $num_rows);
    241. 

  241. 	$expected['rows_fetched_from_client_normal_unbuffered'] = (string)($expected['rows_fetched_from_client_normal_unbuffered'] + $num_rows);
    242. 

  242. 	$expected['unbuffered_sets'] = (string)($expected['unbuffered_sets'] + 1);
    243. 

  243. 	$expected['result_set_queries'] = (string)($expected['result_set_queries'] + 1);
    244. 

  244. 

  245. 	if (!is_array($info = mysqli_get_client_stats()) || empty($info))
    246. 

  246. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    247. 

  247. 			++$test_counter, gettype($info), $info);
    248. 

  248. 

  249. 	mysqli_get_client_stats_assert_gt('bytes_received_real_data_normal', $info, $expected, $test_counter);
    250. 

  250. 	$expected['bytes_received_real_data_normal'] = $info['bytes_received_real_data_normal'];
    251. 

  251. 

  252. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_server_normal', $info, $expected, $test_counter);
    253. 

  253. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_client_normal_unbuffered', $info, $expected, $test_counter);
    254. 

  254. 	mysqli_get_client_stats_assert_eq('unbuffered_sets', $info, $expected, $test_counter);
    255. 

  255. 	mysqli_get_client_stats_assert_eq('result_set_queries', $info, $expected, $test_counter);
    256. 

  256. 

  257. 	print "Testing unbuffered normal... - SELECT id, label FROM test_mysqli_get_client_stats_table_1, not all fetched\n";
    258. 

  258. 	if (!$res = mysqli_query($link, 'SELECT id, label FROM test_mysqli_get_client_stats_table_1', MYSQLI_USE_RESULT))
    259. 

  259. 		printf("[%03d] SELECT id, label FROM test_mysqli_get_client_stats_table_1 failed, [%d] %s\n",
    260. 

  260. 			++$test_counter, mysqli_errno($link), mysqli_error($link));
    261. 

  261. 

  262. 	for ($i = 0; $i < $num_rows - 1; $i++)
    263. 

  263. 		$row = mysqli_fetch_assoc($res);
    264. 

  264. 

  265. 	$expected['rows_fetched_from_server_normal'] = (string)($expected['rows_fetched_from_server_normal'] + $num_rows - 1);
    266. 

  266. 	$expected['rows_fetched_from_client_normal_unbuffered'] = (string)($expected['rows_fetched_from_client_normal_unbuffered'] + $num_rows - 1);
    267. 

  267. 	$expected['unbuffered_sets'] = (string)($expected['unbuffered_sets'] + 1);
    268. 

  268. 	$expected['result_set_queries'] = (string)($expected['result_set_queries'] + 1);
    269. 

  269. 

  270. 	if (!is_array($info = mysqli_get_client_stats()) || empty($info))
    271. 

  271. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    272. 

  272. 			++$test_counter, gettype($info), $info);
    273. 

  273. 

  274. 	mysqli_get_client_stats_assert_gt('bytes_received_real_data_normal', $info, $expected, $test_counter);
    275. 

  275. 	$expected['bytes_received_real_data_normal'] = $info['bytes_received_real_data_normal'];
    276. 

  276. 

  277. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_server_normal', $info, $expected, $test_counter);
    278. 

  278. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_client_normal_unbuffered', $info, $expected, $test_counter);
    279. 

  279. 	mysqli_get_client_stats_assert_eq('unbuffered_sets', $info, $expected, $test_counter);
    280. 

  280. 	mysqli_get_client_stats_assert_eq('result_set_queries', $info, $expected, $test_counter);
    281. 

  281. 

  282. 	print "Testing if implicit fetching and cleaning happens...\n";
    283. 

  283. 	mysqli_free_result($res);
    284. 

  284. 

  285. 	/* last row has been implicitly cleaned from the wire by freeing the result set */
    286. 

  286. 	$expected['rows_fetched_from_server_normal'] = (string)($expected['rows_fetched_from_server_normal'] + 1);
    287. 

  287. 	$expected['rows_fetched_from_client_normal_unbuffered'] = (string)($expected['rows_fetched_from_client_normal_unbuffered'] + 1);
    288. 

  288. 	$expected['rows_skipped_normal'] = (string)($info['rows_skipped_normal'] + 1);
    289. 

  289. 	$expected['flushed_normal_sets'] = (string)($expected['flushed_normal_sets'] + 1);
    290. 

  290. 

  291. 	if (!is_array($info = mysqli_get_client_stats()) || empty($info))
    292. 

  292. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    293. 

  293. 			++$test_counter, gettype($info), $info);
    294. 

  294. 

  295. 	mysqli_get_client_stats_assert_eq('bytes_received_real_data_normal', $info, $expected, $test_counter);
    296. 

  296. 

  297. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_server_normal', $info, $expected, $test_counter);
    298. 

  298. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_client_normal_unbuffered', $info, $expected, $test_counter);
    299. 

  299. 	mysqli_get_client_stats_assert_eq('rows_skipped_normal', $info, $expected, $test_counter);
    300. 

  300. 	mysqli_get_client_stats_assert_eq('flushed_normal_sets', $info, $expected, $test_counter);
    301. 

  301. 

  302. 	print "Testing buffered Prepared Statements...\n";
    303. 

  303. 	if (!$stmt = mysqli_stmt_init($link))
    304. 

  304. 		printf("[%03d] stmt_init() failed, [%d] %s\n",
    305. 

  305. 			++$test_counter, mysqli_errno($link), mysqli_error($link));
    306. 

  306. 

  307. 	if (!mysqli_stmt_prepare($stmt, 'SELECT id, label FROM test_mysqli_get_client_stats_table_1') ||
    308. 

  308. 			!mysqli_stmt_execute($stmt))
    309. 

  309. 		printf("[%03d] prepare/execute failed, [%d] %s\n",
    310. 

  310. 			++$test_counter, mysqli_stmt_errno($stmt), mysqli_stmt_error($stmt));
    311. 

  311. 

  312. 	/* by default PS is unbuffered - no change */
    313. 

  313. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_server_ps', $info, $expected, $test_counter);
    314. 

  314. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_client_ps_buffered', $info, $expected, $test_counter);
    315. 

  315. 

  316. 	if (!mysqli_stmt_store_result($stmt))
    317. 

  317. 		printf("[%03d] store_result failed, [%d] %s\n",
    318. 

  318. 			++$test_counter, mysqli_stmt_errno($stmt), mysqli_stmt_error($stmt));
    319. 

  319. 	mysqli_stmt_free_result($stmt);
    320. 

  320. 

  321. 	mysqli_get_client_stats_assert_eq('bytes_received_real_data_ps', $info, "0", $test_counter);
    322. 

  322. 	mysqli_get_client_stats_assert_eq('bytes_received_real_data_normal', $info, $expected, $test_counter);
    323. 

  323. 

  324. 	$expected['rows_fetched_from_server_ps'] = (string)($expected['rows_fetched_from_server_ps'] + $num_rows);
    325. 

  325. 	$expected['result_set_queries'] = (string)($expected['result_set_queries'] + 1);
    326. 

  326. 	$expected['ps_buffered_sets'] = (string)($expected['ps_buffered_sets'] + 1);
    327. 

  327. 	$expected['rows_buffered_from_client_ps'] = (string)($expected['rows_buffered_from_client_ps'] + $num_rows);
    328. 

  328. 

  329. 

  330. 	if (!is_array($info = mysqli_get_client_stats()) || empty($info))
    331. 

  331. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    332. 

  332. 			++$test_counter, gettype($info), $info);
    333. 

  333. 

  334. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_server_ps', $info, $expected, $test_counter);
    335. 

  335. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_client_ps_buffered', $info, $expected, $test_counter);
    336. 

  336. 	mysqli_get_client_stats_assert_eq('result_set_queries', $info, $expected, $test_counter);
    337. 

  337. 	mysqli_get_client_stats_assert_eq('ps_buffered_sets', $info, $expected, $test_counter);
    338. 

  338. 	mysqli_get_client_stats_assert_eq('rows_buffered_from_client_ps', $info, $expected, $test_counter);
    339. 

  339. 

  340. 	mysqli_get_client_stats_assert_eq('bytes_received_real_data_ps', $info, "0", $test_counter);
    341. 

  341. 

  342. 	print "Testing buffered Prepared Statements... - fetching all\n";
    343. 

  343. 

  344. 	if (!mysqli_stmt_prepare($stmt, 'SELECT id, label FROM test_mysqli_get_client_stats_table_1') ||
    345. 

  345. 			!mysqli_stmt_execute($stmt))
    346. 

  346. 		printf("[%03d] prepare/execute failed, [%d] %s\n",
    347. 

  347. 			++$test_counter, mysqli_stmt_errno($stmt), mysqli_stmt_error($stmt));
    348. 

  348. 

  349. 	$id = $label = null;
    350. 

  350. 	if (!mysqli_stmt_bind_result($stmt, $id, $label))
    351. 

  351. 		printf("[%03d] bind_result failed, [%d] %s\n",
    352. 

  352. 			++$test_counter, mysqli_stmt_errno($stmt), mysqli_stmt_error($stmt));
    353. 

  353. 

  354. 	if (!mysqli_stmt_store_result($stmt))
    355. 

  355. 		printf("[%03d] store_result failed, [%d] %s\n",
    356. 

  356. 			++$test_counter, mysqli_stmt_errno($stmt), mysqli_stmt_error($stmt));
    357. 

  357. 

  358. 	while (mysqli_stmt_fetch($stmt))
    359. 

  359. 		;
    360. 

  360. 

  361. 	$expected['rows_fetched_from_server_ps'] = (string)($expected['rows_fetched_from_server_ps'] + $num_rows);
    362. 

  362. 	$expected['rows_fetched_from_client_ps_buffered'] = (string)($expected['rows_fetched_from_client_ps_buffered'] + $num_rows);
    363. 

  363. 	$expected['result_set_queries'] = (string)($expected['result_set_queries'] + 1);
    364. 

  364. 	$expected['ps_buffered_sets'] = (string)($expected['ps_buffered_sets'] + 1);
    365. 

  365. 	$expected['rows_buffered_from_client_ps'] = (string)($expected['rows_buffered_from_client_ps'] + $num_rows);
    366. 

  366. 

  367. 	if (!is_array($info = mysqli_get_client_stats()) || empty($info))
    368. 

  368. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    369. 

  369. 			++$test_counter, gettype($info), $info);
    370. 

  370. 

  371. 

  372. 	mysqli_get_client_stats_assert_gt('bytes_received_real_data_ps', $info, $expected, $test_counter);
    373. 

  373. 	$expected['bytes_received_real_data_ps'] = $info['bytes_received_real_data_ps'];
    374. 

  374. 

  375. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_server_ps', $info, $expected, $test_counter);
    376. 

  376. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_client_ps_buffered', $info, $expected, $test_counter);
    377. 

  377. 	mysqli_get_client_stats_assert_eq('result_set_queries', $info, $expected, $test_counter);
    378. 

  378. 	mysqli_get_client_stats_assert_eq('ps_buffered_sets', $info, $expected, $test_counter);
    379. 

  379. 	mysqli_get_client_stats_assert_eq('rows_buffered_from_client_ps', $info, $expected, $test_counter);
    380. 

  380. 

  381. 	mysqli_stmt_free_result($stmt);
    382. 

  382. 

  383. 	print "Testing buffered Prepared Statements... - fetching all but one\n";
    384. 

  384. 

  385. 	if (!mysqli_stmt_prepare($stmt, 'SELECT id, label FROM test_mysqli_get_client_stats_table_1') ||
    386. 

  386. 			!mysqli_stmt_execute($stmt))
    387. 

  387. 		printf("[%03d] prepare/execute failed, [%d] %s\n",
    388. 

  388. 			++$test_counter, mysqli_stmt_errno($stmt), mysqli_stmt_error($stmt));
    389. 

  389. 

  390. 	$id = $label = null;
    391. 

  391. 	if (!mysqli_stmt_bind_result($stmt, $id, $label))
    392. 

  392. 		printf("[%03d] bind_result failed, [%d] %s\n",
    393. 

  393. 			++$test_counter, mysqli_stmt_errno($stmt), mysqli_stmt_error($stmt));
    394. 

  394. 

  395. 	if (!mysqli_stmt_store_result($stmt))
    396. 

  396. 		printf("[%03d] store_result failed, [%d] %s\n",
    397. 

  397. 			++$test_counter, mysqli_stmt_errno($stmt), mysqli_stmt_error($stmt));
    398. 

  398. 

  399. 	for ($i = 0; $i < $num_rows - 1; $i++)
    400. 

  400. 		mysqli_stmt_fetch($stmt);
    401. 

  401. 

  402. 	$expected['rows_fetched_from_server_ps'] = (string)($expected['rows_fetched_from_server_ps'] + $num_rows);
    403. 

  403. 	$expected['rows_fetched_from_client_ps_buffered'] = (string)($expected['rows_fetched_from_client_ps_buffered'] + $num_rows - 1);
    404. 

  404. 	$expected['result_set_queries'] = (string)($expected['result_set_queries'] + 1);
    405. 

  405. 	$expected['ps_buffered_sets'] = (string)($expected['ps_buffered_sets'] + 1);
    406. 

  406. 	$expected['rows_buffered_from_client_ps'] = (string)($expected['rows_buffered_from_client_ps'] + $num_rows);
    407. 

  407. 

  408. 	if (!is_array($info = mysqli_get_client_stats()) || empty($info))
    409. 

  409. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    410. 

  410. 			++$test_counter, gettype($info), $info);
    411. 

  411. 

  412. 	mysqli_get_client_stats_assert_gt('bytes_received_real_data_ps', $info, $expected, $test_counter);
    413. 

  413. 	$expected['bytes_received_real_data_ps'] = $info['bytes_received_real_data_ps'];
    414. 

  414. 

  415. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_server_ps', $info, $expected, $test_counter);
    416. 

  416. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_client_ps_buffered', $info, $expected, $test_counter);
    417. 

  417. 	mysqli_get_client_stats_assert_eq('result_set_queries', $info, $expected, $test_counter);
    418. 

  418. 	mysqli_get_client_stats_assert_eq('ps_buffered_sets', $info, $expected, $test_counter);
    419. 

  419. 	mysqli_get_client_stats_assert_eq('rows_buffered_from_client_ps', $info, $expected, $test_counter);
    420. 

  420. 

  421. 	$expected['rows_skipped_ps'] = $info['rows_skipped_ps'];
    422. 

  422. 	mysqli_stmt_free_result($stmt);
    423. 

  423. 

  424. 	if (!is_array($info = mysqli_get_client_stats()) || empty($info))
    425. 

  425. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    426. 

  426. 			++$test_counter, gettype($info), $info);
    427. 

  427. 

  428. 	/* buffered result set - no skipping possible! */
    429. 

  429. 	mysqli_get_client_stats_assert_eq('rows_skipped_ps', $info, $expected, $test_counter);
    430. 

  430. 

  431. 	print "Testing unbuffered Prepared Statements... - fetching all\n";
    432. 

  432. 

  433. 	if (!mysqli_stmt_prepare($stmt, 'SELECT id, label FROM test_mysqli_get_client_stats_table_1') ||
    434. 

  434. 			!mysqli_stmt_execute($stmt))
    435. 

  435. 		printf("[%03d] prepare/execute failed, [%d] %s\n",
    436. 

  436. 			++$test_counter, mysqli_stmt_errno($stmt), mysqli_stmt_error($stmt));
    437. 

  437. 

  438. 	$id = $label = null;
    439. 

  439. 	if (!mysqli_stmt_bind_result($stmt, $id, $label))
    440. 

  440. 		printf("[%03d] bind_result failed, [%d] %s\n",
    441. 

  441. 			++$test_counter, mysqli_stmt_errno($stmt), mysqli_stmt_error($stmt));
    442. 

  442. 

  443. 	$i = 0;
    444. 

  444. 	while (mysqli_stmt_fetch($stmt))
    445. 

  445. 		$i++;
    446. 

  446. 	assert($num_rows = $i);
    447. 

  447. 

  448. 	$expected['rows_fetched_from_server_ps'] = (string)($expected['rows_fetched_from_server_ps'] + $num_rows);
    449. 

  449. 	$expected['rows_fetched_from_client_ps_unbuffered'] = (string)($expected['rows_fetched_from_client_ps_unbuffered'] + $num_rows);
    450. 

  450. 	$expected['result_set_queries'] = (string)($expected['result_set_queries'] + 1);
    451. 

  451. 	$expected['ps_unbuffered_sets'] = (string)($expected['ps_unbuffered_sets'] + 1);
    452. 

  452. 

  453. 	if (!is_array($info = mysqli_get_client_stats()) || empty($info))
    454. 

  454. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    455. 

  455. 			++$test_counter, gettype($info), $info);
    456. 

  456. 

  457. 	mysqli_get_client_stats_assert_gt('bytes_received_real_data_ps', $info, $expected, $test_counter);
    458. 

  458. 	$expected['bytes_received_real_data_ps'] = $info['bytes_received_real_data_ps'];
    459. 

  459. 

  460. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_server_ps', $info, $expected, $test_counter);
    461. 

  461. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_client_ps_unbuffered', $info, $expected, $test_counter);
    462. 

  462. 	mysqli_get_client_stats_assert_eq('result_set_queries', $info, $expected, $test_counter);
    463. 

  463. 	mysqli_get_client_stats_assert_eq('ps_unbuffered_sets', $info, $expected, $test_counter);
    464. 

  464. 	mysqli_get_client_stats_assert_eq('rows_buffered_from_client_ps', $info, $expected, $test_counter);
    465. 

  465. 

  466. 	mysqli_stmt_free_result($stmt);
    467. 

  467. 

  468. 	print "Testing unbuffered Prepared Statements... - fetching all but one\n";
    469. 

  469. 

  470. 	if (!mysqli_stmt_prepare($stmt, 'SELECT id, label FROM test_mysqli_get_client_stats_table_1') ||
    471. 

  471. 			!mysqli_stmt_execute($stmt))
    472. 

  472. 		printf("[%03d] prepare/execute failed, [%d] %s\n",
    473. 

  473. 			++$test_counter, mysqli_stmt_errno($stmt), mysqli_stmt_error($stmt));
    474. 

  474. 

  475. 	$id = $label = null;
    476. 

  476. 	if (!mysqli_stmt_bind_result($stmt, $id, $label))
    477. 

  477. 		printf("[%03d] bind_result failed, [%d] %s\n",
    478. 

  478. 			++$test_counter, mysqli_stmt_errno($stmt), mysqli_stmt_error($stmt));
    479. 

  479. 

  480. 	for ($i = 0; $i < $num_rows - 1; $i++)
    481. 

  481. 		mysqli_stmt_fetch($stmt);
    482. 

  482. 

  483. 	$expected['rows_fetched_from_server_ps'] = (string)($expected['rows_fetched_from_server_ps'] + $num_rows - 1);
    484. 

  484. 	$expected['rows_fetched_from_client_ps_unbuffered'] = (string)($expected['rows_fetched_from_client_ps_unbuffered'] + $num_rows - 1);
    485. 

  485. 	$expected['result_set_queries'] = (string)($expected['result_set_queries'] + 1);
    486. 

  486. 	$expected['ps_unbuffered_sets'] = (string)($expected['ps_unbuffered_sets'] + 1);
    487. 

  487. 

  488. 	if (!is_array($info = mysqli_get_client_stats()) || empty($info))
    489. 

  489. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    490. 

  490. 			++$test_counter, gettype($info), $info);
    491. 

  491. 

  492. 	mysqli_get_client_stats_assert_gt('bytes_received_real_data_ps', $info, $expected, $test_counter);
    493. 

  493. 	$expected['bytes_received_real_data_ps'] = $info['bytes_received_real_data_ps'];
    494. 

  494. 

  495. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_server_ps', $info, $expected, $test_counter);
    496. 

  496. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_client_ps_unbuffered', $info, $expected, $test_counter);
    497. 

  497. 	mysqli_get_client_stats_assert_eq('result_set_queries', $info, $expected, $test_counter);
    498. 

  498. 	mysqli_get_client_stats_assert_eq('ps_unbuffered_sets', $info, $expected, $test_counter);
    499. 

  499. 	mysqli_get_client_stats_assert_eq('rows_buffered_from_client_ps', $info, $expected, $test_counter);
    500. 

  500. 

  501. 	mysqli_stmt_free_result($stmt);
    502. 

  502. 	$expected['rows_skipped_ps'] = (string)($expected['rows_skipped_ps'] + 1);
    503. 

  503. 	$expected['flushed_ps_sets'] = (string)($expected['flushed_ps_sets'] + 1);
    504. 

  504. 	$expected['rows_fetched_from_server_ps'] = (string)($expected['rows_fetched_from_server_ps'] + 1);
    505. 

  505. 

  506. 	if (!is_array($info = mysqli_get_client_stats()) || empty($info))
    507. 

  507. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    508. 

  508. 			++$test_counter, gettype($info), $info);
    509. 

  509. 

  510. 	mysqli_get_client_stats_assert_eq('bytes_received_real_data_ps', $info, $expected, $test_counter);
    511. 

  511. 

  512. 	mysqli_get_client_stats_assert_eq('rows_skipped_ps', $info, $expected, $test_counter);
    513. 

  513. 	mysqli_get_client_stats_assert_eq('flushed_ps_sets', $info, $expected, $test_counter);
    514. 

  514. 	mysqli_get_client_stats_assert_eq('rows_fetched_from_server_ps', $info, $expected, $test_counter);
    515. 

  515. 

  516. 	/*
    517. 

  517. 	print "Checking for normal buffered side effects...\n";
    518. 

  518. 	foreach ($info as $k => $v)
    519. 

  519. 		if ($info[$k] != $expected[$k])
    520. 

  520. 			printf("$k - $v != %s\n", $expected[$k]);
    521. 

  521. 	*/
    522. 

  522. 	print "... done with fetch statistics\n";
    523. 

  523. 

  524. 	if (!is_array($info = mysqli_get_client_stats()) || empty($info))
    525. 

  525. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    526. 

  526. 			++$test_counter, gettype($info), $info);
    527. 

  527. 

  528. 	mysqli_get_client_stats_assert_eq('bytes_received_real_data_normal', $info, $expected, $test_counter);
    529. 

  529. 	mysqli_get_client_stats_assert_eq('bytes_received_real_data_ps', $info, $expected, $test_counter);
    530. 

  530. 

  531. 	//
    532. 

  532. 	// result_set_queries statistics
    533. 

  533. 	//
    534. 

  534. 

  535. 	if (!is_array($info = mysqli_get_client_stats()) || empty($info))
    536. 

  536. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    537. 

  537. 			++$test_counter, gettype($info), $info);
    538. 

  538. 

  539. 	if (!$res = mysqli_query($link, "SELECT id, label FROM test_mysqli_get_client_stats_table_1"))
    540. 

  540. 		printf("[%03d] SELECT failed, [%d] %s\n", ++$test_counter,
    541. 

  541. 			mysqli_errno($link), mysqli_error($link));
    542. 

  542. 

  543. 	$rows = 0;
    544. 

  544. 	while ($row = mysqli_fetch_assoc($res))
    545. 

  545. 		$rows++;
    546. 

  546. 

  547. 	if (0 == $rows)
    548. 

  548. 		printf("[%03d] Expecting at least one result, [%d] %s\n", ++$test_counter,
    549. 

  549. 			mysqli_errno($link), mysqli_error($link));
    550. 

  550. 

  551. 	mysqli_free_result($res);
    552. 

  552. 

  553. 	if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    554. 

  554. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    555. 

  555. 			++$test_counter, gettype($new_info), $new_info);
    556. 

  556. 

  557. 	mysqli_get_client_stats_assert_eq('result_set_queries', $new_info, (string)($info['result_set_queries'] + 1), $test_counter);
    558. 

  558. 	$info = $new_info;
    559. 

  559. 

  560. 	mysqli_get_client_stats_assert_gt('bytes_received_real_data_normal', $info, $expected, $test_counter);
    561. 

  561. 	$expected['bytes_received_real_data_normal'] = $info['bytes_received_real_data_normal'];
    562. 

  562. 

  563. 	//
    564. 

  564. 	// non_result_set_queries - DDL
    565. 

  565. 	//
    566. 

  566. 

  567. 	// CREATE TABLE, DROP TABLE
    568. 

  568. 	if (!mysqli_query($link, "DROP TABLE IF EXISTS non_result_set_queries_test"))
    569. 

  569. 		printf("[%03d] DROP TABLE failed, [%d] %s\n", ++$test_counter,
    570. 

  570. 			mysqli_errno($link), mysqli_error($link));
    571. 

  571. 

  572. 	if (!mysqli_query($link, "CREATE TABLE non_result_set_queries_test(id INT) ENGINE = " . $engine)) {
    573. 

  573. 		printf("[%03d] CREATE TABLE failed, [%d] %s\n", ++$test_counter,
    574. 

  574. 			mysqli_errno($link), mysqli_error($link));
    575. 

  575. 	} else {
    576. 

  576. 		if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    577. 

  577. 			printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    578. 

  578. 			++$test_counter, gettype($new_info), $new_info);
    579. 

  579. 		mysqli_get_client_stats_assert_eq('non_result_set_queries', $new_info, (string)($info['non_result_set_queries'] + 2), $test_counter, 'CREATE/DROP TABLE');
    580. 

  580. 	}
    581. 

  581. 	$info = $new_info;
    582. 

  582. 

  583. 	// ALERT TABLE
    584. 

  584. 	if (!mysqli_query($link, "ALTER TABLE non_result_set_queries_test ADD label CHAR(1)")) {
    585. 

  585. 		printf("[%03d] ALTER TABLE failed, [%d] %s\n", ++$test_counter,
    586. 

  586. 			mysqli_errno($link), mysqli_error($link));
    587. 

  587. 	} else {
    588. 

  588. 		if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    589. 

  589. 			printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    590. 

  590. 				++$test_counter, gettype($new_info), $new_info);
    591. 

  591. 		mysqli_get_client_stats_assert_eq('non_result_set_queries', $new_info, (string)($info['non_result_set_queries'] + 1), $test_counter, 'ALTER TABLE');
    592. 

  592. 	}
    593. 

  593. 	$info = $new_info;
    594. 

  594. 

  595. 	// CREATE INDEX, DROP INDEX
    596. 

  596. 	if (!mysqli_query($link, "CREATE INDEX idx_1 ON non_result_set_queries_test(id)")) {
    597. 

  597. 		printf("[%03d] CREATE INDEX failed, [%d] %s\n", ++$test_counter,
    598. 

  598. 			mysqli_errno($link), mysqli_error($link));
    599. 

  599. 	} else {
    600. 

  600. 

  601. 		if (!mysqli_query($link, "DROP INDEX idx_1 ON non_result_set_queries_test"))
    602. 

  602. 			printf("[%03d] DROP INDEX failed, [%d] %s\n", ++$test_counter,
    603. 

  603. 				mysqli_errno($link), mysqli_error($link));
    604. 

  604. 

  605. 		if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    606. 

  606. 			printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    607. 

  607. 				++$test_counter, gettype($new_info), $new_info);
    608. 

  608. 		mysqli_get_client_stats_assert_eq('non_result_set_queries', $new_info, (string)($info['non_result_set_queries'] + 2), $test_counter, 'DROP INDEX');
    609. 

  609. 	}
    610. 

  610. 	$info = $new_info;
    611. 

  611. 

  612. 	// RENAME TABLE
    613. 

  613. 	if (!mysqli_query($link, "DROP TABLE IF EXISTS client_stats_test"))
    614. 

  614. 		printf("[%03d] Cleanup, DROP TABLE client_stats_test failed, [%d] %s\n", ++$test_counter,
    615. 

  615. 			mysqli_errno($link), mysqli_error($link));
    616. 

  616. 

  617. 	if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    618. 

  618. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    619. 

  619. 			++$test_counter, gettype($new_info), $new_info);
    620. 

  620. 	$info = $new_info;
    621. 

  621. 

  622. 	if (!mysqli_query($link, "RENAME TABLE non_result_set_queries_test TO client_stats_test")) {
    623. 

  623. 		printf("[%03d] RENAME TABLE failed, [%d] %s\n", ++$test_counter,
    624. 

  624. 			mysqli_errno($link), mysqli_error($link));
    625. 

  625. 

  626. 	} else {
    627. 

  627. 		if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    628. 

  628. 			printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    629. 

  629. 				++$test_counter, gettype($new_info), $new_info);
    630. 

  630. 		mysqli_get_client_stats_assert_eq('non_result_set_queries', $new_info, (string)($info['non_result_set_queries'] + 1), $test_counter, 'RENAME TABLE');
    631. 

  631. 

  632. 	}
    633. 

  633. 	$info = $new_info;
    634. 

  634. 

  635. 	if (!mysqli_query($link, "DROP TABLE IF EXISTS non_result_set_queries_test"))
    636. 

  636. 		printf("[%03d] Cleanup, DROP TABLE failed, [%d] %s\n", ++$test_counter,
    637. 

  637. 			mysqli_errno($link), mysqli_error($link));
    638. 

  638. 

  639. 	if (!mysqli_query($link, "DROP TABLE IF EXISTS client_stats_test"))
    640. 

  640. 		printf("[%03d] Cleanup, DROP TABLE failed, [%d] %s\n", ++$test_counter,
    641. 

  641. 			mysqli_errno($link), mysqli_error($link));
    642. 

  642. 

  643. 	// Let's see if we have privileges for CREATE DATABASE
    644. 

  644. 	mysqli_query($link, "DROP DATABASE IF EXISTS mysqli_get_client_stats");
    645. 

  645. 	if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    646. 

  646. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    647. 

  647. 			++$test_counter, gettype($new_info), $new_info);
    648. 

  648. 	$info = $new_info;
    649. 

  649. 

  650. 

  651. 	// CREATE, ALTER, RENAME, DROP DATABASE
    652. 

  652. 	if (mysqli_query($link, "CREATE DATABASE mysqli_get_client_stats")) {
    653. 

  653. 

  654. 		if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    655. 

  655. 			printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    656. 

  656. 				++$test_counter, gettype($new_info), $new_info);
    657. 

  657. 		mysqli_get_client_stats_assert_eq('non_result_set_queries', $new_info, (string)($info['non_result_set_queries'] + 1), $test_counter, 'CREATE DATABASE');
    658. 

  658. 		$info = $new_info;
    659. 

  659. 

  660. 		if (!mysqli_query($link, "ALTER DATABASE DEFAULT CHARACTER SET latin1"))
    661. 

  661. 			printf("[%03d] ALTER DATABASE failed, [%d] %s\n", ++$test_counter,
    662. 

  662. 				mysqli_errno($link), mysqli_error($link));
    663. 

  663. 

  664. 		if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    665. 

  665. 			printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    666. 

  666. 				++$test_counter, gettype($new_info), $new_info);
    667. 

  667. 		mysqli_get_client_stats_assert_eq('non_result_set_queries', $new_info, (string)($info['non_result_set_queries'] + 1), $test_counter, 'CREATE DATABASE');
    668. 

  668. 		$info = $new_info;
    669. 

  669. 

  670. 		if (mysqli_get_server_version($link) > 51700) {
    671. 

  671. 			if (!mysqli_query($link, "RENAME DATABASE mysqli_get_client_stats TO mysqli_get_client_stats_"))
    672. 

  672. 				printf("[%03d] RENAME DATABASE failed, [%d] %s\n", ++$test_counter,
    673. 

  673. 					mysqli_errno($link), mysqli_error($link));
    674. 

  674. 

  675. 			if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    676. 

  676. 				printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    677. 

  677. 					++$test_counter, gettype($new_info), $new_info);
    678. 

  678. 			mysqli_get_client_stats_assert_eq('non_result_set_queries', $new_info, (string)($info['non_result_set_queries'] + 1), $test_counter, 'CREATE DATABASE');
    679. 

  679. 			$info = $new_info;
    680. 

  680. 		} else {
    681. 

  681. 			if (!mysqli_query($link, "CREATE DATABASE mysqli_get_client_stats_"))
    682. 

  682. 				printf("[%03d] CREATE DATABASE failed, [%d] %s\n", ++$test_counter,
    683. 

  683. 					mysqli_errno($link), mysqli_error($link));
    684. 

  684. 			if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    685. 

  685. 				printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    686. 

  686. 					++$test_counter, gettype($new_info), $new_info);
    687. 

  687. 			$info = $new_info;
    688. 

  688. 		}
    689. 

  689. 

  690. 		if (!mysqli_query($link, "DROP DATABASE mysqli_get_client_stats_"))
    691. 

  691. 			printf("[%03d] DROP DATABASE failed, [%d] %s\n", ++$test_counter,
    692. 

  692. 				mysqli_errno($link), mysqli_error($link));
    693. 

  693. 

  694. 		if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    695. 

  695. 			printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    696. 

  696. 				++$test_counter, gettype($new_info), $new_info);
    697. 

  697. 		mysqli_get_client_stats_assert_eq('non_result_set_queries', $new_info, (string)($info['non_result_set_queries'] + 1), $test_counter, 'DROP DATABASE');
    698. 

  698. 		$info = $new_info;
    699. 

  699. 	}
    700. 

  700. 

  701. 	// CREATE SERVER, ALTER SERVER, DROP SERVER
    702. 

  702. 	// We don't really try to use federated, we just want to see if the syntax works
    703. 

  703. 	mysqli_query($link, "DROP SERVER IF EXISTS myself");
    704. 

  704. 

  705. 	if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    706. 

  706. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    707. 

  707. 			++$test_counter, gettype($new_info), $new_info);
    708. 

  708. 	$info = $new_info;
    709. 

  709. 

  710. 	$sql = sprintf("CREATE SERVER myself FOREIGN DATA WRAPPER mysql OPTIONS (user '%s', password '%s', database '%s')",
    711. 

  711. 		$user, $passwd, $db);
    712. 

  712. 	if (mysqli_query($link, $sql)) {
    713. 

  713. 		// server knows about it
    714. 

  714. 

  715. 		if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    716. 

  716. 			printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    717. 

  717. 				++$test_counter, gettype($new_info), $new_info);
    718. 

  718. 

  719. 		mysqli_get_client_stats_assert_eq('non_result_set_queries', $new_info, (string)($info['non_result_set_queries'] + 1), $test_counter, 'CREATE SERVER');
    720. 

  720. 		$info = $new_info;
    721. 

  721. 

  722. 		if (!mysqli_query($link, sprintf("ALTER SERVER myself OPTIONS(user '%s_')", $user)))
    723. 

  723. 			printf("[%03d] ALTER SERVER failed, [%d] %s\n", ++$test_counter,
    724. 

  724. 				mysqli_errno($link), mysqli_error($link));
    725. 

  725. 

  726. 		if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    727. 

  727. 			printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    728. 

  728. 				++$test_counter, gettype($new_info), $new_info);
    729. 

  729. 		mysqli_get_client_stats_assert_eq('non_result_set_queries', $new_info, (string)($info['non_result_set_queries'] + 1), $test_counter, 'ALTER SERVER');
    730. 

  730. 		$info = $new_info;
    731. 

  731. 

  732. 		if (!mysqli_query($link, "DROP SERVER myself"))
    733. 

  733. 			printf("[%03d] DROP SERVER failed, [%d] %s\n", ++$test_counter,
    734. 

  734. 				mysqli_errno($link), mysqli_error($link));
    735. 

  735. 

  736. 		if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    737. 

  737. 			printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    738. 

  738. 				++$test_counter, gettype($new_info), $new_info);
    739. 

  739. 		mysqli_get_client_stats_assert_eq('non_result_set_queries', $new_info, (string)($info['non_result_set_queries'] + 1), $test_counter, 'DROP SERVER');
    740. 

  740. 		$info = $new_info;
    741. 

  741. 	}
    742. 

  742. 

  743. 	mysqli_get_client_stats_assert_eq('bytes_received_real_data_normal', $info, $expected, $test_counter);
    744. 

  744. 	mysqli_get_client_stats_assert_eq('bytes_received_real_data_ps', $info, $expected, $test_counter);
    745. 

  745. 

  746. 	/*
    747. 

  747. 	We don't test_mysqli_get_client_stats_table_1 the NDB ones.
    748. 

  748. 	13.1. Data Definition Statements
    749. 

  749. 	13.1.3. ALTER LOGFILE GROUP Syntax
    750. 

  750. 	13.1.4. ALTER TABLESPACE Syntax
    751. 

  751. 	13.1.9. CREATE LOGFILE GROUP Syntax
    752. 

  752. 	13.1.10. CREATE TABLESPACE Syntax
    753. 

  753. 	13.1.15. DROP LOGFILE GROUP Syntax
    754. 

  754. 	13.1.16. DROP TABLESPACE Syntax
    755. 

  755. 	*/
    756. 

  756. 

  757. 	//
    758. 

  758. 	// DML
    759. 

  759. 	//
    760. 

  760. 	if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    761. 

  761. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    762. 

  762. 				++$test_counter, gettype($new_info), $new_info);
    763. 

  763. 	$info = $new_info;
    764. 

  764. 

  765. 	if (!mysqli_query($link, "INSERT INTO test_mysqli_get_client_stats_table_1(id) VALUES (100)"))
    766. 

  766. 		printf("[%03d] INSERT failed, [%d] %s\n", ++$test_counter,
    767. 

  767. 			mysqli_errno($link), mysqli_error($link));
    768. 

  768. 

  769. 	if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    770. 

  770. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    771. 

  771. 			++$test_counter, gettype($new_info), $new_info);
    772. 

  772. 	mysqli_get_client_stats_assert_eq('non_result_set_queries', $new_info, (string)($info['non_result_set_queries'] + 1), $test_counter, 'INSERT');
    773. 

  773. 	$info = $new_info;
    774. 

  774. 

  775. 	if (!mysqli_query($link, "UPDATE test_mysqli_get_client_stats_table_1 SET label ='z' WHERE id = 100"))
    776. 

  776. 		printf("[%03d] UPDATE failed, [%d] %s\n", ++$test_counter,
    777. 

  777. 			mysqli_errno($link), mysqli_error($link));
    778. 

  778. 

  779. 	if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    780. 

  780. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    781. 

  781. 			++$test_counter, gettype($new_info), $new_info);
    782. 

  782. 	mysqli_get_client_stats_assert_eq('non_result_set_queries', $new_info, (string)($info['non_result_set_queries'] + 1), $test_counter, 'UPDATE');
    783. 

  783. 	$info = $new_info;
    784. 

  784. 

  785. 	if (!mysqli_query($link, "REPLACE INTO test_mysqli_get_client_stats_table_1(id, label) VALUES (100, 'b')"))
    786. 

  786. 		printf("[%03d] INSERT failed, [%d] %s\n", ++$test_counter,
    787. 

  787. 			mysqli_errno($link), mysqli_error($link));
    788. 

  788. 

  789. 	if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    790. 

  790. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    791. 

  791. 			++$test_counter, gettype($new_info), $new_info);
    792. 

  792. 	mysqli_get_client_stats_assert_eq('non_result_set_queries', $new_info, (string)($info['non_result_set_queries'] + 1), $test_counter, 'REPLACE');
    793. 

  793. 	$info = $new_info;
    794. 

  794. 

  795. 	// NOTE: this will NOT update dbl_ddls counter
    796. 

  796. 	if (!$res = mysqli_query($link, "SELECT id, label FROM test_mysqli_get_client_stats_table_1 WHERE id = 100"))
    797. 

  797. 		printf("[%03d] SELECT@dml failed, [%d] %s\n", ++$test_counter,
    798. 

  798. 			mysqli_errno($link), mysqli_error($link));
    799. 

  799. 	mysqli_free_result($res);
    800. 

  800. 

  801. 	if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    802. 

  802. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    803. 

  803. 			++$test_counter, gettype($new_info), $new_info);
    804. 

  804. 	mysqli_get_client_stats_assert_eq('non_result_set_queries', $new_info, $info, $test_counter, 'SELECT@dml');
    805. 

  805. 	$info = $new_info;
    806. 

  806. 

  807. 	if (!mysqli_query($link, "DELETE FROM test_mysqli_get_client_stats_table_1 WHERE id = 100"))
    808. 

  808. 		printf("[%03d] DELETE failed, [%d] %s\n", ++$test_counter,
    809. 

  809. 			mysqli_errno($link), mysqli_error($link));
    810. 

  810. 

  811. 	if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    812. 

  812. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    813. 

  813. 			++$test_counter, gettype($new_info), $new_info);
    814. 

  814. 	mysqli_get_client_stats_assert_eq('non_result_set_queries', $new_info, (string)($info['non_result_set_queries'] + 1), $test_counter, 'DELETE');
    815. 

  815. 	$info = $new_info;
    816. 

  816. 

  817. 	if (!$res = mysqli_query($link, "TRUNCATE TABLE test_mysqli_get_client_stats_table_1"))
    818. 

  818. 		printf("[%03d] TRUNCATE failed, [%d] %s\n", ++$test_counter,
    819. 

  819. 			mysqli_errno($link), mysqli_error($link));
    820. 

  820. 

  821. 	if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    822. 

  822. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    823. 

  823. 			++$test_counter, gettype($new_info), $new_info);
    824. 

  824. 	mysqli_get_client_stats_assert_eq('non_result_set_queries', $new_info, (string)($info['non_result_set_queries'] + 1), $test_counter, 'TRUNCATE');
    825. 

  825. 	$info = $new_info;
    826. 

  826. 

  827. 

  828. 	$file = tempnam(sys_get_temp_dir(), 'mysqli_test');
    829. 

  829. 	if ($fp = fopen($file, 'w')) {
    830. 

  830. 		@fwrite($fp, '1;"a"');
    831. 

  831. 		fclose($fp);
    832. 

  832. 		chmod($file, 0644);
    833. 

  833. 		$sql = sprintf('LOAD DATA LOCAL INFILE "%s" INTO TABLE test_mysqli_get_client_stats_table_1', mysqli_real_escape_string($link, $file));
    834. 

  834. 		if (mysqli_query($link, $sql)) {
    835. 

  835. 			if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    836. 

  836. 				printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    837. 

  837. 					++$test_counter, gettype($new_info), $new_info);
    838. 

  838. 			mysqli_get_client_stats_assert_eq('non_result_set_queries', $new_info, (string)($info['non_result_set_queries'] + 1), $test_counter, 'LOAD DATA LOCAL');
    839. 

  839. 			$info = $new_info;
    840. 

  840. 		}
    841. 

  841. 		unlink($file);
    842. 

  842. 	}
    843. 

  843. 

  844. 	mysqli_get_client_stats_assert_eq('bytes_received_real_data_normal', $info, $expected, $test_counter);
    845. 

  845. 	mysqli_get_client_stats_assert_eq('bytes_received_real_data_ps', $info, $expected, $test_counter);
    846. 

  846. 

  847. 	/*
    848. 

  848. 	We skip those:
    849. 

  849. 	13.2. Data Manipulation Statements
    850. 

  850. 	13.2.2. DO Syntax
    851. 

  851. 	13.2.3. HANDLER Syntax
    852. 

  852. 	13.2.5. LOAD DATA INFILE Syntax
    853. 

  853. 	*/
    854. 

  854. 	mysqli_query($link, "DELETE FROM test_mysqli_get_client_stats_table_1");
    855. 

  855. 	if (!mysqli_query($link, "INSERT INTO test_mysqli_get_client_stats_table_1(id, label) VALUES (1, 'a'), (2, 'b')"))
    856. 

  856. 		printf("[%03d] Cannot insert new records, [%d] %s\n", ++$test_counter,
    857. 

  857. 			mysqli_errno($link), mysqli_error($link));
    858. 

  858. 

  859. 	if (!$res = mysqli_real_query($link, "SELECT id, label FROM test_mysqli_get_client_stats_table_1 ORDER BY id"))
    860. 

  860. 		printf("[%03d] Cannot SELECT with mysqli_real_query(), [%d] %s\n", ++$test_counter,
    861. 

  861. 			mysqli_errno($link), mysqli_error($link));
    862. 

  862. 

  863. 	if (!is_object($res = mysqli_use_result($link)))
    864. 

  864. 		printf("[%03d] mysqli_use_result() failed, [%d] %s\n", ++$test_counter,
    865. 

  865. 			mysqli_errno($link), mysqli_error($link));
    866. 

  866. 

  867. 	while ($row = mysqli_fetch_assoc($res))
    868. 

  868. 		;
    869. 

  869. 	mysqli_free_result($res);
    870. 

  870. 	if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    871. 

  871. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    872. 

  872. 			++$test_counter, gettype($new_info), $new_info);
    873. 

  873. 	mysqli_get_client_stats_assert_eq('unbuffered_sets', $new_info, (string)($info['unbuffered_sets'] + 1), $test_counter, 'mysqli_use_result()');
    874. 

  874. 	$info = $new_info;
    875. 

  875. 

  876. 	if (!$res = mysqli_real_query($link, "SELECT id, label FROM test_mysqli_get_client_stats_table_1 ORDER BY id"))
    877. 

  877. 		printf("[%03d] Cannot SELECT with mysqli_real_query() II, [%d] %s\n", ++$test_counter,
    878. 

  878. 			mysqli_errno($link), mysqli_error($link));
    879. 

  879. 

  880. 	if (!is_object($res = mysqli_store_result($link)))
    881. 

  881. 		printf("[%03d] mysqli_use_result() failed, [%d] %s\n", ++$test_counter,
    882. 

  882. 			mysqli_errno($link), mysqli_error($link));
    883. 

  883. 

  884. 	while ($row = mysqli_fetch_assoc($res))
    885. 

  885. 		;
    886. 

  886. 	mysqli_free_result($res);
    887. 

  887. 	if (!is_array($new_info = mysqli_get_client_stats()) || empty($new_info))
    888. 

  888. 		printf("[%03d] Expecting array/any_non_empty, got %s/%s\n",
    889. 

  889. 			++$test_counter, gettype($new_info), $new_info);
    890. 

  890. 	mysqli_get_client_stats_assert_eq('buffered_sets', $new_info, (string)($info['buffered_sets'] + 1), $test_counter, 'mysqli_use_result()');
    891. 

  891. 	$info = $new_info;
    892. 

  892. 

  893. 	mysqli_close($link);
    894. 

  894. 

  895. 	mysqli_get_client_stats_assert_gt('bytes_received_real_data_normal', $info, $expected, $test_counter);
    896. 

  896. 	$expected['bytes_received_real_data_normal'] = $info['bytes_received_real_data_normal'];
    897. 

  897. 	mysqli_get_client_stats_assert_eq('bytes_received_real_data_ps', $info, $expected, $test_counter);
    898. 

  898. 

  899. 	/*
    900. 

  900. 	no_index_used
    901. 

  901. 	bad_index_used
    902. 

  902. 	flushed_normal_sets
    903. 

  903. 	flushed_ps_sets
    904. 

  904. 	explicit_close
    905. 

  905. 	implicit_close
    906. 

  906. 	disconnect_close
    907. 

  907. 	in_middle_of_command_close
    908. 

  908. 	explicit_free_result
    909. 

  909. 	implicit_free_result
    910. 

  910. 	explicit_stmt_close
    911. 

  911. 	implicit_stmt_close
    912. 

  912. 	*/
    913. 

  913. 

  914. 	print "done!";
    915. 

  915. ?>
    916. 

  916. <?php
    917. 

  917. require_once("connect.inc");
    918. 

  918. if (!$link = my_mysqli_connect($host, $user, $passwd, $db, $port, $socket))
    919. 

  919.    printf("[c001] [%d] %s\n", mysqli_connect_errno(), mysqli_connect_error());
    920. 

  920. 

  921. if (!mysqli_query($link, "DROP TABLE IF EXISTS test_mysqli_get_client_stats_table_1"))
    922. 

  922. 	printf("[c002] Cannot drop table, [%d] %s\n", mysqli_errno($link), mysqli_error($link));
    923. 

  923. 

  924. if (!mysqli_query($link, "DROP TABLE IF EXISTS non_result_set_queries_test"))
    925. 

  925. 	printf("[c003] Cannot drop table, [%d] %s\n", mysqli_errno($link), mysqli_error($link));
    926. 

  926. 

  927. if (!mysqli_query($link, "DROP TABLE IF EXISTS client_stats_test"))
    928. 

  928. 	printf("[c004] Cannot drop table, [%d] %s\n", mysqli_errno($link), mysqli_error($link));
    929. 

  929. 

  930. if (!mysqli_query($link, "DROP DATABASE IF EXISTS mysqli_get_client_stats_"))
    931. 

  931. 	printf("[c005] Cannot drop table, [%d] %s\n", mysqli_errno($link), mysqli_error($link));
    932. 

  932. 

  933. if (!mysqli_query($link, "DROP DATABASE IF EXISTS mysqli_get_client_stats"))
    934. 

  934. 	printf("[c006] Cannot drop table, [%d] %s\n", mysqli_errno($link), mysqli_error($link));
    935. 

  935. 

  936. if (!mysqli_query($link, "DROP SERVER IF EXISTS myself"))
    937. 

  937. 	printf("[c007] Cannot drop table, [%d] %s\n", mysqli_errno($link), mysqli_error($link));
    938. 

  938. 

  939. mysqli_close($link);
    940. 

  940. ?>
    941.