PageRenderTime 25ms CodeModel.GetById 26ms RepoModel.GetById 1ms app.codeStats 0ms

/tests/obsql/mysql_query.c

https://github.com/wangbingo/oceanbase
C | 483 lines | 368 code | 99 blank | 16 comment | 80 complexity | f1192f04947a52cad599fa93c9b43326 MD5 | raw file
Possible License(s): GPL-2.0
  1. /*
  2. * (C) 2007-2011 Alibaba Group Holding Limited.
  3. *
  4. * This program is free software; you can redistribute it and/or modify
  5. * it under the terms of the GNU General Public License version 2 as
  6. * published by the Free Software Foundation.
  7. *
  8. *
  9. * Version: $Id
  10. *
  11. * Authors:
  12. * admin <admin@taobao.com>
  13. * - initial release
  14. *
  15. */
  16. #include "sql_ob_init.h"
  17. #include <string.h>
  18. #define CREATE_TABLE "create table if not exists t1 (c1 int primary key, c2 int, c3 int, c4 int, c5 int)"
  19. #define SELECT_SQL "select * from t1"
  20. #define DROP_TABLE "drop table if exists t1"
  21. TEST_F(ObWithoutInit, 01_mysql_query)
  22. {
  23. int ret;
  24. my_ulonglong my_long_ret;
  25. unsigned int u_ret;
  26. ret = mysql_library_init(0, NULL, NULL);
  27. EXPECT_EQ(ret,0);
  28. MYSQL my_;
  29. EXPECT_TRUE(NULL != mysql_init(&my_));
  30. EXPECT_TRUE(NULL != mysql_real_connect(&my_, HOST, "admin", "admin", "test", PORT, NULL, 0));
  31. printf("query: %s\n", DROP_TABLE);
  32. ret = mysql_query(&my_, DROP_TABLE);
  33. EXPECT_TRUE( ret == 0 );
  34. printf("query: %s\n", CREATE_TABLE);
  35. ret = mysql_query(&my_, CREATE_TABLE);
  36. EXPECT_TRUE( ret == 0 );
  37. int len = 256;
  38. char sql[len];
  39. int i = 0;
  40. int n = 5;
  41. for( i=0; i<5; i++ )
  42. {
  43. memset(sql, '\0', len);
  44. sprintf(sql, "insert into t1 values ( %d, %d, %d, %d ,%d )", i*n, i*n+1, i*n+2, i*n+3, i*n+4);
  45. printf("query: %s\n", sql);
  46. ret = mysql_query(&my_, sql);
  47. EXPECT_TRUE( ret == 0 );
  48. my_long_ret = mysql_affected_rows(&my_);
  49. EXPECT_TRUE( my_long_ret == 1 );
  50. }
  51. ret = mysql_query(&my_, SELECT_SQL);
  52. EXPECT_TRUE( ret == 0 );
  53. MYSQL_RES* res;
  54. res = mysql_store_result(&my_);
  55. my_long_ret = mysql_num_rows(res);
  56. EXPECT_TRUE( my_long_ret == 5 );
  57. my_long_ret = mysql_num_fields(res);
  58. EXPECT_TRUE( my_long_ret == 5 );
  59. u_ret = mysql_field_count(&my_);
  60. EXPECT_TRUE( u_ret == 5 );
  61. MYSQL_ROW row;
  62. row = mysql_fetch_row(res);
  63. i = 1;
  64. while( row != NULL )
  65. {
  66. printf("ROW %d: %s\n", i, row[0]);
  67. ++i;
  68. row = mysql_fetch_row(res);
  69. }
  70. EXPECT_TRUE( i == 6 );
  71. MYSQL_FIELD * field;
  72. field = mysql_fetch_field(res);
  73. i = 1;
  74. while( field != NULL)
  75. {
  76. printf("FIELD %d: %s\n", i, field->name);
  77. ++i;
  78. field = mysql_fetch_field(res);
  79. }
  80. EXPECT_TRUE( i == 6 );
  81. my_ulonglong offset = 3;
  82. mysql_data_seek(res, offset);
  83. row = mysql_fetch_row(res);
  84. i = 4;
  85. while( row != NULL )
  86. {
  87. printf("ROW %d: %s\n", i, row[0]);
  88. ++i;
  89. row = mysql_fetch_row(res);
  90. }
  91. EXPECT_TRUE( i == 6 );
  92. unsigned int fieldnr = 3;
  93. field = mysql_fetch_field_direct(res,fieldnr);
  94. printf("FIELD %d: %s\n", 4, field->name);
  95. char*s_ret = "c4";
  96. EXPECT_TRUE( strcmp(s_ret, field->name) == 0 );
  97. mysql_data_seek(res, 0);
  98. mysql_row_seek(res, mysql_row_tell(res));
  99. row = mysql_fetch_row(res);
  100. printf("ROW %d: %s\n", 1, row[0]);
  101. s_ret = "0";
  102. EXPECT_TRUE( strcmp(s_ret, row[0]) == 0 );
  103. mysql_field_seek(res, 0);
  104. field = mysql_fetch_field(res);
  105. printf("FIELD %d: %s\n", 1, field->name);
  106. s_ret = "c1";
  107. EXPECT_TRUE( strcmp(s_ret, field->name) == 0 );
  108. unsigned long * lengths;
  109. lengths = mysql_fetch_lengths(res);
  110. for( i =0 ; i<5; i++)
  111. {
  112. printf("Column %u is %lu bytes in length.\n", i, lengths[i]);
  113. EXPECT_TRUE( 1 == lengths[i] );
  114. }
  115. printf("SQL STAT: %s\n", mysql_stat(&my_));
  116. mysql_free_result(res);
  117. mysql_close(&my_);
  118. mysql_library_end();
  119. }
  120. TEST_F(ObWithoutInit, 02_mysql_real_query)
  121. {
  122. int ret;
  123. my_ulonglong my_long_ret;
  124. unsigned int u_ret;
  125. ret = mysql_library_init(0, NULL, NULL);
  126. EXPECT_EQ(ret,0);
  127. MYSQL my_;
  128. EXPECT_TRUE(NULL != mysql_init(&my_));
  129. EXPECT_TRUE(NULL != mysql_real_connect(&my_, HOST, "admin", "admin", "test", PORT, NULL, 0));
  130. printf("query: %s\n", DROP_TABLE);
  131. ret = mysql_real_query(&my_, DROP_TABLE, strlen(DROP_TABLE));
  132. EXPECT_TRUE( ret == 0 );
  133. printf("query: %s\n", CREATE_TABLE);
  134. ret = mysql_real_query(&my_, CREATE_TABLE, strlen(CREATE_TABLE));
  135. EXPECT_TRUE( ret == 0 );
  136. int len = 256;
  137. char sql[len];
  138. int i = 0;
  139. int n = 5;
  140. for( i=0; i<5; i++ )
  141. {
  142. memset(sql, '\0', len);
  143. sprintf(sql, "insert into t1 values ( %d, %d, %d, %d ,%d )", i*n, i*n+1, i*n+2, i*n+3, i*n+4);
  144. printf("query: %s\n", sql);
  145. ret = mysql_real_query(&my_, sql, strlen(sql));
  146. EXPECT_TRUE( ret == 0 );
  147. my_long_ret = mysql_affected_rows(&my_);
  148. EXPECT_TRUE( my_long_ret == 1 );
  149. }
  150. ret = mysql_real_query(&my_, SELECT_SQL, strlen(SELECT_SQL));
  151. EXPECT_TRUE( ret == 0 );
  152. MYSQL_RES* res;
  153. res = mysql_store_result(&my_);
  154. my_long_ret = mysql_num_rows(res);
  155. EXPECT_TRUE( my_long_ret == 5 );
  156. my_long_ret = mysql_num_fields(res);
  157. EXPECT_TRUE( my_long_ret == 5 );
  158. u_ret = mysql_field_count(&my_);
  159. EXPECT_TRUE( u_ret == 5 );
  160. MYSQL_ROW row;
  161. row = mysql_fetch_row(res);
  162. i = 1;
  163. while( row != NULL )
  164. {
  165. printf("ROW %d: %s\n", i, row[0]);
  166. ++i;
  167. row = mysql_fetch_row(res);
  168. }
  169. EXPECT_TRUE( i == 6 );
  170. MYSQL_FIELD * field;
  171. field = mysql_fetch_field(res);
  172. i = 1;
  173. while( field != NULL)
  174. {
  175. printf("FIELD %d: %s\n", i, field->name);
  176. ++i;
  177. field = mysql_fetch_field(res);
  178. }
  179. EXPECT_TRUE( i == 6 );
  180. my_ulonglong offset = 3;
  181. mysql_data_seek(res, offset);
  182. row = mysql_fetch_row(res);
  183. i = 4;
  184. while( row != NULL )
  185. {
  186. printf("ROW %d: %s\n", i, row[0]);
  187. ++i;
  188. row = mysql_fetch_row(res);
  189. }
  190. EXPECT_TRUE( i == 6 );
  191. unsigned int fieldnr = 3;
  192. field = mysql_fetch_field_direct(res,fieldnr);
  193. printf("FIELD %d: %s\n", 4, field->name);
  194. char*s_ret = "c4";
  195. EXPECT_TRUE( strcmp(s_ret, field->name) == 0 );
  196. mysql_data_seek(res, 0);
  197. mysql_row_seek(res, mysql_row_tell(res));
  198. row = mysql_fetch_row(res);
  199. printf("ROW %d: %s\n", 1, row[0]);
  200. s_ret = "0";
  201. EXPECT_TRUE( strcmp(s_ret, row[0]) == 0 );
  202. mysql_field_seek(res, 0);
  203. field = mysql_fetch_field(res);
  204. printf("FIELD %d: %s\n", 1, field->name);
  205. s_ret = "c1";
  206. EXPECT_TRUE( strcmp(s_ret, field->name) == 0 );
  207. //mysql_data_seek(res,2);
  208. unsigned long * lengths;
  209. lengths = mysql_fetch_lengths(res);
  210. for( i =0 ; i<5; i++)
  211. {
  212. printf("Column %u is %lu bytes in length.\n", i, lengths[i]);
  213. EXPECT_TRUE( 1 == lengths[i] );
  214. }
  215. printf("SQL STAT: %s\n", mysql_stat(&my_));
  216. mysql_free_result(res);
  217. mysql_close(&my_);
  218. mysql_library_end();
  219. }
  220. TEST_F(ObWithoutInit, 03_mysql_query_use_result)
  221. {
  222. int ret;
  223. my_ulonglong my_long_ret;
  224. unsigned int u_ret;
  225. ret = mysql_library_init(0, NULL, NULL);
  226. EXPECT_EQ(ret,0);
  227. MYSQL my_;
  228. EXPECT_TRUE(NULL != mysql_init(&my_));
  229. EXPECT_TRUE(NULL != mysql_real_connect(&my_, HOST, "admin", "admin", "test", PORT, NULL, 0));
  230. printf("query: %s\n", DROP_TABLE);
  231. ret = mysql_query(&my_, DROP_TABLE);
  232. EXPECT_TRUE( ret == 0 );
  233. printf("query: %s\n", CREATE_TABLE);
  234. ret = mysql_query(&my_, CREATE_TABLE);
  235. EXPECT_TRUE( ret == 0 );
  236. int len = 256;
  237. char sql[len];
  238. int i = 0;
  239. int n = 5;
  240. for( i=0; i<5; i++ )
  241. {
  242. memset(sql, '\0', len);
  243. sprintf(sql, "insert into t1 values ( %d, %d, %d, %d ,%d )", i*n, i*n+1, i*n+2, i*n+3, i*n+4);
  244. printf("query: %s\n", sql);
  245. ret = mysql_query(&my_, sql);
  246. EXPECT_TRUE( ret == 0 );
  247. my_long_ret = mysql_affected_rows(&my_);
  248. EXPECT_TRUE( my_long_ret == 1 );
  249. }
  250. ret = mysql_query(&my_, SELECT_SQL);
  251. EXPECT_TRUE( ret == 0 );
  252. MYSQL_RES* res;
  253. res = mysql_use_result(&my_);
  254. my_long_ret = mysql_num_fields(res);
  255. EXPECT_TRUE( my_long_ret == 5 );
  256. u_ret = mysql_field_count(&my_);
  257. EXPECT_TRUE( u_ret == 5 );
  258. MYSQL_ROW row;
  259. row = mysql_fetch_row(res);
  260. i = 1;
  261. while( row != NULL )
  262. {
  263. printf("ROW %d: %s\n", i, row[0]);
  264. ++i;
  265. row = mysql_fetch_row(res);
  266. }
  267. EXPECT_TRUE( i == 6 );
  268. MYSQL_FIELD * field;
  269. field = mysql_fetch_field(res);
  270. i = 1;
  271. while( field != NULL)
  272. {
  273. printf("FIELD %d: %s\n", i, field->name);
  274. ++i;
  275. field = mysql_fetch_field(res);
  276. }
  277. EXPECT_TRUE( i == 6 );
  278. unsigned int fieldnr = 3;
  279. field = mysql_fetch_field_direct(res,fieldnr);
  280. printf("FIELD %d: %s\n", 4, field->name);
  281. char*s_ret = "c4";
  282. EXPECT_TRUE( strcmp(s_ret, field->name) == 0 );
  283. mysql_field_seek(res, 0);
  284. field = mysql_fetch_field(res);
  285. printf("FIELD %d: %s\n", 1, field->name);
  286. s_ret = "c1";
  287. EXPECT_TRUE( strcmp(s_ret, field->name) == 0 );
  288. unsigned long * lengths;
  289. lengths = mysql_fetch_lengths(res);
  290. for( i =0 ; i<5; i++)
  291. {
  292. printf("Column %u is %lu bytes in length.\n", i, lengths[i]);
  293. EXPECT_TRUE( 2 == lengths[i] );
  294. }
  295. printf("SQL STAT: %s\n", mysql_stat(&my_));
  296. mysql_free_result(res);
  297. mysql_close(&my_);
  298. mysql_library_end();
  299. }
  300. TEST_F(ObWithoutInit, 04_mysql_real_query_use_result)
  301. {
  302. int ret;
  303. my_ulonglong my_long_ret;
  304. unsigned int u_ret;
  305. ret = mysql_library_init(0, NULL, NULL);
  306. EXPECT_EQ(ret,0);
  307. MYSQL my_;
  308. EXPECT_TRUE(NULL != mysql_init(&my_));
  309. EXPECT_TRUE(NULL != mysql_real_connect(&my_, HOST, "admin", "admin", "test", PORT, NULL, 0));
  310. printf("query: %s\n", DROP_TABLE);
  311. ret = mysql_real_query(&my_, DROP_TABLE, strlen(DROP_TABLE));
  312. EXPECT_TRUE( ret == 0 );
  313. printf("query: %s\n", CREATE_TABLE);
  314. ret = mysql_real_query(&my_, CREATE_TABLE, strlen(CREATE_TABLE));
  315. EXPECT_TRUE( ret == 0 );
  316. int len = 256;
  317. char sql[len];
  318. int i = 0;
  319. int n = 5;
  320. for( i=0; i<5; i++ )
  321. {
  322. memset(sql, '\0', len);
  323. sprintf(sql, "insert into t1 values ( %d, %d, %d, %d ,%d )", i*n, i*n+1, i*n+2, i*n+3, i*n+4);
  324. printf("query: %s\n", sql);
  325. ret = mysql_real_query(&my_, sql, strlen(sql));
  326. EXPECT_TRUE( ret == 0 );
  327. my_long_ret = mysql_affected_rows(&my_);
  328. EXPECT_TRUE( my_long_ret == 1 );
  329. }
  330. ret = mysql_real_query(&my_, SELECT_SQL, strlen(SELECT_SQL));
  331. EXPECT_TRUE( ret == 0 );
  332. MYSQL_RES* res;
  333. res = mysql_use_result(&my_);
  334. my_long_ret = mysql_num_fields(res);
  335. EXPECT_TRUE( my_long_ret == 5 );
  336. u_ret = mysql_field_count(&my_);
  337. EXPECT_TRUE( u_ret == 5 );
  338. MYSQL_ROW row;
  339. row = mysql_fetch_row(res);
  340. i = 1;
  341. while( row != NULL )
  342. {
  343. printf("ROW %d: %s\n", i, row[0]);
  344. ++i;
  345. row = mysql_fetch_row(res);
  346. }
  347. EXPECT_TRUE( i == 6 );
  348. MYSQL_FIELD * field;
  349. field = mysql_fetch_field(res);
  350. i = 1;
  351. while( field != NULL)
  352. {
  353. printf("FIELD %d: %s\n", i, field->name);
  354. ++i;
  355. field = mysql_fetch_field(res);
  356. }
  357. EXPECT_TRUE( i == 6 );
  358. unsigned int fieldnr = 3;
  359. field = mysql_fetch_field_direct(res,fieldnr);
  360. printf("FIELD %d: %s\n", 4, field->name);
  361. char*s_ret = "c4";
  362. EXPECT_TRUE( strcmp(s_ret, field->name) == 0 );
  363. mysql_field_seek(res, 0);
  364. field = mysql_fetch_field(res);
  365. printf("FIELD %d: %s\n", 1, field->name);
  366. s_ret = "c1";
  367. EXPECT_TRUE( strcmp(s_ret, field->name) == 0 );
  368. unsigned long * lengths;
  369. lengths = mysql_fetch_lengths(res);
  370. for( i =0 ; i<5; i++)
  371. {
  372. printf("Column %u is %lu bytes in length.\n", i, lengths[i]);
  373. EXPECT_TRUE( 2 == lengths[i] );
  374. }
  375. printf("SQL STAT: %s\n", mysql_stat(&my_));
  376. mysql_free_result(res);
  377. mysql_close(&my_);
  378. mysql_library_end();
  379. }
  380. int main (int argc , char**argv)
  381. {
  382. testing::InitGoogleTest(&argc,argv);
  383. return RUN_ALL_TESTS();
  384. }