ps_query.inc
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:25k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. ####################### ps_query.inc #########################
  2. #                                                            #
  3. #       Tests for prepared statements: SELECTs               #
  4. #                                                            #
  5. ##############################################################
  6. #    
  7. # NOTE: PLEASE SEE ps_1general.test (bottom) 
  8. #       BEFORE ADDING NEW TEST CASES HERE !!!
  9. #
  10. # Please be aware, that this file will be sourced by several test case files
  11. # stored within the subdirectory 't'. So every change here will affect 
  12. # several test cases.
  13. #
  14. # Please do not modify (INSERT/UPDATE/DELETE) the content or the 
  15. # structure (DROP/ALTER..) of the tables
  16. #     't1' and 't9'. 
  17. # Such tests should be done in include/ps_modify.inc .
  18. #
  19. # But you are encouraged to use these two tables within your SELECT statements
  20. # whenever possible. 
  21. #     t1  - very simple table
  22. #     t9  - table with nearly all available column types
  23. #
  24. # The structure and the content of these tables can be found in
  25. #     include/ps_create.inc  CREATE TABLE ...
  26. #     include/ps_renew.inc   DELETE all rows and INSERT some rows
  27. #
  28. # Both tables are managed by the same storage engine.
  29. # The type of the storage engine is stored in the variable '$type' . 
  30. #------------------- Please insert your test cases here -------------------#
  31. #-------- Please be very carefull when editing behind this line  ----------#
  32. ################ simple select tests ################
  33. --disable_query_log
  34. select '------ simple select tests ------' as test_sequence ;
  35. --enable_query_log
  36. ##### many column types, but no parameter
  37. # heavy modified case derived from client_test.c: test_func_fields()
  38. prepare stmt1 from ' select * from t9 order by c1 ' ;
  39. --enable_metadata
  40. execute stmt1;
  41. --disable_metadata
  42. ##### parameter used for keyword like SELECT (must fail)
  43. set @arg00='SELECT' ;
  44. # mysqltest gives no output for the next statement, Why ??
  45. --error 1064
  46. @arg00 a from t1 where a=1;
  47. --error 1064
  48. prepare stmt1 from ' ? a from t1 where a=1 ';
  49. ##### parameter in select column list
  50. ## parameter is not NULL
  51. set @arg00=1 ;
  52. select @arg00, b from t1 where a=1 ;
  53. prepare stmt1 from ' select ?, b from t1 where a=1 ' ;
  54. execute stmt1 using @arg00 ;
  55. set @arg00='lion' ;
  56. select @arg00, b from t1 where a=1 ;
  57. prepare stmt1 from ' select ?, b from t1 where a=1 ' ;
  58. execute stmt1 using @arg00 ;
  59. ## parameter is NULL
  60. set @arg00=NULL ;
  61. select @arg00, b from t1 where a=1 ;
  62. prepare stmt1 from ' select ?, b from t1 where a=1 ' ;
  63. execute stmt1 using @arg00 ;
  64. ## parameter within an expression
  65. set @arg00=1 ;
  66. select b, a - @arg00 from t1 where a=1 ;
  67. prepare stmt1 from ' select b, a - ? from t1 where a=1 ' ;
  68. execute stmt1 using @arg00 ;
  69. # case derived from client_test.c: test_ps_null_param()
  70. set @arg00=null ;
  71. select @arg00 as my_col ;
  72. prepare stmt1 from ' select ? as my_col';
  73. execute stmt1 using @arg00 ;
  74. select @arg00 + 1 as my_col ;
  75. prepare stmt1 from ' select ? + 1 as my_col';
  76. execute stmt1 using @arg00 ;
  77. select 1 + @arg00 as my_col ;
  78. prepare stmt1 from ' select 1 + ? as my_col';
  79. execute stmt1 using @arg00 ;
  80. ## parameter is within a function
  81. # variations on 'substr'
  82. set @arg00='MySQL' ;
  83. select substr(@arg00,1,2) from t1 where a=1 ;
  84. prepare stmt1 from ' select substr(?,1,2) from t1 where a=1 ' ;
  85. execute stmt1 using @arg00 ;
  86. set @arg00=3 ;
  87. select substr('MySQL',@arg00,5) from t1 where a=1 ;
  88. prepare stmt1 from ' select substr(''MySQL'',?,5) from t1 where a=1 ' ;
  89. execute stmt1 using @arg00 ;
  90. select substr('MySQL',1,@arg00) from t1 where a=1 ;
  91. prepare stmt1 from ' select substr(''MySQL'',1,?) from t1 where a=1 ' ;
  92. execute stmt1 using @arg00 ;
  93. # variations on 'concat'
  94. set @arg00='MySQL' ;
  95. select a , concat(@arg00,b) from t1 order by a;
  96. # BUG#3796 Prepared statement, select concat(<parameter>,<column>),wrong result
  97. prepare stmt1 from ' select a , concat(?,b) from t1 order by a ' ;
  98. execute stmt1 using @arg00;
  99. #
  100. select a , concat(b,@arg00) from t1 order by a ;
  101. prepare stmt1 from ' select a , concat(b,?) from t1 order by a ' ;
  102. execute stmt1 using @arg00;
  103. # variations on 'group_concat'
  104. set @arg00='MySQL' ;
  105. select group_concat(@arg00,b order by a) from t1 
  106. group by 'a' ;
  107. prepare stmt1 from ' select group_concat(?,b order by a) from t1
  108. group by ''a'' ' ;
  109. execute stmt1 using @arg00;
  110. #
  111. select group_concat(b,@arg00 order by a) from t1 
  112. group by 'a' ;
  113. prepare stmt1 from ' select group_concat(b,? order by a) from t1
  114. group by ''a'' ' ;
  115. execute stmt1 using @arg00;
  116. ## two parameters
  117. set @arg00='first' ;
  118. set @arg01='second' ;
  119. set @arg02=NULL;
  120. select @arg00, @arg01 from t1 where a=1 ;
  121. prepare stmt1 from ' select ?, ? from t1 where a=1 ' ;
  122. execute stmt1 using @arg00, @arg01 ;
  123. # NULL as first and/or last parameter 
  124. execute stmt1 using @arg02, @arg01 ;
  125. execute stmt1 using @arg00, @arg02 ;
  126. execute stmt1 using @arg02, @arg02 ;
  127. # case derived from client_test.c: test_ps_conj_select()
  128. #      for BUG#3420: select returned all rows of the table
  129. --disable_warnings
  130. drop table if exists t5 ;
  131. --enable_warnings
  132. create table t5 (id1 int(11) not null default '0',
  133.        value2 varchar(100), value1 varchar(100)) ;
  134. insert into t5 values (1,'hh','hh'),(2,'hh','hh'),
  135.                   (1,'ii','ii'),(2,'ii','ii') ;
  136. prepare stmt1 from ' select id1,value1 from t5 where id1=? or value1=? order by id1,value1 ' ;
  137. set @arg00=1 ;
  138. set @arg01='hh' ;
  139. execute stmt1 using @arg00, @arg01 ;
  140. drop table t5 ;
  141. # case derived from client_test.c: test_bug1180()
  142. #      for BUG#1180 optimized away part of WHERE clause
  143. --disable_warnings
  144. drop table if exists t5 ;
  145. --enable_warnings
  146. create table t5(session_id  char(9) not null) ;
  147. insert into t5 values ('abc') ;
  148. prepare stmt1 from ' select * from t5
  149. where ?=''1111'' and session_id = ''abc'' ' ;
  150. set @arg00='abc' ;
  151. execute stmt1 using @arg00 ;
  152. set @arg00='1111' ;
  153. execute stmt1 using @arg00 ;
  154. set @arg00='abc' ;
  155. execute stmt1 using @arg00 ;
  156. drop table t5 ;
  157. ##### parameter used for keyword FROM (must fail)
  158. set @arg00='FROM' ;
  159. --error 1064
  160. select a @arg00 t1 where a=1 ;
  161. --error 1064
  162. prepare stmt1 from ' select a ? t1 where a=1 ' ;
  163. ##### parameter used for tablename (must fail)
  164. set @arg00='t1' ;
  165. --error 1064
  166. select a from @arg00 where a=1 ;
  167. --error 1064
  168. prepare stmt1 from ' select a from ? where a=1 ' ;
  169. ##### parameter used for keyword WHERE tablename (must fail)
  170. set @arg00='WHERE' ;
  171. --error 1064
  172. select a from t1 @arg00 a=1 ;
  173. --error 1064
  174. prepare stmt1 from ' select a from t1 ? a=1 ' ;
  175. ##### parameter used in where clause
  176. # parameter is not NULL
  177. set @arg00=1 ;
  178. select a FROM t1 where a=@arg00 ;
  179. prepare stmt1 from ' select a FROM t1 where a=? ' ;
  180. execute stmt1 using @arg00 ;
  181. set @arg00=1000 ;
  182. # row not found
  183. execute stmt1 using @arg00 ;
  184. # parameter is NULL
  185. set @arg00=NULL ;
  186. select a FROM t1 where a=@arg00 ;
  187. prepare stmt1 from ' select a FROM t1 where a=? ' ;
  188. execute stmt1 using @arg00 ;
  189. # parameter is not NULL within a function
  190. set @arg00=4 ;
  191. select a FROM t1 where a=sqrt(@arg00) ;
  192. prepare stmt1 from ' select a FROM t1 where a=sqrt(?) ' ;
  193. execute stmt1 using @arg00 ;
  194. # parameter is NULL within a function
  195. set @arg00=NULL ;
  196. select a FROM t1 where a=sqrt(@arg00) ;
  197. prepare stmt1 from ' select a FROM t1 where a=sqrt(?) ' ;
  198. execute stmt1 using @arg00 ;
  199. # parameter in IN
  200. set @arg00=2 ;
  201. set @arg01=3 ;
  202. select a FROM t1 where a in (@arg00,@arg01) order by a;
  203. prepare stmt1 from ' select a FROM t1 where a in (?,?) order by a ';
  204. execute stmt1 using @arg00, @arg01;
  205. # case derived from client_test.c: test_bug1500()
  206. set @arg00= 'one' ;
  207. set @arg01= 'two' ;
  208. set @arg02= 'five' ;
  209. prepare stmt1 from ' select b FROM t1 where b in (?,?,?) order by b ' ;
  210. execute stmt1 using @arg00, @arg01, @arg02 ;
  211. # parameter in LIKE
  212. prepare stmt1 from ' select b FROM t1 where b like ? ';
  213. set @arg00='two' ;
  214. execute stmt1 using @arg00 ;
  215. set @arg00='tw%' ;
  216. execute stmt1 using @arg00 ;
  217. set @arg00='%wo' ;
  218. execute stmt1 using @arg00 ;
  219. # case derived from client_test.c: test_ps_null_param():
  220. # second part, comparisions with NULL placeholders in prepared
  221. # mode
  222. set @arg00=null ;
  223. insert into t9 set c1= 0, c5 = NULL ;
  224. select c5 from t9 where c5 > NULL ;
  225. prepare stmt1 from ' select c5 from t9 where c5 > ? ';
  226. execute stmt1 using @arg00 ;
  227. select c5 from t9 where c5 < NULL ;
  228. prepare stmt1 from ' select c5 from t9 where c5 < ? ';
  229. execute stmt1 using @arg00 ;
  230. select c5 from t9 where c5 = NULL ;
  231. prepare stmt1 from ' select c5 from t9 where c5 = ? ';
  232. execute stmt1 using @arg00 ;
  233. select c5 from t9 where c5 <=> NULL ;
  234. prepare stmt1 from ' select c5 from t9 where c5 <=> ? ';
  235. execute stmt1 using @arg00 ;
  236. delete from t9 where c1= 0 ;
  237. ##### parameter used for operator in WHERE clause (must fail)
  238. set @arg00='>' ;
  239. --error 1064
  240. select a FROM t1 where a @arg00 1 ;
  241. --error 1064
  242. prepare stmt1 from ' select a FROM t1 where a ? 1 ' ;
  243. ##### parameter used in group by clause
  244. set @arg00=1 ;
  245. select a,b FROM t1 where a is not NULL
  246. AND b is not NULL group by a - @arg00 ;
  247. prepare stmt1 from ' select a,b FROM t1 where a is not NULL
  248. AND b is not NULL group by a - ? ' ;
  249. execute stmt1 using @arg00 ;
  250. ##### parameter used in having clause
  251. set @arg00='two' ;
  252. select a,b FROM t1 where a is not NULL
  253. AND b is not NULL having b <> @arg00 order by a ;
  254. prepare stmt1 from ' select a,b FROM t1 where a is not NULL
  255. AND b is not NULL having b <> ? order by a ' ;
  256. execute stmt1 using @arg00 ;
  257. ##### parameter used in order clause
  258. set @arg00=1 ;
  259. select a,b FROM t1 where a is not NULL
  260. AND b is not NULL order by a - @arg00 ;
  261. prepare stmt1 from ' select a,b FROM t1 where a is not NULL
  262. AND b is not NULL order by a - ? ' ;
  263. execute stmt1 using @arg00 ;
  264. ## What is the semantic of a single parameter (integer >0)
  265. #  after order by? column number or constant
  266. set @arg00=2 ;
  267. select a,b from t1 order by 2 ;
  268. prepare stmt1 from ' select a,b from t1
  269. order by ? ';
  270. execute stmt1 using @arg00;
  271. set @arg00=1 ;
  272. execute stmt1 using @arg00;
  273. set @arg00=0 ;
  274. --error 1054
  275. execute stmt1 using @arg00;
  276. ##### parameter used in limit clause
  277. set @arg00=1;
  278. prepare stmt1 from ' select a,b from t1 order by a
  279. limit 1 ';
  280. execute stmt1 ;
  281. # currently (May 2004, Version 4.1) it is impossible
  282. -- error 1064
  283. prepare stmt1 from ' select a,b from t1
  284. limit ? ';
  285. ##### parameter used in many places
  286. set @arg00='b' ;
  287. set @arg01=0 ;
  288. set @arg02=2 ;
  289. set @arg03=2 ;
  290. select sum(a), @arg00 from t1 where a > @arg01
  291. and b is not null group by substr(b,@arg02)
  292. having sum(a) <> @arg03 ;
  293. prepare stmt1 from ' select sum(a), ? from t1 where a > ?
  294. and b is not null group by substr(b,?)
  295. having sum(a) <> ? ';
  296. execute stmt1 using @arg00, @arg01, @arg02, @arg03;
  297. ################ join tests ################
  298. --disable_query_log
  299. select '------ join tests ------' as test_sequence ;
  300. --enable_query_log
  301. # no parameter
  302. select first.a as a1, second.a as a2 
  303. from t1 first, t1 second
  304. where first.a = second.a order by a1 ;
  305. prepare stmt1 from ' select first.a as a1, second.a as a2 
  306.         from t1 first, t1 second
  307.         where first.a = second.a order by a1 ';
  308. execute stmt1 ;
  309. # some parameters
  310. set @arg00='ABC';
  311. set @arg01='two';
  312. set @arg02='one';
  313. select first.a, @arg00, second.a FROM t1 first, t1 second
  314. where @arg01 = first.b or first.a = second.a or second.b = @arg02
  315. order by second.a, first.a;
  316. prepare stmt1 from ' select first.a, ?, second.a FROM t1 first, t1 second
  317.                     where ? = first.b or first.a = second.a or second.b = ?
  318.                     order by second.a, first.a';
  319. execute stmt1 using @arg00, @arg01, @arg02;
  320. # test case derived from client_test.c: test_join()
  321. --disable_warnings
  322. drop table if exists t2 ;
  323. --enable_warnings
  324. create table t2 as select * from t1 ;
  325. set @query1= 'SELECT * FROM t2 join t1 on (t1.a=t2.a) order by t2.a ' ;
  326. set @query2= 'SELECT * FROM t2 natural join t1 order by t2.a ' ;
  327. set @query3= 'SELECT * FROM t2 join t1 using(a) order by t2.a ' ;
  328. set @query4= 'SELECT * FROM t2 left join t1 on(t1.a=t2.a) order by t2.a ' ;
  329. set @query5= 'SELECT * FROM t2 natural left join t1 order by t2.a ' ;
  330. set @query6= 'SELECT * FROM t2 left join t1 using(a) order by t2.a ' ;
  331. set @query7= 'SELECT * FROM t2 right join t1 on(t1.a=t2.a) order by t2.a ' ;
  332. set @query8= 'SELECT * FROM t2 natural right join t1 order by t2.a ' ;
  333. set @query9= 'SELECT * FROM t2 right join t1 using(a) order by t2.a ' ;
  334. let $1= 9 ;
  335. while ($1)
  336. {
  337.   --disable_query_log
  338.   eval select @query$1 as 'the join statement is:' ;
  339.   --enable_query_log
  340.   eval prepare stmt1 from @query$1 ;
  341.   let $2= 3 ;
  342.   while ($2)
  343.   {
  344.     execute stmt1 ;
  345.     dec $2 ;
  346.   }
  347.   dec $1 ;
  348. }
  349. drop table t2 ;
  350. ################ subquery tests ################
  351. --disable_query_log
  352. select '------ subquery tests ------' as test_sequence ;
  353. --enable_query_log
  354. # no parameter
  355. prepare stmt1 from ' select a, b FROM t1 outer_table where
  356.    a = (select a from t1 where b = ''two'') ';
  357. execute stmt1 ;
  358. ###### parameter in the outer part
  359. set @arg00='two' ;
  360. select a, b FROM t1 outer_table where
  361.    a = (select a from t1 where b = 'two' ) and b=@arg00 ;
  362. prepare stmt1 from ' select a, b FROM t1 outer_table where
  363.    a = (select a from t1 where b = ''two'') and b=? ';
  364. execute stmt1 using @arg00;
  365. ###### parameter in the inner part
  366. set @arg00='two' ;
  367. # Bug#4000 (only BDB tables)
  368. select a, b FROM t1 outer_table where
  369.    a = (select a from t1 where b = @arg00 ) and b='two' ;
  370. prepare stmt1 from ' select a, b FROM t1 outer_table where
  371.    a = (select a from t1 where b = ? ) and b=''two'' ' ;
  372. execute stmt1 using @arg00;
  373. set @arg00=3 ;
  374. set @arg01='three' ;
  375. select a,b FROM t1 where (a,b) in (select 3, 'three');
  376. select a FROM t1 where (a,b) in (select @arg00,@arg01);
  377. prepare stmt1 from ' select a FROM t1 where (a,b) in (select ?, ?) ';
  378. execute stmt1 using @arg00, @arg01;
  379. ###### parameters in the both parts
  380. set @arg00=1 ;
  381. set @arg01='two' ;
  382. set @arg02=2 ;
  383. set @arg03='two' ;
  384. # Bug#4000 (only BDB tables)
  385. select a, @arg00, b FROM t1 outer_table where
  386.    b=@arg01 and a = (select @arg02 from t1 where b = @arg03 ) ;
  387. prepare stmt1 from ' select a, ?, b FROM t1 outer_table where
  388.    b=? and a = (select ? from t1 where b = ? ) ' ;
  389. execute stmt1 using @arg00, @arg01, @arg02, @arg03 ;
  390. # Bug#8807
  391. prepare stmt1 from 'select c4 FROM t9 where
  392.     c13 = (select MAX(b) from t1 where a = ?) and c22 = ? ' ;
  393. execute stmt1 using @arg01, @arg02;
  394. ######## correlated subquery
  395. # no parameter
  396. prepare stmt1 from ' select a, b FROM t1 outer_table where
  397.    a = (select a from t1 where b = outer_table.b ) order by a ';
  398. # also Bug#4000 (only BDB tables)
  399. # Bug#4106 : ndb table, query with correlated subquery, wrong result
  400. execute stmt1 ;
  401. # test case derived from client_test.c: test_subqueries_ref
  402. let $1= 3 ;
  403. while ($1)
  404. {
  405.   prepare stmt1 from ' SELECT a as ccc from t1 where a+1=
  406.                            (SELECT 1+ccc from t1 where ccc+1=a+1 and a=1) ';
  407.   execute stmt1 ;
  408.   deallocate prepare stmt1 ;
  409.   dec $1 ;
  410. }
  411. ###### parameter in the outer part
  412. set @arg00='two' ;
  413. # Bug#4000 (only BDB tables)
  414. select a, b FROM t1 outer_table where
  415.    a = (select a from t1 where b = outer_table.b ) and b=@arg00 ;
  416. prepare stmt1 from ' select a, b FROM t1 outer_table where
  417.    a = (select a from t1 where b = outer_table.b) and b=? ';
  418. # also Bug#4000 (only BDB tables)
  419. execute stmt1 using @arg00;
  420. ###### parameter in the inner part
  421. set @arg00=2 ;
  422. select a, b FROM t1 outer_table where
  423.    a = (select a from t1 where a = @arg00 and b = outer_table.b) and b='two' ;
  424. prepare stmt1 from ' select a, b FROM t1 outer_table where
  425.    a = (select a from t1 where a = ? and b = outer_table.b) and b=''two'' ' ;
  426. execute stmt1 using @arg00;
  427. set @arg00=2 ;
  428. select a, b FROM t1 outer_table where
  429.    a = (select a from t1 where outer_table.a = @arg00 and a=2) and b='two' ;
  430. prepare stmt1 from ' select a, b FROM t1 outer_table where
  431.    a = (select a from t1 where outer_table.a = ? and a=2) and b=''two'' ' ;
  432. execute stmt1 using @arg00;
  433. ###### parameters in the both parts
  434. set @arg00=1 ;
  435. set @arg01='two' ;
  436. set @arg02=2 ;
  437. set @arg03='two' ;
  438. # Bug#4000 (only BDB tables)
  439. select a, @arg00, b FROM t1 outer_table where
  440.    b=@arg01 and a = (select @arg02 from t1 where outer_table.b = @arg03
  441.                         and outer_table.a=a ) ;
  442. prepare stmt1 from ' select a, ?, b FROM t1 outer_table where
  443.    b=? and a = (select ? from t1 where outer_table.b = ? 
  444.                    and outer_table.a=a ) ' ;
  445. # also Bug#4000 (only BDB tables)
  446. execute stmt1 using @arg00, @arg01, @arg02, @arg03 ;
  447. ###### subquery after from
  448. set @arg00=1 ;
  449. set @arg01=0 ;
  450. select a, @arg00 
  451. from ( select a - @arg00 as a from t1 where a=@arg00 ) as t2
  452. where a=@arg01;
  453. prepare stmt1 from ' select a, ? 
  454.                     from ( select a - ? as a from t1 where a=? ) as t2
  455.                     where a=? ';
  456. execute stmt1 using @arg00, @arg00, @arg00, @arg01 ;
  457. ###### subquery  in select list
  458. # test case derived from client_test.c: test_create_drop
  459. --disable_warnings
  460. drop table if exists t2 ;
  461. --enable_warnings
  462. create table t2 as select * from t1;
  463. prepare stmt1 from ' select a in (select a from t2) from t1 ' ;
  464. execute stmt1 ;
  465. # test case derived from client_test.c: test_selecttmp()
  466. --disable_warnings
  467. drop table if exists t5, t6, t7 ;
  468. --enable_warnings
  469. create table t5 (a int , b int) ;
  470. create table t6 like t5 ;
  471. create table t7 like t5 ;
  472. insert into t5 values (0, 100), (1, 2), (1, 3), (2, 2), (2, 7),
  473.                       (2, -1), (3, 10) ;
  474. insert into t6 values (0, 0), (1, 1), (2, 1), (3, 1), (4, 1) ;
  475. insert into t7 values (3, 3), (2, 2), (1, 1) ;
  476. prepare stmt1 from ' select a, (select count(distinct t5.b) as sum from t5, t6
  477.                      where t5.a=t6.a and t6.b > 0 and t5.a <= t7.b
  478.                      group by t5.a order by sum limit 1) from t7 ' ;
  479. let $1= 3 ;
  480. while ($1)
  481. {
  482.   execute stmt1 ;
  483.   dec $1 ;
  484. }
  485. drop table t5, t6, t7 ;
  486. ###### heavy modified case derived from client_test.c: test_distinct()
  487. --disable_warnings
  488. drop table if exists t2 ;
  489. --enable_warnings
  490. create table t2 as select * from t9;
  491. ## unusual and complex SELECT without parameters
  492. set @stmt= ' SELECT
  493.    (SELECT SUM(c1 + c12 + 0.0) FROM t2 
  494.     where (t9.c2 - 0e-3) = t2.c2
  495.     GROUP BY t9.c15 LIMIT 1) as scalar_s,
  496.    exists (select 1.0e+0 from t2 
  497.            where t2.c3 * 9.0000000000 = t9.c4) as exists_s,
  498.    c5 * 4 in (select c6 + 0.3e+1 from t2) as in_s,
  499.    (c7 - 4, c8 - 4) in (select c9 + 4.0, c10 + 40e-1 from t2) as in_row_s
  500. FROM t9,
  501. (select c25 x, c32 y from t2) tt WHERE x = c25 ' ;
  502. --enable_metadata
  503. prepare stmt1 from @stmt ;
  504. #
  505. # Result log was disabled upon test case failure in the optimized build.
  506. #
  507. --disable_result_log
  508. execute stmt1 ;
  509. --disable_metadata
  510. execute stmt1 ;
  511. ## now expand the terrible SELECT to EXPLAIN SELECT
  512. set @stmt= concat('explain ',@stmt);
  513. --enable_metadata
  514. prepare stmt1 from @stmt ;
  515. execute stmt1 ;
  516. --disable_metadata
  517. # Bug#4271 prepared explain complex select, second executes crashes the server
  518. execute stmt1 ;
  519. ## many parameters
  520. ## replace the constants of the complex SELECT with parameters
  521. set @stmt= ' SELECT
  522.    (SELECT SUM(c1+c12+?) FROM t2 where (t9.c2-?)=t2.c2
  523.     GROUP BY t9.c15 LIMIT 1) as scalar_s,
  524.    exists (select ? from t2 
  525.            where t2.c3*?=t9.c4) as exists_s,
  526.    c5*? in (select c6+? from t2) as in_s,
  527.    (c7-?, c8-?) in (select c9+?, c10+? from t2) as in_row_s
  528. FROM t9,
  529. (select c25 x, c32 y from t2) tt WHERE x =c25 ' ;
  530. set @arg00= 0.0 ;
  531. set @arg01= 0e-3 ;
  532. set @arg02= 1.0e+0 ;
  533. set @arg03= 9.0000000000 ;
  534. set @arg04= 4 ;
  535. set @arg05= 0.3e+1 ;
  536. set @arg06= 4 ;
  537. set @arg07= 4 ;
  538. set @arg08= 4.0 ;
  539. set @arg09= 40e-1 ;
  540. --enable_metadata
  541. prepare stmt1 from @stmt ;
  542. execute stmt1 using @arg00, @arg01, @arg02, @arg03, @arg04, @arg05, @arg06,
  543.                     @arg07, @arg08, @arg09 ;
  544. --disable_metadata
  545. execute stmt1 using @arg00, @arg01, @arg02, @arg03, @arg04, @arg05, @arg06,
  546.                     @arg07, @arg08, @arg09 ;
  547. ## now expand the terrible SELECT to EXPLAIN SELECT
  548. set @stmt= concat('explain ',@stmt);
  549. --enable_metadata
  550. prepare stmt1 from @stmt ;
  551. execute stmt1 using @arg00, @arg01, @arg02, @arg03, @arg04, @arg05, @arg06,
  552.                     @arg07, @arg08, @arg09 ;
  553. --disable_metadata
  554. execute stmt1 using @arg00, @arg01, @arg02, @arg03, @arg04, @arg05, @arg06,
  555.                     @arg07, @arg08, @arg09 ;
  556. --enable_result_log
  557. drop table t2 ;
  558. ##### test case derived from client_test.c: test_bug4079()
  559. --error 1242
  560. select 1 < (select a from t1) ;
  561. prepare stmt1 from ' select 1 < (select a from t1) ' ;
  562. --error 1242
  563. execute stmt1 ;
  564. # Bug#5066 embedded server, select after failed subquery provides wrong result
  565. #          (two additional records, all column values NULL)
  566. select 1 as my_col ;
  567. ################ union tests ################
  568. --disable_query_log
  569. select '------ union tests ------' as test_sequence ;
  570. --enable_query_log
  571. # no parameter
  572. prepare stmt1 from ' select a FROM t1 where a=1
  573.                      union distinct
  574.                      select a FROM t1 where a=1 ';
  575. execute stmt1 ;
  576. # Bug#3577: the second execute crashes mysqld
  577. execute stmt1 ;
  578. prepare stmt1 from ' select a FROM t1 where a=1
  579.                      union all
  580.                      select a FROM t1 where a=1 ';
  581. execute stmt1 ;
  582. # test case derived from client_test.c: test_bad_union()
  583. --error 1222
  584. prepare stmt1 from ' SELECT 1, 2 union SELECT 1 ' ;
  585. --error 1222
  586. prepare stmt1 from ' SELECT 1 union SELECT 1, 2 ' ;
  587. --error 1222
  588. prepare stmt1 from ' SELECT * from t1 union SELECT 1 ' ;
  589. --error 1222
  590. prepare stmt1 from ' SELECT 1 union SELECT * from t1 ' ;
  591. ##### everything in the first table
  592. # one parameter as constant in the first table
  593. set @arg00=1 ;
  594. select @arg00 FROM t1 where a=1
  595. union distinct
  596. select 1 FROM t1 where a=1;
  597. prepare stmt1 from ' select ? FROM t1 where a=1
  598.                      union distinct
  599.                      select 1 FROM t1 where a=1 ' ;
  600. execute stmt1 using @arg00;
  601. ##### everything in the second table
  602. # one parameter as constant
  603. set @arg00=1 ;
  604. select 1 FROM t1 where a=1
  605. union distinct
  606. select @arg00 FROM t1 where a=1;
  607. prepare stmt1 from ' select 1 FROM t1 where a=1
  608.                      union distinct
  609.                      select ? FROM t1 where a=1 ' ;
  610. execute stmt1 using @arg00;
  611. # one parameter in every table
  612. set @arg00='a' ;
  613. select @arg00 FROM t1 where a=1
  614. union distinct
  615. select @arg00 FROM t1 where a=1;
  616. prepare stmt1 from ' select ? FROM t1 where a=1
  617.                      union distinct
  618.                      select ? FROM t1 where a=1 ';
  619. # BUG#3811 wrong result, prepared statement, union, 
  620. # parameter in result column list
  621. execute stmt1 using @arg00, @arg00;
  622. prepare stmt1 from ' select ? 
  623.                      union distinct
  624.                      select ? ';
  625. execute stmt1 using @arg00, @arg00;
  626. # many parameters
  627. set @arg00='a' ;
  628. set @arg01=1 ;
  629. set @arg02='a' ;
  630. set @arg03=2 ;
  631. select @arg00 FROM t1 where a=@arg01
  632. union distinct
  633. select @arg02 FROM t1 where a=@arg03;
  634. prepare stmt1 from ' select ? FROM t1 where a=?
  635.                      union distinct
  636.                      select ? FROM t1 where a=? ' ;
  637. execute stmt1 using @arg00, @arg01, @arg02, @arg03;
  638. ## increased complexity
  639. set @arg00=1 ;
  640. # Bug#3686 the wrong server response was 1140 Mixing of GROUP columns ..
  641. prepare stmt1 from ' select sum(a) + 200, ? from t1
  642. union distinct
  643. select sum(a) + 200, 1 from t1
  644. group by b ' ;
  645. execute stmt1 using @arg00;
  646. set @Oporto='Oporto' ;
  647. set @Lisboa='Lisboa' ;
  648. set @0=0 ;
  649. set @1=1 ;
  650. set @2=2 ;
  651. set @3=3 ;
  652. set @4=4 ;
  653. select @Oporto,@Lisboa,@0,@1,@2,@3,@4 ;
  654. ## union + group by
  655. select sum(a) + 200 as the_sum, @Oporto as the_town from t1
  656. group by b
  657. union distinct
  658. select sum(a) + 200, @Lisboa from t1
  659. group by b ;
  660. prepare stmt1 from ' select sum(a) + 200 as the_sum, ? as the_town from t1
  661.                      group by b
  662.                      union distinct
  663.                      select sum(a) + 200, ? from t1
  664.                      group by b ' ;
  665. execute stmt1 using @Oporto, @Lisboa;
  666. ## union + where + group by
  667. select sum(a) + 200 as the_sum, @Oporto as the_town from t1
  668. where a > @1
  669. group by b
  670. union distinct
  671. select sum(a) + 200, @Lisboa from t1
  672. where a > @2
  673. group by b ;
  674. prepare stmt1 from ' select sum(a) + 200 as the_sum, ? as the_town from t1
  675.                      where a > ?
  676.                      group by b
  677.                      union distinct
  678.                      select sum(a) + 200, ? from t1
  679.                      where a > ?
  680.                      group by b ' ;
  681. execute stmt1 using @Oporto, @1, @Lisboa, @2;
  682. ## union + where + group by + having
  683. select sum(a) + 200 as the_sum, @Oporto as the_town from t1
  684. where a > @1
  685. group by b
  686. having avg(a) > @2
  687. union distinct
  688. select sum(a) + 200, @Lisboa from t1
  689. where a > @2
  690. group by b 
  691. having avg(a) > @3;
  692. prepare stmt1 from ' select sum(a) + 200 as the_sum, ? as the_town from t1
  693.                      where a > ?
  694.                      group by b
  695.                      having avg(a) > ?
  696.                      union distinct
  697.                      select sum(a) + 200, ? from t1
  698.                      where a > ?
  699.                      group by b
  700.                      having avg(a) > ? ';
  701. execute stmt1 using @Oporto, @1, @2, @Lisboa, @2, @3;
  702. ################ explain select tests ################
  703. --disable_query_log
  704. select '------ explain select tests ------' as test_sequence ;
  705. --enable_query_log
  706. --disable_metadata
  707. # table with many column types
  708. prepare stmt1 from ' explain select * from t9 ' ;
  709. --enable_metadata
  710. execute stmt1;
  711. --disable_metadata