← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysql-test/t/mysqltest.test

  • Committer: brian
  • Date: 2008-06-25 05:29:13 UTC
  • Revision ID: brian@localhost.localdomain-20080625052913-6upwo0jsrl4lnapl
clean slate

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysql-test/t/mysqltest.test
 
1
-- source include/have_log_bin.inc
 
2
 
 
3
# This test should work in embedded server after mysqltest is fixed
 
4
-- source include/not_embedded.inc
 
5
 
 
6
# This test uses chmod, can't be run with root permissions
 
7
-- source include/not_as_root.inc
 
8
 
 
9
# ============================================================================
 
10
#
 
11
# Test of mysqltest itself
 
12
#
 
13
# There are three rules that determines what belong to each command
 
14
# 1. A normal command is delimited by the <delimiter> which by default is
 
15
#    set to ';'
 
16
#
 
17
#   ex: | select *
 
18
#       |   from t1;
 
19
#       |
 
20
#   Command: "select * from t1"
 
21
#
 
22
# 2. Special case is a line that starts with "--", this is a comment
 
23
#    ended when the new line character is reached. But the first word
 
24
#    in the comment may contain a valid command, which then will be
 
25
#    executed. This can be useful when sending commands that
 
26
#    contains <delimiter>
 
27
#
 
28
# 3. Special case is also a line that starts with '#' which is treated
 
29
#     as a comment and will be ended by new line character
 
30
#
 
31
# ============================================================================
 
32
 
 
33
# ----------------------------------------------------------------------------
 
34
# $mysql_errno contains the return code of the last command
 
35
# sent to the server.
 
36
# ----------------------------------------------------------------------------
 
37
# get $mysql_errno before the first statement
 
38
#     $mysql_errno should be -1
 
39
eval select $mysql_errno as "before_use_test" ;
 
40
 
 
41
 
 
42
# ----------------------------------------------------------------------------
 
43
# Positive case(statement)
 
44
# ----------------------------------------------------------------------------
 
45
 
 
46
select otto from (select 1 as otto) as t1;
 
47
# expectation = response
 
48
--error 0
 
49
select otto from (select 1 as otto) as t1;
 
50
 
 
51
# ----------------------------------------------------------------------------
 
52
# Negative case(statement):
 
53
# The derived table t1 does not contain a column named 'friedrich' . 
 
54
# --> ERROR 42S22: Unknown column 'friedrich' in 'field list and
 
55
# --> 1054: Unknown column 'friedrich' in 'field list'
 
56
# ----------------------------------------------------------------------------
 
57
 
 
58
# expectation <> response
 
59
#--error 0
 
60
#select friedrich from (select 1 as otto) as t1
 
61
--error 1
 
62
--exec echo "select friedrich from (select 1 as otto) as t1;" | $MYSQL_TEST  2>&1
 
63
 
 
64
# expectation = response
 
65
--error 1054
 
66
select friedrich from (select 1 as otto) as t1;
 
67
 
 
68
# The following unmasked unsuccessful statement must give
 
69
# 1. mysqltest gives a 'failed'
 
70
# 2. does not produce a r/<test case>.reject file !!!
 
71
# PLEASE uncomment it and check its effect
 
72
#select friedrich from (select 1 as otto) as t1;
 
73
 
 
74
 
 
75
# ----------------------------------------------------------------------------
 
76
# Tests for the new feature - SQLSTATE error code matching
 
77
# Positive case(statement)
 
78
# ----------------------------------------------------------------------------
 
79
 
 
80
# This syntax not allowed anymore, use --error S00000, see below
 
81
# expectation = response
 
82
#!S00000 select otto from (select 1 as otto) as t1;
 
83
 
 
84
--error S00000
 
85
select otto from (select 1 as otto) as t1;
 
86
 
 
87
# expectation <> response
 
88
#!S42S22 select otto from (select 1 as otto) as t1;
 
89
#--error S42S22
 
90
#select otto from (select 1 as otto) as t1;
 
91
--error 1
 
92
--exec echo "error S42S22; select otto from (select 1 as otto) as t1;" | $MYSQL_TEST  2>&1
 
93
 
 
94
 
 
95
 
 
96
# ----------------------------------------------------------------------------
 
97
# Negative case(statement)
 
98
# ----------------------------------------------------------------------------
 
99
 
 
100
# This syntax not allowed anymore, use --error S42S22, see below
 
101
# expectation = response
 
102
#!S42S22 select friedrich from (select 1 as otto) as t1;
 
103
--error S42S22
 
104
select friedrich from (select 1 as otto) as t1;
 
105
 
 
106
# expectation !=response
 
107
#!S00000 select friedrich from (select 1 as otto) as t1;
 
108
#--error S00000
 
109
#select friedrich from (select 1 as otto) as t1;
 
110
--error 1
 
111
--exec echo "error S00000; select friedrich from (select 1 as otto) as t1;" | $MYSQL_TEST  2>&1
 
112
 
 
113
# ----------------------------------------------------------------------------
 
114
# test cases for $mysql_errno
 
115
#
 
116
# $mysql_errno is a builtin variable of mysqltest and contains the return code
 
117
# of the last command sent to the server.
 
118
#
 
119
#      The following test cases often initialize $mysql_errno to 1064 by 
 
120
#      a command with wrong syntax.
 
121
#      Example: --error 1064      To prevent the abort after the error.
 
122
#               garbage ;
 
123
# ----------------------------------------------------------------------------
 
124
 
 
125
# ----------------------------------------------------------------------------
 
126
# check mysql_errno = 0 after successful statement
 
127
# ----------------------------------------------------------------------------
 
128
select otto from (select 1 as otto) as t1;
 
129
eval select $mysql_errno as "after_successful_stmt_errno" ;
 
130
 
 
131
#----------------------------------------------------------------------------
 
132
# check mysql_errno = 1064 after statement with wrong syntax
 
133
# ----------------------------------------------------------------------------
 
134
--error 1064
 
135
garbage ;
 
136
eval select $mysql_errno as "after_wrong_syntax_errno" ;
 
137
 
 
138
# ----------------------------------------------------------------------------
 
139
# check if let $my_var= 'abc' ; affects $mysql_errno
 
140
# ----------------------------------------------------------------------------
 
141
--error 1064
 
142
garbage ;
 
143
let $my_var= 'abc' ;
 
144
eval select $mysql_errno as "after_let_var_equal_value" ;
 
145
 
 
146
# ----------------------------------------------------------------------------
 
147
# check if set @my_var= 'abc' ; affects $mysql_errno
 
148
# ----------------------------------------------------------------------------
 
149
--error 1064
 
150
garbage ;
 
151
set @my_var= 'abc' ;
 
152
eval select $mysql_errno as "after_set_var_equal_value" ;
 
153
 
 
154
# ----------------------------------------------------------------------------
 
155
#  check if the setting of --disable-warnings itself affects $mysql_errno
 
156
#  (May be --<whatever> modifies $mysql_errno.)
 
157
# ----------------------------------------------------------------------------
 
158
--error 1064
 
159
garbage ;
 
160
--disable_warnings
 
161
eval select $mysql_errno as "after_disable_warnings_command" ;
 
162
 
 
163
# ----------------------------------------------------------------------------
 
164
# check if --disable-warnings + command with warning affects the errno
 
165
# stored within $mysql_errno
 
166
# (May be disabled warnings affect $mysql_errno.)
 
167
# ----------------------------------------------------------------------------
 
168
drop table if exists t1 ;
 
169
--error 1064
 
170
garbage ;
 
171
drop table if exists t1 ;
 
172
eval select $mysql_errno as "after_disable_warnings" ;
 
173
--enable_warnings
 
174
 
 
175
# ----------------------------------------------------------------------------
 
176
# check if masked errors affect $mysql_errno
 
177
# ----------------------------------------------------------------------------
 
178
--error 1064
 
179
garbage ;
 
180
--error 1146
 
181
select 3 from t1 ;
 
182
eval select $mysql_errno as "after_minus_masked" ;
 
183
--error 1064
 
184
garbage ;
 
185
--error 1146
 
186
select 3 from t1 ;
 
187
eval select $mysql_errno as "after_!_masked" ;
 
188
 
 
189
# ----------------------------------------------------------------------------
 
190
# Will manipulations of $mysql_errno be possible and visible ?
 
191
# ----------------------------------------------------------------------------
 
192
--error 1064
 
193
garbage ;
 
194
let $mysql_errno= -1;
 
195
eval select $mysql_errno as "after_let_errno_equal_value" ;
 
196
 
 
197
# ----------------------------------------------------------------------------
 
198
# How affect actions on prepared statements $mysql_errno ?
 
199
# ----------------------------------------------------------------------------
 
200
# failing prepare
 
201
--error 1064
 
202
garbage ;
 
203
--error 1146
 
204
prepare stmt from "select 3 from t1" ;
 
205
eval select $mysql_errno as "after_failing_prepare" ;
 
206
create table t1 ( f1 char(10));
 
207
 
 
208
# successful prepare
 
209
--error 1064
 
210
garbage ;
 
211
prepare stmt from "select 3 from t1" ;
 
212
eval select $mysql_errno as "after_successful_prepare" ;
 
213
 
 
214
# successful execute
 
215
--error 1064
 
216
garbage ;
 
217
execute stmt;
 
218
eval select $mysql_errno as "after_successful_execute" ;
 
219
 
 
220
# failing execute (table has been dropped)
 
221
drop table t1;
 
222
--error 1064
 
223
garbage ;
 
224
--error 1146
 
225
execute stmt;
 
226
eval select $mysql_errno as "after_failing_execute" ;
 
227
 
 
228
# failing execute (unknown statement)
 
229
--error 1064
 
230
garbage ;
 
231
--error 1243
 
232
execute __stmt_;
 
233
eval select $mysql_errno as "after_failing_execute" ;
 
234
 
 
235
# successful deallocate
 
236
--error 1064
 
237
garbage ;
 
238
deallocate prepare stmt;
 
239
eval select $mysql_errno as "after_successful_deallocate" ;
 
240
 
 
241
# failing deallocate ( statement handle does not exist )
 
242
--error 1064
 
243
garbage ;
 
244
--error 1243
 
245
deallocate prepare __stmt_;
 
246
eval select $mysql_errno as "after_failing_deallocate" ;
 
247
 
 
248
 
 
249
# ----------------------------------------------------------------------------
 
250
# test cases for "--disable_abort_on_error"
 
251
#
 
252
# "--disable_abort_on_error" switches off the abort of mysqltest
 
253
# after "unmasked" failing statements.
 
254
#
 
255
# The default is "--enable_abort_on_error".
 
256
#
 
257
# "Maskings" are
 
258
#   --error <error number>  and  --error <error number>
 
259
# in the line before the failing statement.
 
260
#
 
261
# There are some additional test cases for $mysql_errno
 
262
# because "--disable_abort_on_error" enables a new situation.
 
263
# Example: "unmasked" statement fails + analysis of $mysql_errno
 
264
# ----------------------------------------------------------------------------
 
265
 
 
266
# ----------------------------------------------------------------------------
 
267
# Switch off the abort on error and check the effect on $mysql_errno
 
268
# ----------------------------------------------------------------------------
 
269
--error 1064
 
270
garbage ;
 
271
--disable_abort_on_error
 
272
eval select $mysql_errno as "after_--disable_abort_on_error" ;
 
273
 
 
274
# ----------------------------------------------------------------------------
 
275
# "unmasked" failing statement should not cause an abort
 
276
# ----------------------------------------------------------------------------
 
277
select 3 from t1 ;
 
278
 
 
279
# ----------------------------------------------------------------------------
 
280
# masked failing statements
 
281
# ----------------------------------------------------------------------------
 
282
# expected error = response
 
283
--error 1146
 
284
select 3 from t1 ;
 
285
--error 1146
 
286
select 3 from t1 ;
 
287
eval select $mysql_errno as "after_!errno_masked_error" ;
 
288
# expected error <> response
 
289
# --error 1000
 
290
# select 3 from t1 ;
 
291
# --error 1000
 
292
# select 3 from t1 ;
 
293
--error 1
 
294
--exec echo "disable_abort_on_error; error 1000; select 3 from t1; error 1000; select 3 from t1;" | $MYSQL_TEST  2>&1
 
295
 
 
296
# ----------------------------------------------------------------------------
 
297
# Switch the abort on error on and check the effect on $mysql_errno
 
298
# ----------------------------------------------------------------------------
 
299
--error 1064
 
300
garbage ;
 
301
--enable_abort_on_error
 
302
eval select $mysql_errno as "after_--enable_abort_on_error" ;
 
303
 
 
304
# ----------------------------------------------------------------------------
 
305
# masked failing statements
 
306
# ----------------------------------------------------------------------------
 
307
# expected error = response
 
308
--error 1146
 
309
select 3 from t1 ;
 
310
 
 
311
# ----------------------------------------------------------------------------
 
312
# check that the old default behaviour is not changed
 
313
# Please remove the '#' to get the abort on error
 
314
# ----------------------------------------------------------------------------
 
315
#--error 1064
 
316
#select 3 from t1 ;
 
317
#
 
318
#select 3 from t1 ;
 
319
 
 
320
--error 1
 
321
--exec echo "disable_abort_on_error; enable_abort_on_error; error 1064; select 3 from t1; select 3 from t1;" | $MYSQL_TEST  2>&1
 
322
 
 
323
 
 
324
# ----------------------------------------------------------------------------
 
325
# Test comments
 
326
# ----------------------------------------------------------------------------
 
327
 
 
328
# This is a comment
 
329
# This is a ;  comment
 
330
# This is a -- comment
 
331
# -- This is also a comment
 
332
# -- # This is also a comment
 
333
# -- This is also a ; comment
 
334
 
 
335
# ----------------------------------------------------------------------------
 
336
# Test comments with embedded command
 
337
# ----------------------------------------------------------------------------
 
338
 
 
339
--echo hello
 
340
--     echo hello
 
341
--    echo ;;;;;;;;
 
342
 
 
343
--echo # MySQL: -- The
 
344
 
 
345
# ----------------------------------------------------------------------------
 
346
# Test detect end of line "junk"
 
347
# Most likely caused by a missing delimiter
 
348
# ----------------------------------------------------------------------------
 
349
 
 
350
# Too many parameters to function
 
351
--error 1
 
352
--exec echo "sleep 5 6;" | $MYSQL_TEST 2>&1
 
353
 
 
354
# Too many parameters to function
 
355
--error 1
 
356
--exec echo "--sleep 5 6" | $MYSQL_TEST 2>&1
 
357
 
 
358
#
 
359
# Missing delimiter
 
360
# The comment will be "sucked into" the sleep command since
 
361
# delimiter is missing until after "show status"
 
362
--write_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql
 
363
sleep 4
 
364
# A comment
 
365
show status;
 
366
EOF
 
367
--error 1
 
368
--exec $MYSQL_TEST < $MYSQLTEST_VARDIR/tmp/mysqltest.sql 2>&1
 
369
remove_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql;
 
370
 
 
371
#
 
372
# Missing delimiter until eof
 
373
# The comment will be "sucked into" the sleep command since
 
374
# delimiter is missing
 
375
--write_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql
 
376
sleep 7
 
377
# Another comment
 
378
EOF
 
379
--error 1
 
380
--exec $MYSQL_TEST < $MYSQLTEST_VARDIR/tmp/mysqltest.sql 2>&1
 
381
remove_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql;
 
382
 
 
383
#
 
384
# Missing delimiter until "disable_query_log"
 
385
#
 
386
--write_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql
 
387
disconnect default
 
388
 
 
389
#
 
390
# comment
 
391
# comment 3
 
392
disable_query_log;
 
393
EOF
 
394
--error 1
 
395
--exec $MYSQL_TEST < $MYSQLTEST_VARDIR/tmp/mysqltest.sql 2>&1
 
396
remove_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql;
 
397
 
 
398
#
 
399
# Missing delimiter until "disable_query_log"
 
400
#
 
401
--write_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql
 
402
disconnect default
 
403
 
 
404
#
 
405
# comment
 
406
 
 
407
# comment 3
 
408
disable_query_log;
 
409
EOF
 
410
--error 1
 
411
--exec $MYSQL_TEST < $MYSQLTEST_VARDIR/tmp/mysqltest.sql 2>&1
 
412
remove_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql;
 
413
 
 
414
#
 
415
# Missing delimiter until eof
 
416
#
 
417
--write_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql
 
418
disconnect default
 
419
 
 
420
#
 
421
# comment
 
422
# comment2
 
423
 
 
424
# comment 3
 
425
--disable_query_log
 
426
EOF
 
427
--error 1
 
428
--exec $MYSQL_TEST < $MYSQLTEST_VARDIR/tmp/mysqltest.sql 2>&1
 
429
remove_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql;
 
430
 
 
431
#
 
432
# Missing delimiter until eof
 
433
#
 
434
--write_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql
 
435
disconnect default # comment
 
436
# comment part2
 
437
 
 
438
# comment 3
 
439
--disable_query_log
 
440
EOF
 
441
--error 1
 
442
--exec $MYSQL_TEST < $MYSQLTEST_VARDIR/tmp/mysqltest.sql 2>&1
 
443
 
 
444
remove_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql;
 
445
 
 
446
#
 
447
# Extra delimiter
 
448
#
 
449
--error 1
 
450
--exec echo "--sleep 4;" | $MYSQL_TEST 2>&1
 
451
--error 1
 
452
--exec echo "--disable_query_log;" | $MYSQL_TEST 2>&1
 
453
 
 
454
 
 
455
# Allow trailing # comment
 
456
--sleep 1 # Wait for insert delayed to be executed.
 
457
--sleep 1        # Wait for insert delayed to be executed.
 
458
 
 
459
# ----------------------------------------------------------------------------
 
460
# Test error
 
461
# ----------------------------------------------------------------------------
 
462
 
 
463
# Missing argument
 
464
--error 1
 
465
--exec echo "error;" | $MYSQL_TEST 2>&1
 
466
--error 1
 
467
--exec echo "--error" | $MYSQL_TEST 2>&1
 
468
 
 
469
# First char must be uppercase 'S' or 'E' or [0-9]
 
470
--error 1
 
471
--exec echo "--error s99999" | $MYSQL_TEST 2>&1
 
472
--error 1
 
473
--exec echo "--error e99999" | $MYSQL_TEST 2>&1
 
474
--error 1
 
475
--exec echo "--error 9eeeee" | $MYSQL_TEST 2>&1
 
476
--error 1
 
477
--exec echo "--error 1sssss" | $MYSQL_TEST 2>&1
 
478
 
 
479
# First char 'S' but too long
 
480
--error 1
 
481
--exec echo "--error S999999" | $MYSQL_TEST 2>&1
 
482
 
 
483
# First char 'S' but lowercase char found
 
484
--error 1
 
485
--exec echo "--error S99a99" | $MYSQL_TEST 2>&1
 
486
 
 
487
# First char 'S' but too short
 
488
--error 1
 
489
--exec echo "--error S9999" | $MYSQL_TEST 2>&1
 
490
 
 
491
# First char 'E' but not found in error array
 
492
--error 1
 
493
--exec echo "--error E9999" | $MYSQL_TEST 2>&1
 
494
 
 
495
# First char [0-9] but contains chars
 
496
--error 1
 
497
--exec echo "--error 999e9" | $MYSQL_TEST 2>&1
 
498
--error 1
 
499
--exec echo "--error 9b" | $MYSQL_TEST 2>&1
 
500
 
 
501
# Multiple errorcodes separated by ','
 
502
--error 1,1,1,1
 
503
#--error 9,ER_PARSE_ERROR
 
504
#--error ER_PARSE_ERROR
 
505
#--error 9,ER_PARSE_ERROR,9,ER_PARSE_ERROR
 
506
#--error 9, ER_PARSE_ERROR,  9,   ER_PARSE_ERROR
 
507
#--error 9,S00000,9,ER_PARSE_ERROR
 
508
#--error 9,S00000,9,ER_PARSE_ERROR,ER_PARSE_ERROR,ER_PARSE_ERROR,9,10,11,12
 
509
--error 9,S00000,9
 
510
--error 9,S00000,9,9,10,11,12
 
511
--error 9 ,10
 
512
--error 9 , 10
 
513
--error    9   ,   10
 
514
--error    9   ,   10
 
515
 
 
516
# Too many errorcodes specified
 
517
--error 1
 
518
--exec echo "--error 1,2,3,4,5,6,7,8,9,10,11" | $MYSQL_TEST 2>&1
 
519
 
 
520
 
 
521
# ----------------------------------------------------------------------------
 
522
# Test echo command
 
523
# ----------------------------------------------------------------------------
 
524
 
 
525
echo MySQL;
 
526
echo "MySQL";
 
527
echo MySQL: The world''s most popular open source database;
 
528
echo "MySQL: The world's most popular open source database";
 
529
 
 
530
echo MySQL: The world''s
 
531
     most popular open
 
532
     source database;
 
533
 
 
534
echo # MySQL: The world''s
 
535
# most popular open
 
536
# source database;
 
537
 
 
538
echo - MySQL: The world''s
 
539
- most popular open
 
540
- source database;
 
541
 
 
542
echo - MySQL: The world''s
 
543
-- most popular
 
544
-- open source database;
 
545
 
 
546
echo # MySQL: The
 
547
--world''s
 
548
# most popular
 
549
-- open
 
550
- source database;
 
551
 
 
552
echo "MySQL: The world's most popular; open source database";
 
553
echo "MySQL: The world's most popular ; open source database";
 
554
echo "MySQL: The world's most popular ;open source database";
 
555
echo echo message echo message;
 
556
 
 
557
 
 
558
echo ;
 
559
 
 
560
# Illegal use of echo
 
561
 
 
562
#--error 1
 
563
#--exec echo "echo \$;" | $MYSQL_TEST 2>&1
 
564
 
 
565
 
 
566
# ----------------------------------------------------------------------------
 
567
# Test exec command
 
568
# ----------------------------------------------------------------------------
 
569
 
 
570
# Illegal use of exec
 
571
--error 1
 
572
--exec echo "--exec false" | $MYSQL_TEST 2>&1
 
573
 
 
574
--error 1
 
575
--exec echo "--exec " | $MYSQL_TEST 2>&1
 
576
 
 
577
# ----------------------------------------------------------------------------
 
578
# Test let command
 
579
# ----------------------------------------------------------------------------
 
580
 
 
581
let $message=MySQL;
 
582
echo $message;
 
583
 
 
584
let $message="MySQL";
 
585
echo $message;
 
586
 
 
587
let $message= MySQL: The
 
588
 world''s most
 
589
 popular open
 
590
 source database;
 
591
echo $message;
 
592
 
 
593
let $message= # MySQL: The
 
594
# world''s most
 
595
# popular open
 
596
# source database;
 
597
echo $message;
 
598
 
 
599
let $message=  -- MySQL: The
 
600
-- world''s most
 
601
-- popular
 
602
-- open source database;
 
603
echo $message;
 
604
 
 
605
let $message=  # MySQL: The
 
606
- world''s most
 
607
-- popular open
 
608
# source database;
 
609
echo $message;
 
610
 
 
611
echo '$message';
 
612
echo "$message";
 
613
 
 
614
let $1=hej;
 
615
echo $1;
 
616
 
 
617
let   $1   =hej ;
 
618
echo $1;
 
619
 
 
620
let $1 = hej;
 
621
echo $1;
 
622
 
 
623
let $1=1;
 
624
let $2=$1;
 
625
echo $2;
 
626
let $5=$6;
 
627
echo $5;
 
628
echo $6;
 
629
 
 
630
let $where=a long variable content;
 
631
echo $where;
 
632
 
 
633
let $where2= $where;
 
634
echo $where2;
 
635
 
 
636
let $where3=a long $where variable content;
 
637
echo $where3;
 
638
 
 
639
let $where3=a long \\\$where variable content;
 
640
echo $where3;
 
641
 
 
642
let $novar1= $novar2;
 
643
echo $novar1;
 
644
 
 
645
let $cat=na;
 
646
let $cat=ba$cat$cat;
 
647
echo banana = $cat;
 
648
 
 
649
# ba\$cat\$cat should have been sufficient.
 
650
# ba\\\$cat\\\$cat -> ba\$cat\$cat -> ba$cat$cat -> banana
 
651
# Magnus' upcoming patch will fix the missing second interpretation.
 
652
let $cat=ba\\\$cat\\\$cat;
 
653
echo Not a banana: $cat;
 
654
 
 
655
 
 
656
# Test illegal uses of let
 
657
 
 
658
--error 1
 
659
--exec echo "let ;" | $MYSQL_TEST 2>&1
 
660
 
 
661
--error 1
 
662
--exec echo "let \$=hi;" | $MYSQL_TEST  2>&1
 
663
 
 
664
--error 1
 
665
--exec echo "let \$1 hi;" | $MYSQL_TEST  2>&1
 
666
 
 
667
--error 1
 
668
--exec echo "let \$m hi;" | $MYSQL_TEST  2>&1
 
669
 
 
670
--error 1
 
671
--exec echo "let \$hi;" | $MYSQL_TEST  2>&1
 
672
 
 
673
--error 1
 
674
--exec echo "let \$ hi;" | $MYSQL_TEST  2>&1
 
675
 
 
676
--error 1
 
677
--exec echo "let =hi;" | $MYSQL_TEST  2>&1
 
678
 
 
679
--error 1
 
680
--exec echo "let hi;" | $MYSQL_TEST  2>&1
 
681
 
 
682
# More advanced test for bug#17280
 
683
let $success= 1;
 
684
--echo # Execute: --echo # <whatever> success: \$success
 
685
--echo # <whatever> success: $success
 
686
--echo # Execute: echo # <whatever> success: \$success ;
 
687
echo # <whatever> success: $success ;
 
688
 
 
689
--echo # The next two variants work fine and expand the content of \$success
 
690
--echo # Execute: --echo \$success
 
691
--echo $success
 
692
--echo # Execute: echo \$success ;
 
693
echo $success ;
 
694
 
 
695
 
 
696
# ----------------------------------------------------------------------------
 
697
# Test to assign let from variable
 
698
# let $<var_name>=$<var_name>;
 
699
# ----------------------------------------------------------------------------
 
700
 
 
701
--echo # Check if let \$B = \$A is an assignment per value.
 
702
 
 
703
# Basic preparations:
 
704
--echo let \$A = initial value of A;
 
705
let $A = initial value of A;
 
706
# --echo # Content of \$A is: $A
 
707
--echo let \$B = initial value of B;
 
708
let $B = initial value of B;
 
709
# --echo # Content of \$B is: $B
 
710
 
 
711
# Assign $B to $A:
 
712
--echo let \$B = \$A
 
713
let $A = $B;
 
714
--echo # Content of \$A is: $A
 
715
 
 
716
# Changes of $B must NOT affect $A and Changes of $A must NOT affect $B !
 
717
--echo let \$A = changed value of A;
 
718
let $A = changed value of A;
 
719
--echo # Content of \$B is: $B
 
720
 
 
721
--echo let \$B = changed value of B;
 
722
let $B = changed value of B;
 
723
--echo # Content of \$A is: $A
 
724
 
 
725
# ----------------------------------------------------------------------------
 
726
# Test let from query with $variable
 
727
# let $<var_name>=`<query with $variable>`;
 
728
# ----------------------------------------------------------------------------
 
729
 
 
730
let $var1=content of variable 1;
 
731
let $var2= `select "$var1"`;
 
732
let $var3= `select concat("$var1", " ", "$var2")`;
 
733
echo var2: $var2;
 
734
echo var3: $var3;
 
735
if (`select length("$var3") > 0`)
 
736
{
 
737
  echo length of var3 is longer than 0;
 
738
}
 
739
 
 
740
# ----------------------------------------------------------------------------
 
741
# Test to assign let from query
 
742
# let $<var_name>=`<query>`;
 
743
# ----------------------------------------------------------------------------
 
744
echo var1;
 
745
let $var1= `select "hi" as "Col", 1 as "Column1", "hi there" as Col3`;
 
746
echo $var1;
 
747
 
 
748
echo var2;
 
749
let $var2= `select 2 as "Column num 2"`;
 
750
echo $var2;
 
751
 
 
752
echo var2 again;
 
753
let $var2= `select 2 as "Column num 2"`;
 
754
echo $var2;
 
755
 
 
756
echo var3 two columns with same name;
 
757
let $var3= `select 1 as "Col", 2 as "Col", 3 as "var3"`;
 
758
echo $var3;
 
759
 
 
760
echo var4 from query that returns NULL;
 
761
let $var4= `select NULL`;
 
762
 
 
763
echo var5 from query that returns no row;
 
764
let $var5= `SHOW VARIABLES LIKE "nonexisting_variable"`;
 
765
 
 
766
echo failing query in let;
 
767
--write_file $MYSQLTEST_VARDIR/tmp/let.sql
 
768
let $var2= `failing query`;
 
769
echo $var2;
 
770
EOF
 
771
 
 
772
--error 1
 
773
--exec $MYSQL_TEST < $MYSQLTEST_VARDIR/tmp/let.sql 2>&1
 
774
 
 
775
remove_file $MYSQLTEST_VARDIR/tmp/let.sql;
 
776
 
 
777
 
 
778
# ----------------------------------------------------------------------------
 
779
# Test source command
 
780
# ----------------------------------------------------------------------------
 
781
 
 
782
# Test illegal uses of source
 
783
 
 
784
--error 1
 
785
--exec echo "source ;" | $MYSQL_TEST 2>&1
 
786
 
 
787
# Fix win paths
 
788
--replace_result \\ /
 
789
# Source a nonexisting file
 
790
--error 1
 
791
--exec echo "source non_existingFile;" | $MYSQL_TEST 2>&1
 
792
 
 
793
# Too many source
 
794
--exec echo "source $MYSQLTEST_VARDIR/tmp/recursive.sql;" > $MYSQLTEST_VARDIR/tmp/recursive.sql
 
795
--replace_result $MYSQLTEST_VARDIR MYSQLTEST_VARDIR
 
796
--error 1
 
797
--exec echo "source $MYSQLTEST_VARDIR/tmp/recursive.sql;" | $MYSQL_TEST 2>&1
 
798
remove_file $MYSQLTEST_VARDIR/tmp/recursive.sql;
 
799
 
 
800
# Source a file with error
 
801
--exec echo "garbage ;" > $MYSQLTEST_VARDIR/tmp/error.sql
 
802
--replace_result $MYSQLTEST_VARDIR MYSQLTEST_VARDIR
 
803
--error 1
 
804
--exec echo "source $MYSQLTEST_VARDIR/tmp/error.sql;" | $MYSQL_TEST 2>&1
 
805
 
 
806
remove_file $MYSQLTEST_VARDIR/tmp/error.sql;
 
807
 
 
808
# Test execution of source in a while loop
 
809
--write_file $MYSQLTEST_VARDIR/tmp/sourced.inc
 
810
echo here is the sourced script;
 
811
EOF
 
812
--disable_query_log
 
813
let $outer= 2; # Number of outer loops
 
814
while ($outer)
 
815
{
 
816
  eval SELECT '$outer = outer loop variable after while' AS "";
 
817
 
 
818
  --source $MYSQLTEST_VARDIR/tmp/sourced.inc
 
819
 
 
820
  eval SELECT '$outer = outer loop variable before dec' AS "";
 
821
  dec $outer;
 
822
  eval SELECT '$outer = outer loop variable after dec' AS "";
 
823
}
 
824
 
 
825
let $outer= 2; # Number of outer loops
 
826
while ($outer)
 
827
{
 
828
  eval SELECT '$outer = outer loop variable after while' AS "";
 
829
 
 
830
  echo here is the sourced script;
 
831
 
 
832
  eval SELECT '$outer = outer loop variable before dec' AS "";
 
833
  dec $outer;
 
834
  eval SELECT '$outer = outer loop variable after dec' AS "";
 
835
}
 
836
 
 
837
 
 
838
# Test execution of source in a while loop
 
839
--disable_abort_on_error
 
840
# Sourcing of a file within while loop, sourced file will
 
841
# source other file
 
842
let $num= 9;
 
843
while ($num)
 
844
{
 
845
   SELECT 'In loop' AS "";
 
846
   --source $MYSQLTEST_VARDIR/tmp/sourced.inc
 
847
   dec $num;
 
848
}
 
849
--enable_abort_on_error
 
850
--enable_query_log
 
851
 
 
852
# Test source $variable/<filename>
 
853
--source $MYSQLTEST_VARDIR/tmp/sourced.inc
 
854
 
 
855
--remove_file $MYSQLTEST_VARDIR/tmp/sourced.inc
 
856
 
 
857
--write_file $MYSQLTEST_VARDIR/tmp/sourced.inc
 
858
echo "hello";
 
859
EOF
 
860
 
 
861
let $x= sourced;
 
862
source $MYSQLTEST_VARDIR/tmp/$x.inc;
 
863
 
 
864
let $x= $MYSQLTEST_VARDIR;
 
865
source $x/tmp/sourced.inc;
 
866
 
 
867
--remove_file $MYSQLTEST_VARDIR/tmp/sourced.inc
 
868
 
 
869
 
 
870
# ----------------------------------------------------------------------------
 
871
# Test sleep command
 
872
# ----------------------------------------------------------------------------
 
873
 
 
874
sleep 0.5;
 
875
sleep 1;
 
876
real_sleep 1;
 
877
 
 
878
# Missing parameter
 
879
--error 1
 
880
--exec echo "sleep ;" | $MYSQL_TEST 2>&1
 
881
--error 1
 
882
--exec echo "real_sleep ;" | $MYSQL_TEST 2>&1
 
883
 
 
884
# Illegal parameter
 
885
--error 1
 
886
--exec echo "sleep abc;" | $MYSQL_TEST 2>&1
 
887
--error 1
 
888
--exec echo "real_sleep abc;" | $MYSQL_TEST 2>&1
 
889
 
 
890
# ----------------------------------------------------------------------------
 
891
# Test inc
 
892
# ----------------------------------------------------------------------------
 
893
inc $i;
 
894
echo $i;
 
895
inc $i;
 
896
echo $i;
 
897
let $i=100;
 
898
inc $i;
 
899
echo $i;
 
900
 
 
901
let $i=hej;
 
902
echo $i;
 
903
inc $i;
 
904
echo $i;
 
905
 
 
906
--error 1
 
907
--exec echo "inc;" | $MYSQL_TEST 2>&1
 
908
--error 1
 
909
--exec echo "inc i;" | $MYSQL_TEST 2>&1
 
910
--error 1
 
911
--exec echo "let \$i=100; inc \$i 1000; echo \$i;" | $MYSQL_TEST 2>&1
 
912
 
 
913
inc $i; inc $i; inc $i; --echo $i
 
914
echo $i;
 
915
 
 
916
 
 
917
# ----------------------------------------------------------------------------
 
918
# Test dec
 
919
# ----------------------------------------------------------------------------
 
920
 
 
921
dec $d;
 
922
echo $d;
 
923
dec $d;
 
924
echo $d;
 
925
let $d=100;
 
926
dec $d;
 
927
echo $d;
 
928
 
 
929
let $d=hej;
 
930
echo $d;
 
931
dec $d;
 
932
echo $d;
 
933
 
 
934
--error 1
 
935
--exec echo "dec;" | $MYSQL_TEST 2>&1
 
936
--error 1
 
937
--exec echo "dec i;" | $MYSQL_TEST 2>&1
 
938
--error 1
 
939
--exec echo "let \$i=100; dec \$i 1000; echo \$i;" | $MYSQL_TEST 2>&1
 
940
 
 
941
 
 
942
# ----------------------------------------------------------------------------
 
943
# Test system
 
944
# ----------------------------------------------------------------------------
 
945
#system ls > /dev/null;
 
946
system echo "hej" > /dev/null;
 
947
#--system ls > /dev/null
 
948
--system echo "hej" > /dev/null;
 
949
 
 
950
--error 1
 
951
--exec echo "system;" | $MYSQL_TEST 2>&1
 
952
--error 1
 
953
--exec echo "system $NONEXISTSINFVAREABLI;" | $MYSQL_TEST 2>&1
 
954
--error 1
 
955
--exec echo "system false;" | $MYSQL_TEST 2>&1
 
956
 
 
957
--disable_abort_on_error
 
958
system NonExistsinfComamdn 2> /dev/null;
 
959
--enable_abort_on_error
 
960
 
 
961
 
 
962
# ----------------------------------------------------------------------------
 
963
# Test delimiter
 
964
# ----------------------------------------------------------------------------
 
965
 
 
966
delimiter stop;
 
967
echo teststop
 
968
delimiter ;stop
 
969
echo test2;
 
970
--delimiter stop
 
971
echo test3stop
 
972
--delimiter ;
 
973
echo test4;
 
974
 
 
975
 
 
976
# ----------------------------------------------------------------------------
 
977
# Test if
 
978
# ----------------------------------------------------------------------------
 
979
 
 
980
let $counter=10;
 
981
if ($counter)
 
982
{
 
983
  echo Counter is greater than 0, (counter=10);
 
984
}
 
985
if (!$counter)
 
986
{
 
987
  echo Counter is not 0, (counter=10);
 
988
}
 
989
let $counter=0;
 
990
if($counter)
 
991
{
 
992
  echo Counter is greater than 0, (counter=0);
 
993
}
 
994
if (!$counter)
 
995
{
 
996
  echo Counter is not 0, (counter=0);
 
997
}
 
998
 
 
999
# ----------------------------------------------------------------------------
 
1000
# Test while, { and }
 
1001
# ----------------------------------------------------------------------------
 
1002
 
 
1003
let $i=1;
 
1004
while ($i)
 
1005
{
 
1006
  echo $i;
 
1007
  dec $i;
 
1008
}
 
1009
# One liner
 
1010
#let $i=1;while ($i){echo $i;dec $i;}
 
1011
 
 
1012
let $i=0;
 
1013
while (!$i)
 
1014
{
 
1015
  echo Testing while with not;
 
1016
  inc $i;
 
1017
}
 
1018
 
 
1019
# Exceed max nesting level
 
1020
--write_file $MYSQLTEST_VARDIR/tmp/mysqltest_while.inc
 
1021
let $1 = 10;
 
1022
while ($1)
 
1023
{
 
1024
while ($1)
 
1025
{
 
1026
while ($1)
 
1027
{
 
1028
 while ($1)
 
1029
{
 
1030
 while ($1)
 
1031
{
 
1032
 while ($1)
 
1033
{
 
1034
 while ($1)
 
1035
{
 
1036
 while ($1)
 
1037
{
 
1038
 while ($1)
 
1039
{
 
1040
 while ($1)
 
1041
{
 
1042
 while ($1)
 
1043
{
 
1044
 while ($1)
 
1045
{
 
1046
 while ($1)
 
1047
{
 
1048
 while ($1)
 
1049
{
 
1050
 while ($1)
 
1051
{
 
1052
 while ($1)
 
1053
{
 
1054
 while ($1)
 
1055
{
 
1056
 while ($1)
 
1057
{
 
1058
 while ($1)
 
1059
{
 
1060
 while ($1)
 
1061
{
 
1062
 while ($1)
 
1063
{
 
1064
 while ($1)
 
1065
{
 
1066
 while ($1)
 
1067
{
 
1068
 while ($1)
 
1069
{
 
1070
 while ($1)
 
1071
{
 
1072
 while ($1)
 
1073
{
 
1074
 while ($1)
 
1075
{
 
1076
 while ($1)
 
1077
{
 
1078
 while ($1)
 
1079
{
 
1080
 while ($1)
 
1081
{
 
1082
 while ($1)
 
1083
{
 
1084
 while ($1)
 
1085
{
 
1086
 while ($1)
 
1087
{
 
1088
 while ($1)
 
1089
{
 
1090
 while ($1)
 
1091
{
 
1092
 while ($1)
 
1093
{
 
1094
 while ($1)
 
1095
{
 
1096
 while ($1)
 
1097
{
 
1098
 while ($1)
 
1099
{
 
1100
 while ($1)
 
1101
{
 
1102
 while ($1)
 
1103
{
 
1104
 while ($1)
 
1105
{
 
1106
 while ($1)
 
1107
{
 
1108
 while ($1)
 
1109
{
 
1110
 while ($1)
 
1111
{
 
1112
 while ($1)
 
1113
{
 
1114
 while ($1)
 
1115
{
 
1116
 while ($1)
 
1117
{
 
1118
 while ($1)
 
1119
{
 
1120
  echo $1;
 
1121
  dec $1;
 
1122
}
 
1123
}
 
1124
}
 
1125
}
 
1126
}
 
1127
}
 
1128
}
 
1129
}
 
1130
}
 
1131
}
 
1132
}
 
1133
}
 
1134
}
 
1135
}
 
1136
}
 
1137
}
 
1138
}
 
1139
}
 
1140
}
 
1141
}
 
1142
}
 
1143
}
 
1144
}
 
1145
}
 
1146
}
 
1147
}
 
1148
}
 
1149
}
 
1150
}
 
1151
}
 
1152
}
 
1153
}
 
1154
}
 
1155
}
 
1156
}
 
1157
}
 
1158
EOF
 
1159
# Fix win path
 
1160
--replace_result \\ / $MYSQLTEST_VARDIR MYSQLTEST_VARDIR
 
1161
--error 1
 
1162
--exec echo "source $MYSQLTEST_VARDIR/tmp/mysqltest_while.inc;" | $MYSQL_TEST 2>&1
 
1163
--remove_file $MYSQLTEST_VARDIR/tmp/mysqltest_while.inc
 
1164
--error 1
 
1165
--exec echo "while \$i;" | $MYSQL_TEST 2>&1
 
1166
--error 1
 
1167
--exec echo "while (\$i;" | $MYSQL_TEST 2>&1
 
1168
--error 1
 
1169
--exec echo "let \$i=1; while (\$i) dec \$i;" | $MYSQL_TEST 2>&1
 
1170
--error 1
 
1171
--exec echo "};" | $MYSQL_TEST 2>&1
 
1172
--error 1
 
1173
--exec echo "end;" | $MYSQL_TEST 2>&1
 
1174
--error 1
 
1175
--exec echo "{;" | $MYSQL_TEST 2>&1
 
1176
 
 
1177
--write_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql
 
1178
while (0)
 
1179
echo hej;
 
1180
EOF
 
1181
--error 1
 
1182
--exec $MYSQL_TEST < $MYSQLTEST_VARDIR/tmp/mysqltest.sql 2>&1
 
1183
remove_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql;
 
1184
 
 
1185
--write_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql
 
1186
while (0)
 
1187
{echo hej;
 
1188
EOF
 
1189
--error 1
 
1190
--exec $MYSQL_TEST < $MYSQLTEST_VARDIR/tmp/mysqltest.sql 2>&1
 
1191
remove_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql;
 
1192
 
 
1193
--write_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql
 
1194
while (0){
 
1195
 echo hej;
 
1196
EOF
 
1197
--error 1
 
1198
--exec $MYSQL_TEST < $MYSQLTEST_VARDIR/tmp/mysqltest.sql 2>&1
 
1199
 
 
1200
remove_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql;
 
1201
 
 
1202
# ----------------------------------------------------------------------------
 
1203
# Test error messages returned from comments starting with a command
 
1204
# ----------------------------------------------------------------------------
 
1205
--error 1
 
1206
--exec echo "--if the other server is down" | $MYSQL_TEST 2>&1
 
1207
 
 
1208
--error 1
 
1209
--exec echo "-- end when ..." | $MYSQL_TEST 2>&1
 
1210
 
 
1211
# ----------------------------------------------------------------------------
 
1212
# Test replace
 
1213
# ----------------------------------------------------------------------------
 
1214
--replace_result a b
 
1215
select "a" as col1, "c" as col2;
 
1216
 
 
1217
--replace_result a b c d
 
1218
select "a" as col1, "c" as col2;
 
1219
 
 
1220
--error 1
 
1221
--exec echo "--replace_result a" | $MYSQL_TEST 2>&1
 
1222
--error 1
 
1223
--exec echo "--replace_result a;" | $MYSQL_TEST 2>&1
 
1224
--error 1
 
1225
--exec echo "replace_result a;" | $MYSQL_TEST 2>&1
 
1226
--error 1
 
1227
--exec echo "replace_result a ;" | $MYSQL_TEST 2>&1
 
1228
--exec echo "replace_result a b; echo OK;" | $MYSQL_TEST 2>&1
 
1229
--error 1
 
1230
--exec echo "--replace_result a b c" | $MYSQL_TEST 2>&1
 
1231
--error 1
 
1232
--exec echo "replace_result a b c ;" | $MYSQL_TEST 2>&1
 
1233
 
 
1234
 
 
1235
--replace_column 1 b
 
1236
select "a" as col1, "c" as col2;
 
1237
 
 
1238
--replace_column 1 b 2 d
 
1239
select "a" as col1, "c" as col2;
 
1240
 
 
1241
--error 1
 
1242
--exec echo "--replace_column a" | $MYSQL_TEST 2>&1
 
1243
 
 
1244
--error 1
 
1245
--exec echo "--replace_column 1" | $MYSQL_TEST 2>&1
 
1246
 
 
1247
--error 1
 
1248
--exec echo "--replace_column a b" | $MYSQL_TEST 2>&1
 
1249
--error 1
 
1250
--exec echo "--replace_column a 1" | $MYSQL_TEST 2>&1
 
1251
--error 1
 
1252
--exec echo "--replace_column 1 b c " | $MYSQL_TEST 2>&1
 
1253
 
 
1254
 
 
1255
# ----------------------------------------------------------------------------
 
1256
# Test sync_with_master
 
1257
# ----------------------------------------------------------------------------
 
1258
--error 1
 
1259
--exec echo "sync_with_master 10!;" | $MYSQL_TEST 2>&1
 
1260
--error 1
 
1261
--exec echo "sync_with_master a;" | $MYSQL_TEST 2>&1
 
1262
 
 
1263
# ----------------------------------------------------------------------------
 
1264
# Test connect
 
1265
# ----------------------------------------------------------------------------
 
1266
 
 
1267
--error 1
 
1268
--exec echo "connect;" | $MYSQL_TEST 2>&1
 
1269
--error 1
 
1270
--exec echo "connect ();" | $MYSQL_TEST 2>&1
 
1271
--error 1
 
1272
--exec echo "connect (con2);" | $MYSQL_TEST 2>&1
 
1273
--error 1
 
1274
--exec echo "connect (con2,);" | $MYSQL_TEST 2>&1
 
1275
--error 1
 
1276
--exec echo "connect (con2,localhost,root,,illegal_db);" | $MYSQL_TEST 2>&1
 
1277
--error 1
 
1278
--exec echo "connect (con1,localhost,root,,,illegal_port,);" | $MYSQL_TEST 2>&1
 
1279
--error 1
 
1280
--exec echo "connect (con1,localhost,root,,,,,SMTP POP);" | $MYSQL_TEST 2>&1
 
1281
 
 
1282
# Repeat connect/disconnect
 
1283
--write_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql
 
1284
let $i=100;
 
1285
while ($i)
 
1286
{
 
1287
  connect (test_con1,localhost,root,,);
 
1288
  disconnect test_con1;
 
1289
  dec $i;
 
1290
}
 
1291
EOF
 
1292
--exec echo "source $MYSQLTEST_VARDIR/tmp/mysqltest.sql; echo OK;" | $MYSQL_TEST 2>&1
 
1293
remove_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql;
 
1294
 
 
1295
# Repeat connect/disconnect
 
1296
--write_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql
 
1297
let $i=200;
 
1298
while ($i)
 
1299
{
 
1300
 connect (test_con1,localhost,root,,);
 
1301
 disconnect test_con1;
 
1302
 dec $i;
 
1303
}
 
1304
EOF
 
1305
--replace_result $MYSQLTEST_VARDIR MYSQLTEST_VARDIR
 
1306
--error 1
 
1307
--exec echo "source $MYSQLTEST_VARDIR/tmp/mysqltest.sql;" | $MYSQL_TEST 2>&1
 
1308
remove_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql;
 
1309
 
 
1310
# Select disconnected connection
 
1311
--write_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql
 
1312
connect (test_con1,localhost,root,,);
 
1313
disconnect test_con1;
 
1314
connection test_con1;
 
1315
EOF
 
1316
--replace_result $MYSQLTEST_VARDIR MYSQLTEST_VARDIR
 
1317
--error 1
 
1318
--exec echo "source $MYSQLTEST_VARDIR/tmp/mysqltest.sql;" | $MYSQL_TEST 2>&1
 
1319
remove_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql;
 
1320
 
 
1321
# Connection name already used
 
1322
--write_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql
 
1323
connect (test_con1,localhost,root,,);
 
1324
connect (test_con1,localhost,root,,);
 
1325
EOF
 
1326
--replace_result $MYSQLTEST_VARDIR MYSQLTEST_VARDIR
 
1327
--error 1
 
1328
--exec echo "source $MYSQLTEST_VARDIR/tmp/mysqltest.sql;" | $MYSQL_TEST 2>&1
 
1329
 
 
1330
remove_file $MYSQLTEST_VARDIR/tmp/mysqltest.sql;
 
1331
 
 
1332
# connect when "disable_abort_on_error" caused "connection not found"
 
1333
--replace_result $MASTER_MYSOCK MASTER_SOCKET $MASTER_MYPORT MASTER_PORT
 
1334
--disable_abort_on_error
 
1335
connect (con1,localhost,root,,);
 
1336
connection default;
 
1337
connection con1;
 
1338
disconnect con1;
 
1339
--enable_abort_on_error
 
1340
 
 
1341
# Test connect without a database
 
1342
connect (con2,localhost,root,,*NO-ONE*);
 
1343
--error ER_NO_DB_ERROR
 
1344
show tables;
 
1345
disconnect con2;
 
1346
connection default;
 
1347
 
 
1348
# ----------------------------------------------------------------------------
 
1349
# Test mysqltest arguments
 
1350
# ----------------------------------------------------------------------------
 
1351
 
 
1352
# -x <file_name>, use the file specified after -x as the test file
 
1353
--exec $MYSQL_TEST < $MYSQL_TEST_DIR/include/mysqltest-x.inc
 
1354
--exec $MYSQL_TEST -x $MYSQL_TEST_DIR/include/mysqltest-x.inc
 
1355
--exec $MYSQL_TEST --test_file=$MYSQL_TEST_DIR/include/mysqltest-x.inc
 
1356
# Fix Win paths
 
1357
--replace_result \\ /
 
1358
--error 1
 
1359
--exec $MYSQL_TEST -x non_existing_file.inc 2>&1
 
1360
 
 
1361
 
 
1362
# ----------------------------------------------------------------------------
 
1363
# TODO Test queries, especially their errormessages... so it's easy to debug 
 
1364
# new scripts and diagnose errors
 
1365
# ----------------------------------------------------------------------------
 
1366
 
 
1367
# ----------------------------------------------------------------------------
 
1368
# Test bug#12386
 
1369
# ----------------------------------------------------------------------------
 
1370
let $num= 2;
 
1371
while ($num)
 
1372
{
 
1373
   --error 1064
 
1374
   failing_statement;
 
1375
 
 
1376
   dec $num;
 
1377
}
 
1378
 
 
1379
SELECT 1 as a;
 
1380
 
 
1381
 
 
1382
#
 
1383
# Bug #10251: Identifiers containing quotes not handled correctly
 
1384
#
 
1385
select 1 as `a'b`, 2 as `a"b`;
 
1386
 
 
1387
# Test escaping of quotes
 
1388
select 'aaa\\','aa''a',"aa""a";
 
1389
 
 
1390
#
 
1391
# Check of include/show_msg.inc and include/show_msg80.inc
 
1392
#
 
1393
 
 
1394
# The message contains in most cases a string with the default character set
 
1395
let $message= Here comes a message;
 
1396
--source include/show_msg.inc
 
1397
 
 
1398
# The message could also contain a string with character set utf8
 
1399
let $message= `SELECT USER()`;
 
1400
--source include/show_msg.inc
 
1401
 
 
1402
# The message contains more then 80 characters on multiple lines
 
1403
# and is kept between double quotes.
 
1404
let $message= 
 
1405
"Here comes a very very long message that
 
1406
    - is longer then 80 characters    and
 
1407
    - consists of several lines";
 
1408
--source include/show_msg80.inc
 
1409
 
 
1410
# The message contains more then 80 characters on multiple lines
 
1411
# and uses the auxiliary character "." at the beginning of the message lines.
 
1412
let $message= . Here comes a very very long message that
 
1413
              .      - is longer then 80 characters    and
 
1414
              .      - consists of several lines;
 
1415
--source include/show_msg80.inc
 
1416
 
 
1417
#
 
1418
# Test --enable_parsing / disable_parsing
 
1419
#
 
1420
--disable_query_log
 
1421
--disable_parsing
 
1422
# The following will not enable query logging
 
1423
--enable_query_log
 
1424
select "this will not be executed";
 
1425
--enable_parsing
 
1426
select "this will be executed";
 
1427
--enable_query_log
 
1428
 
 
1429
#
 
1430
# Test zero length result file. Should not pass
 
1431
#
 
1432
--exec touch $MYSQLTEST_VARDIR/tmp/zero_length_file.result
 
1433
--exec echo "echo ok;" > $MYSQLTEST_VARDIR/tmp/query.sql
 
1434
--error 1
 
1435
--exec $MYSQL_TEST -x $MYSQLTEST_VARDIR/tmp/query.sql -R $MYSQLTEST_VARDIR/tmp/zero_length_file.result  > /dev/null 2>&1
 
1436
 
 
1437
remove_file $MYSQLTEST_VARDIR/tmp/zero_length_file.result;
 
1438
--error 0,1
 
1439
remove_file $MYSQLTEST_VARDIR/log/zero_length_file.reject;
 
1440
--error 0,1
 
1441
remove_file $MYSQL_TEST_DIR/r/zero_length_file.reject;
 
1442
 
 
1443
#
 
1444
# Test that a test file that does not generate any output fails.
 
1445
#
 
1446
--exec echo "let \$i= 1;" > $MYSQLTEST_VARDIR/tmp/query.sql
 
1447
--error 1
 
1448
--exec $MYSQL_TEST -x $MYSQLTEST_VARDIR/tmp/query.sql  2>&1
 
1449
 
 
1450
remove_file $MYSQLTEST_VARDIR/tmp/query.sql;
 
1451
 
 
1452
#
 
1453
# Test that mysqltest fails when there are no queries executed
 
1454
# but a result file exists
 
1455
# NOTE! This will never happen as long as it's not allowed to have
 
1456
# test files that produce no output
 
1457
#--exec echo "something" > $MYSQLTEST_VARDIR/tmp/result_file.result
 
1458
#--exec echo "let \$i= 1;" > $MYSQLTEST_VARDIR/tmp/query.sql
 
1459
#--error 1
 
1460
#--exec $MYSQL_TEST -x $MYSQLTEST_VARDIR/tmp/query.sql -R $MYSQLTEST_VARDIR/tmp/result_file.result 2>&1
 
1461
 
 
1462
#
 
1463
# Bug #11731 mysqltest in multi-statement queries ignores errors in
 
1464
#            non-1st queries
 
1465
#
 
1466
 
 
1467
echo Failing multi statement query;
 
1468
# PS does not support multi statement
 
1469
--exec echo "--disable_ps_protocol"                    > $MYSQLTEST_VARDIR/tmp/bug11731.sql
 
1470
--exec echo "delimiter ||||;"                         >> $MYSQLTEST_VARDIR/tmp/bug11731.sql
 
1471
--exec echo "create table t1 (a int primary key);"    >> $MYSQLTEST_VARDIR/tmp/bug11731.sql
 
1472
--exec echo "insert into t1 values (1);"              >> $MYSQLTEST_VARDIR/tmp/bug11731.sql
 
1473
--exec echo "select 'select-me';"                     >> $MYSQLTEST_VARDIR/tmp/bug11731.sql
 
1474
--exec echo "insertz 'error query'||||"               >> $MYSQLTEST_VARDIR/tmp/bug11731.sql
 
1475
--exec echo "delimiter ;||||"                         >> $MYSQLTEST_VARDIR/tmp/bug11731.sql
 
1476
 
 
1477
--error 1
 
1478
--exec $MYSQL_TEST -x $MYSQLTEST_VARDIR/tmp/bug11731.sql 2>&1
 
1479
drop table t1;
 
1480
 
 
1481
--replace_result $MYSQLTEST_VARDIR MYSQLTEST_VARDIR
 
1482
--error 1
 
1483
--exec $MYSQL_TEST --record -x $MYSQLTEST_VARDIR/tmp/bug11731.sql -R $MYSQLTEST_VARDIR/tmp/bug11731.out 2>&1
 
1484
# The .out file should be non existent
 
1485
--exec test ! -s $MYSQLTEST_VARDIR/tmp/bug11731.out
 
1486
drop table t1;
 
1487
 
 
1488
 
 
1489
echo Multi statement using expected error;
 
1490
# PS does not support multi statement
 
1491
--exec echo "--disable_ps_protocol"                    > $MYSQLTEST_VARDIR/tmp/bug11731.sql
 
1492
--exec echo "delimiter ||||;"                         >> $MYSQLTEST_VARDIR/tmp/bug11731.sql
 
1493
--exec echo "--error 1064"                            >> $MYSQLTEST_VARDIR/tmp/bug11731.sql
 
1494
--exec echo "create table t1 (a int primary key);"    >> $MYSQLTEST_VARDIR/tmp/bug11731.sql
 
1495
--exec echo "insert into t1 values (1);"              >> $MYSQLTEST_VARDIR/tmp/bug11731.sql
 
1496
--exec echo "select 'select-me';"                     >> $MYSQLTEST_VARDIR/tmp/bug11731.sql
 
1497
--exec echo "insertz "error query"||||"               >> $MYSQLTEST_VARDIR/tmp/bug11731.sql
 
1498
--exec echo "delimiter ;||||"                         >> $MYSQLTEST_VARDIR/tmp/bug11731.sql
 
1499
 
 
1500
# These two should work since the error is expected
 
1501
--exec $MYSQL_TEST -x $MYSQLTEST_VARDIR/tmp/bug11731.sql  2>&1
 
1502
drop table t1;
 
1503
 
 
1504
--exec $MYSQL_TEST --record -x $MYSQLTEST_VARDIR/tmp/bug11731.sql -R $MYSQLTEST_VARDIR/tmp/bug11731.out 2>&1
 
1505
# The .out file should exist
 
1506
--exec test -s $MYSQLTEST_VARDIR/tmp/bug11731.out
 
1507
drop table t1;
 
1508
remove_file $MYSQLTEST_VARDIR/tmp/bug11731.out;
 
1509
remove_file $MYSQLTEST_VARDIR/log/bug11731.log;
 
1510
remove_file $MYSQLTEST_VARDIR/tmp/bug11731.sql;
 
1511
 
 
1512
#
 
1513
# Bug#19890     mysqltest: "query" command is broken
 
1514
#
 
1515
 
 
1516
# It should be possible to use the command "query" to force mysqltest to
 
1517
# send the command to the server although it's a builtin mysqltest command.
 
1518
--error 1064
 
1519
query sleep;
 
1520
 
 
1521
--error 1064
 
1522
--query sleep
 
1523
 
 
1524
# Just an empty query command
 
1525
--error 1065
 
1526
query ;
 
1527
 
 
1528
# test for replace_regex
 
1529
--replace_regex /at/b/
 
1530
select "at" as col1, "c" as col2;
 
1531
 
 
1532
--replace_regex /at/b/i
 
1533
select "at" as col1, "AT" as col2, "c" as col3;
 
1534
 
 
1535
--replace_regex /a/b/ /ct/d/
 
1536
select "a" as col1, "ct" as col2; 
 
1537
 
 
1538
--replace_regex /(strawberry)/raspberry and \1/ /blueberry/blackberry/ /potato/tomato/;
 
1539
select "strawberry","blueberry","potato";
 
1540
 
 
1541
--error 1
 
1542
--exec echo "--replace_regex a" | $MYSQL_TEST 2>&1
 
1543
--error 1
 
1544
--exec echo "--replace_regex a;" | $MYSQL_TEST 2>&1
 
1545
--error 1
 
1546
--exec echo "replace_regex a;" | $MYSQL_TEST 2>&1
 
1547
--error 1
 
1548
--exec echo "replace_regex a ;" | $MYSQL_TEST 2>&1
 
1549
--error 1
 
1550
--exec echo "replace_regex a b; echo OK;" | $MYSQL_TEST 2>&1
 
1551
--error 1
 
1552
--exec echo "--replace_regex /a b c" | $MYSQL_TEST 2>&1
 
1553
--error 1
 
1554
--exec echo "replace_regex /a /b c ;" | $MYSQL_TEST 2>&1 
 
1555
 
 
1556
# REQUIREMENT
 
1557
#   replace_regex should replace substitutions from left to right in output
 
1558
 
 
1559
create table t1 (a int, b int);
 
1560
insert into t1 values (1,3);
 
1561
insert into t1 values (2,4);
 
1562
--replace_regex /A/C/ /B/D/i /3/2/ /2/1/
 
1563
select * from t1;
 
1564
drop table t1;
 
1565
 
 
1566
# ----------------------------------------------------------------------------
 
1567
# test for remove_file
 
1568
# ----------------------------------------------------------------------------
 
1569
 
 
1570
--error 1
 
1571
--exec echo "remove_file ;" | $MYSQL_TEST 2>&1
 
1572
 
 
1573
--error 1
 
1574
remove_file non_existing_file;
 
1575
 
 
1576
# ----------------------------------------------------------------------------
 
1577
# test for write_file
 
1578
# ----------------------------------------------------------------------------
 
1579
--error 1
 
1580
--exec echo "write_file ;" | $MYSQL_TEST 2>&1
 
1581
 
 
1582
--error 1
 
1583
--exec echo "write_file filename ;" | $MYSQL_TEST 2>&1
 
1584
 
 
1585
# Comment out this test as it confuses cmd.exe with unmatched "
 
1586
#--error 1
 
1587
#--exec echo "write_file filename \";" | $MYSQL_TEST 2>&1
 
1588
 
 
1589
write_file $MYSQLTEST_VARDIR/tmp/test_file1.tmp;
 
1590
Content for test_file1
 
1591
EOF
 
1592
file_exists $MYSQLTEST_VARDIR/tmp/test_file1.tmp;
 
1593
cat_file $MYSQLTEST_VARDIR/tmp/test_file1.tmp;
 
1594
remove_file $MYSQLTEST_VARDIR/tmp/test_file1.tmp;
 
1595
 
 
1596
write_file $MYSQLTEST_VARDIR/tmp/test_file1.tmp END_DELIMITER;
 
1597
Content for test_file1 contains EOF
 
1598
END_DELIMITER
 
1599
file_exists $MYSQLTEST_VARDIR/tmp/test_file1.tmp;
 
1600
 
 
1601
# write to already exisiting file
 
1602
--replace_result $MYSQLTEST_VARDIR MYSQLTEST_VARDIR
 
1603
--error 1
 
1604
--exec echo "write_file $MYSQLTEST_VARDIR/tmp/test_file1.tmp;" | $MYSQL_TEST 2>&1
 
1605
 
 
1606
remove_file $MYSQLTEST_VARDIR/tmp/test_file1.tmp;
 
1607
 
 
1608
# ----------------------------------------------------------------------------
 
1609
# test for append_file
 
1610
# ----------------------------------------------------------------------------
 
1611
 
 
1612
write_file $MYSQLTEST_VARDIR/tmp/test_file1.tmp;
 
1613
Content for test_file1
 
1614
EOF
 
1615
file_exists $MYSQLTEST_VARDIR/tmp/test_file1.tmp;
 
1616
 
 
1617
append_file $MYSQLTEST_VARDIR/tmp/test_file1.tmp;
 
1618
Appended text
 
1619
EOF
 
1620
file_exists $MYSQLTEST_VARDIR/tmp/test_file1.tmp;
 
1621
 
 
1622
remove_file $MYSQLTEST_VARDIR/tmp/test_file1.tmp;
 
1623
append_file $MYSQLTEST_VARDIR/tmp/test_file1.tmp;
 
1624
Appended text on nonexisting file
 
1625
EOF
 
1626
 
 
1627
remove_file $MYSQLTEST_VARDIR/tmp/test_file1.tmp;
 
1628
 
 
1629
# ----------------------------------------------------------------------------
 
1630
# test for cat_file
 
1631
# ----------------------------------------------------------------------------
 
1632
 
 
1633
--write_file $MYSQLTEST_VARDIR/tmp/test_file1.tmp
 
1634
Some data
 
1635
for cat_file command
 
1636
of mysqltest
 
1637
EOF
 
1638
cat_file $MYSQLTEST_VARDIR/tmp/test_file1.tmp;
 
1639
remove_file $MYSQLTEST_VARDIR/tmp/test_file1.tmp;
 
1640
 
 
1641
--error 1
 
1642
--exec echo "cat_file non_existing_file;" | $MYSQL_TEST 2>&1
 
1643
 
 
1644
# ----------------------------------------------------------------------------
 
1645
# test for diff_files
 
1646
# ----------------------------------------------------------------------------
 
1647
 
 
1648
--write_file $MYSQLTEST_VARDIR/tmp/diff1.tmp
 
1649
Some data
 
1650
for diff_file command
 
1651
of mysqltest
 
1652
EOF
 
1653
 
 
1654
--write_file $MYSQLTEST_VARDIR/tmp/diff2.tmp
 
1655
Some data
 
1656
for diff_file command
 
1657
of mysqltest
 
1658
EOF
 
1659
 
 
1660
--write_file $MYSQLTEST_VARDIR/tmp/diff3.tmp
 
1661
Some other data
 
1662
for diff_file command
 
1663
of mysqltest
 
1664
EOF
 
1665
 
 
1666
--write_file $MYSQLTEST_VARDIR/tmp/diff4.tmp
 
1667
Some data
 
1668
for diff_file command
 
1669
of musqltest
 
1670
EOF
 
1671
 
 
1672
# Compare equal files
 
1673
--diff_files $MYSQLTEST_VARDIR/tmp/diff1.tmp $MYSQLTEST_VARDIR/tmp/diff2.tmp
 
1674
--diff_files $MYSQLTEST_VARDIR/tmp/diff2.tmp $MYSQLTEST_VARDIR/tmp/diff1.tmp
 
1675
 
 
1676
# Write the below commands to a intermediary file and execute them with
 
1677
# mysqltest in --exec, since the output will vary depending on what "diff"
 
1678
# is available it is sent to /dev/null
 
1679
--write_file $MYSQLTEST_VARDIR/tmp/diff.test
 
1680
# Compare files that differ in size
 
1681
--error 2
 
1682
--diff_files $MYSQLTEST_VARDIR/tmp/diff1.tmp $MYSQLTEST_VARDIR/tmp/diff3.tmp
 
1683
--error 2
 
1684
--diff_files $MYSQLTEST_VARDIR/tmp/diff3.tmp $MYSQLTEST_VARDIR/tmp/diff1.tmp
 
1685
 
 
1686
# Compare files that differ only in content
 
1687
--error 1
 
1688
--diff_files $MYSQLTEST_VARDIR/tmp/diff1.tmp $MYSQLTEST_VARDIR/tmp/diff4.tmp
 
1689
--error 1
 
1690
--diff_files $MYSQLTEST_VARDIR/tmp/diff4.tmp $MYSQLTEST_VARDIR/tmp/diff1.tmp
 
1691
EOF
 
1692
 
 
1693
# Execute the above diffs, and send their output to /dev/null - only
 
1694
# interesting to see that it returns correct error codes
 
1695
--exec $MYSQL_TEST < $MYSQLTEST_VARDIR/tmp/diff.test > /dev/null 2>&1
 
1696
 
 
1697
 
 
1698
# Compare equal files, again...
 
1699
--diff_files $MYSQLTEST_VARDIR/tmp/diff1.tmp $MYSQLTEST_VARDIR/tmp/diff2.tmp
 
1700
 
 
1701
--remove_file $MYSQLTEST_VARDIR/tmp/diff1.tmp
 
1702
--remove_file $MYSQLTEST_VARDIR/tmp/diff2.tmp
 
1703
--remove_file $MYSQLTEST_VARDIR/tmp/diff3.tmp
 
1704
--remove_file $MYSQLTEST_VARDIR/tmp/diff4.tmp
 
1705
--remove_file $MYSQLTEST_VARDIR/tmp/diff.test
 
1706
 
 
1707
 
 
1708
# ----------------------------------------------------------------------------
 
1709
# test for file_exist
 
1710
# ----------------------------------------------------------------------------
 
1711
--error 1
 
1712
--exec echo "file_exists ;" | $MYSQL_TEST 2>&1
 
1713
 
 
1714
--error 0,1
 
1715
remove_file $MYSQLTEST_VARDIR/tmp/test_file1.tmp;
 
1716
--error 1
 
1717
file_exists $MYSQLTEST_VARDIR/tmp/test_file1.tmp;
 
1718
write_file $MYSQLTEST_VARDIR/tmp/test_file1.tmp;
 
1719
Content for test_file1
 
1720
EOF
 
1721
file_exists $MYSQLTEST_VARDIR/tmp/test_file1.tmp;
 
1722
remove_file $MYSQLTEST_VARDIR/tmp/test_file1.tmp;
 
1723
--error 1
 
1724
file_exists $MYSQLTEST_VARDIR/tmp/test_file1.tmp;
 
1725
 
 
1726
 
 
1727
# ----------------------------------------------------------------------------
 
1728
# test for copy_file
 
1729
# ----------------------------------------------------------------------------
 
1730
--write_file $MYSQLTEST_VARDIR/tmp/file1.tmp
 
1731
file1
 
1732
EOF
 
1733
 
 
1734
copy_file $MYSQLTEST_VARDIR/tmp/file1.tmp $MYSQLTEST_VARDIR/tmp/file2.tmp;
 
1735
file_exists $MYSQLTEST_VARDIR/tmp/file2.tmp;
 
1736
remove_file $MYSQLTEST_VARDIR/tmp/file1.tmp;
 
1737
remove_file $MYSQLTEST_VARDIR/tmp/file2.tmp;
 
1738
 
 
1739
--error 1
 
1740
--exec echo "copy_file ;" | $MYSQL_TEST 2>&1
 
1741
 
 
1742
--error 1
 
1743
--exec echo "copy_file from_file;" | $MYSQL_TEST 2>&1
 
1744
 
 
1745
# ----------------------------------------------------------------------------
 
1746
# test for chmod
 
1747
# ----------------------------------------------------------------------------
 
1748
--write_file $MYSQLTEST_VARDIR/tmp/file1.tmp
 
1749
file1
 
1750
EOF
 
1751
 
 
1752
chmod 0000 $MYSQLTEST_VARDIR/tmp/file1.tmp;
 
1753
# The below write fails, but --error is not implemented
 
1754
# for write_file
 
1755
#--write_file $MYSQLTEST_VARDIR/tmp/file1.tmp
 
1756
#test should fail
 
1757
#EOF
 
1758
 
 
1759
chmod 0777 $MYSQLTEST_VARDIR/tmp/file1.tmp;
 
1760
remove_file $MYSQLTEST_VARDIR/tmp/file1.tmp;
 
1761
--write_file $MYSQLTEST_VARDIR/tmp/file1.tmp
 
1762
test2
 
1763
EOF
 
1764
 
 
1765
remove_file $MYSQLTEST_VARDIR/tmp/file1.tmp;
 
1766
 
 
1767
--error 1
 
1768
--exec echo "chmod ;" | $MYSQL_TEST 2>&1
 
1769
 
 
1770
--error 1
 
1771
--exec echo "chmod 0 from_file;" | $MYSQL_TEST 2>&1
 
1772
 
 
1773
--error 1
 
1774
--exec echo "chmod 08 from_file;" | $MYSQL_TEST 2>&1
 
1775
 
 
1776
--error 1
 
1777
--exec echo "chmod from_file;" | $MYSQL_TEST 2>&1
 
1778
 
 
1779
--error 1
 
1780
--exec echo "chmod ABZD from_file;" | $MYSQL_TEST 2>&1
 
1781
 
 
1782
--error 1
 
1783
--exec echo "chmod 06789 from_file;" | $MYSQL_TEST 2>&1
 
1784
 
 
1785
 
 
1786
# ----------------------------------------------------------------------------
 
1787
# test for perl
 
1788
# ----------------------------------------------------------------------------
 
1789
--perl
 
1790
print "hello\n";
 
1791
EOF
 
1792
 
 
1793
--perl EOF
 
1794
print "hello\n";
 
1795
EOF
 
1796
 
 
1797
--perl DELIMITER
 
1798
print "hello\n";
 
1799
DELIMITER
 
1800
 
 
1801
--error 1
 
1802
--exec echo "perl TOO_LONG_DELIMITER ;" | $MYSQL_TEST 2>&1
 
1803
 
 
1804
perl;
 
1805
print "hello\n";
 
1806
EOF
 
1807
 
 
1808
perl;
 
1809
  # Print "hello"
 
1810
  print "hello\n";
 
1811
EOF
 
1812
 
 
1813
# ----------------------------------------------------------------------------
 
1814
# test for die
 
1815
# ----------------------------------------------------------------------------
 
1816
 
 
1817
--error 1
 
1818
--exec echo "die test of die;" | $MYSQL_TEST 2>&1
 
1819
 
 
1820
 
 
1821
# ----------------------------------------------------------------------------
 
1822
# test for exit
 
1823
# ----------------------------------------------------------------------------
 
1824
 
 
1825
--exec echo "echo Some output; exit; echo Not this;" | $MYSQL_TEST 2>&1
 
1826
 
 
1827
# ----------------------------------------------------------------------------
 
1828
# test for sorted_result
 
1829
# ----------------------------------------------------------------------------
 
1830
 
 
1831
create table t1( a int, b char(255), c timestamp);
 
1832
insert into t1 values(1, 'Line 1', '2007-04-05'), (2, "Part 2", '2007-04-05');
 
1833
insert into t1 values(1, 'Line 1', '2007-04-05'), (2, "Part 3", '2007-04-05');
 
1834
select * from t1;
 
1835
--sorted_result
 
1836
select * from t1;
 
1837
# Should not be sorted
 
1838
select * from t1;
 
1839
disable_result_log;
 
1840
sorted_result;
 
1841
select * from t1;
 
1842
enable_result_log;
 
1843
--sorted_result
 
1844
select '';
 
1845
sorted_result;
 
1846
select "h";
 
1847
--sorted_result
 
1848
select "he";
 
1849
--sorted_result
 
1850
select "hep";
 
1851
--sorted_result
 
1852
select "hepp";
 
1853
 
 
1854
drop table t1;
 
1855
 
 
1856
# 1. Assignment of result set sorting
 
1857
sorted_result;
 
1858
 SELECT 2 as "my_col"
 
1859
UNION
 
1860
SELECT 1;
 
1861
#
 
1862
--sorted_result
 
1863
SELECT 2 as "my_col" UNION SELECT 1;
 
1864
--sorted_result
 
1865
SELECT 2 as "my_col"
 
1866
UNION
 
1867
SELECT 1;
 
1868
 
 
1869
# 2. Ensure that the table header will be not sorted into the result
 
1870
--sorted_result
 
1871
SELECT '2' as "3"
 
1872
UNION
 
1873
SELECT '1';
 
1874
 
 
1875
# 3. Ensure that an empty result set does not cause problems
 
1876
CREATE TABLE t1( a CHAR);
 
1877
--sorted_result
 
1878
SELECT * FROM t1;
 
1879
DROP TABLE t1;
 
1880
 
 
1881
# 4. Ensure that NULL values within the result set do not cause problems
 
1882
SELECT NULL as "my_col1",2 AS "my_col2"
 
1883
UNION
 
1884
SELECT NULL,1;
 
1885
--sorted_result
 
1886
SELECT NULL as "my_col1",2 AS "my_col2"
 
1887
UNION
 
1888
SELECT NULL,1;
 
1889
#
 
1890
SELECT 2 as "my_col1",NULL AS "my_col2"
 
1891
UNION
 
1892
SELECT 1,NULL;
 
1893
--sorted_result
 
1894
SELECT 2 as "my_col1",NULL AS "my_col2"
 
1895
UNION
 
1896
SELECT 1,NULL;
 
1897
 
 
1898
# 5. "sorted_result" changes nothing when applied to a non query statement.
 
1899
sorted_result;
 
1900
 SET @a = 17;
 
1901
#
 
1902
# 6. Show that "sorted_result;" before the "SET @a = 17;" above does not affect
 
1903
# the now following query.
 
1904
SELECT 2 as "my_col"
 
1905
UNION
 
1906
SELECT 1;
 
1907
 
 
1908
# 7. Ensure that "sorted_result" in combination with $variables works
 
1909
let $my_stmt=SELECT 2 as "my_col"
 
1910
UNION
 
1911
SELECT 1;
 
1912
--sorted_result
 
1913
eval $my_stmt;
 
1914
 
 
1915
# 8. Ensure that "sorted_result " does not change the semantics of
 
1916
#    "--error ...." or the protocol output after such an expected failure
 
1917
--sorted_result
 
1918
--error 1146
 
1919
SELECT '2' as "my_col1",2 as "my_col2"
 
1920
UNION
 
1921
SELECT '1',1 from t2;
 
1922
 
 
1923
# 9. Ensure that several result formatting options including "sorted_result" 
 
1924
#    - have all an effect
 
1925
#    - "--sorted_result" does not need to be direct before the statement
 
1926
#    - Row sorting is applied after modification of the column content
 
1927
--sorted_result
 
1928
--replace_column 1 #
 
1929
SELECT '1' as "my_col1",2 as "my_col2"
 
1930
UNION
 
1931
SELECT '2',1;
 
1932
 
 
1933
# 10. Ensure that at least 1024 rows within a result set do not cause problems
 
1934
#
 
1935
CREATE TABLE t1 (f1 INT);
 
1936
INSERT INTO t1 SET f1 = 1024;
 
1937
INSERT INTO t1 SELECT f1 - 1 FROM t1;
 
1938
INSERT INTO t1 SELECT f1 - 2 FROM t1;
 
1939
INSERT INTO t1 SELECT f1 - 4 FROM t1;
 
1940
INSERT INTO t1 SELECT f1 - 8 FROM t1;
 
1941
INSERT INTO t1 SELECT f1 - 16 FROM t1;
 
1942
INSERT INTO t1 SELECT f1 - 32 FROM t1;
 
1943
INSERT INTO t1 SELECT f1 - 64 FROM t1;
 
1944
INSERT INTO t1 SELECT f1 - 128 FROM t1;
 
1945
INSERT INTO t1 SELECT f1 - 256 FROM t1;
 
1946
INSERT INTO t1 SELECT f1 - 512 FROM t1;
 
1947
--disable_result_log
 
1948
--sorted_result
 
1949
SELECT * FROM t1;
 
1950
--enable_result_log
 
1951
DROP TABLE t1;
 
1952
# ----------------------------------------------------------------------------
 
1953
# Some coverage tests
 
1954
# ----------------------------------------------------------------------------
 
1955
 
 
1956
--disable_query_log
 
1957
--exec $MYSQL_TEST --help 2>&1 > /dev/null
 
1958
--exec $MYSQL_TEST --version 2>&1 > /dev/null
 
1959
--enable_query_log
 
1960
--disable_abort_on_error
 
1961
--error 1
 
1962
--exec $MYSQL_TEST a b c 2>&1 > /dev/null
 
1963
--enable_abort_on_error
 
1964
--enable_query_log
 
1965
 
 
1966
# ----------------------------------------------------------------------------
 
1967
# test for query_get_value
 
1968
# ----------------------------------------------------------------------------
 
1969
 
 
1970
CREATE TABLE t1(
 
1971
 a int, b varchar(255), c datetime
 
1972
);
 
1973
SHOW COLUMNS FROM t1;
 
1974
 
 
1975
#------------ Positive tests ------------
 
1976
# 1. constant parameters
 
1977
#    value is simple string without spaces
 
1978
let $value= query_get_value(SHOW COLUMNS FROM t1, Type, 1);
 
1979
--echo statement=SHOW COLUMNS FROM t1 row_number=1, column_name="Type", Value=$value
 
1980
let $value= query_get_value("SHOW COLUMNS FROM t1", Type, 1);
 
1981
--echo statement="SHOW COLUMNS FROM t1" row_number=1, column_name="Type", Value=$value
 
1982
#
 
1983
# 2. $variables as parameters
 
1984
#    value IS NULL
 
1985
let $my_show= SHOW COLUMNS FROM t1;
 
1986
let $column_name= Default;
 
1987
let $row_number= 1;
 
1988
let $value= query_get_value($my_show, $column_name, $row_number);
 
1989
--echo statement=$my_show row_number=$row_number, column_name=$column_name, Value=$value
 
1990
#
 
1991
# 3. result set of a SELECT (not recommended, because projection and
 
1992
#         selection could be done much better by pure SELECT functionality)
 
1993
#    value is string with space in the middle
 
1994
let $value= query_get_value(SELECT 'A B' AS "MyColumn", MyColumn, 1);
 
1995
--echo value= ->$value<-
 
1996
#
 
1997
# 4. column name with space
 
1998
let $value= query_get_value(SELECT 1 AS "My Column", My Column, 1);
 
1999
--echo value= $value
 
2000
#
 
2001
#------------ Negative tests ------------
 
2002
# 5. Incomplete statement including missing parameters
 
2003
# 5.1 incomplete statement
 
2004
--error 1
 
2005
--exec echo "let \$value= query_get_value(SHOW;" | $MYSQL_TEST 2>&1
 
2006
# 5.2 missing query
 
2007
--error 1
 
2008
--exec echo "let \$value= query_get_value;" | $MYSQL_TEST 2>&1
 
2009
# 5.3 missing column name
 
2010
--error 1
 
2011
--exec echo "let \$value= query_get_value(SHOW COLUMNS FROM t1);" | $MYSQL_TEST 2>&1
 
2012
# 5.4 missing row number
 
2013
--error 1
 
2014
--exec echo "let \$value= query_get_value(SHOW COLUMNS FROM t1, Field);" | $MYSQL_TEST 2>&1
 
2015
#
 
2016
# 6. Somehow "wrong" value of parameters
 
2017
# 6.1 row parameter
 
2018
# 6.1.1 non sense number 0
 
2019
let $value= initialized;
 
2020
let $value= query_get_value(SHOW COLUMNS FROM t1, Field, 0);
 
2021
--echo value= $value
 
2022
# 6.1.2 after the last row
 
2023
let $value= initialized;
 
2024
let $value= query_get_value(SHOW COLUMNS FROM t1, Field, 10);
 
2025
--echo value= $value
 
2026
# 6.1.3 invalid row number
 
2027
--error 1
 
2028
--exec echo "let \$value= query_get_value(SHOW COLUMNS FROM t1, Field, notnumber);" | $MYSQL_TEST 2>&1
 
2029
# 6.2 column name parameter, name of not existing column
 
2030
--error 1
 
2031
--exec echo "let \$value= query_get_value(SHOW COLUMNS FROM t1, column_not_exists, 1);" | $MYSQL_TEST 2>&1
 
2032
# 6.3. statement which never gives a result set
 
2033
--error 1
 
2034
--exec echo "let \$value= query_get_value(SET @A = 1, Field, 1);" | $MYSQL_TEST 2>&1
 
2035
# 6.4. statement contains a ","
 
2036
#      Note: There is no need to improve this, because we need query_get_value
 
2037
#            for SHOW commands only.
 
2038
--error 1
 
2039
--exec echo "let \$value= query_get_value(SELECT 1 AS "A", 1 AS "B", 1);" | $MYSQL_TEST 2>&1
 
2040
#
 
2041
# 7. empty result set
 
2042
let $value= initialized;
 
2043
let $value= query_get_value(SELECT a FROM t1, a, 1);
 
2044
--echo value= $value
 
2045
#
 
2046
# 9. failing statement
 
2047
--error 1
 
2048
--exec echo "let \$value= query_get_value(SHOW COLNS FROM t1, Field, 1);" | $MYSQL_TEST 2>&1
 
2049
#
 
2050
# 10. Artificial example how to process a complete SHOW result set:
 
2051
let $show_statement= SHOW COLUMNS FROM t1;
 
2052
let $rowno= 1;
 
2053
let $run=1;
 
2054
let $count= 0;
 
2055
--echo
 
2056
--echo Field Type Null Key Default Extra
 
2057
while ($run)
 
2058
{
 
2059
   let $Field=   query_get_value($show_statement, Field,   $rowno);
 
2060
   if (`SELECT '$Field' = 'No such row'`)
 
2061
   {
 
2062
      let $run= 0;
 
2063
   }
 
2064
   if (`SELECT '$Field' <> 'No such row'`)
 
2065
   {
 
2066
      let $Type=    query_get_value($show_statement, Type,    $rowno);
 
2067
      let $Null=    query_get_value($show_statement, Null,    $rowno);
 
2068
      if (`SELECT '$Null' = 'YES'`)
 
2069
      {
 
2070
         inc $count;
 
2071
      }
 
2072
      let $Key=     query_get_value($show_statement, Key,     $rowno);
 
2073
      let $Default= query_get_value($show_statement, Default, $rowno);
 
2074
      let $Extra=   query_get_value($show_statement, Extra,   $rowno);
 
2075
      --echo $Field $Type $Null ->$Key<- $Default $Extra
 
2076
      inc $rowno;
 
2077
   }
 
2078
}
 
2079
--echo
 
2080
--echo Number of columns with Default NULL: $count
 
2081
--echo
 
2082
eval $show_statement;
 
2083
 
 
2084
drop table t1;
 
2085
 
 
2086
# ----------------------------------------------------------------------------
 
2087
# Test change_user command
 
2088
# ----------------------------------------------------------------------------
 
2089
 
 
2090
--error 1
 
2091
--exec echo "--change_user root,,inexistent" | $MYSQL_TEST 2>&1
 
2092
 
 
2093
--error 1
 
2094
--exec echo "--change_user inexistent,,test" | $MYSQL_TEST 2>&1
 
2095
 
 
2096
--error 1
 
2097
--exec echo "--change_user root,inexistent,test" | $MYSQL_TEST 2>&1
 
2098
 
 
2099
--change_user
 
2100
--change_user root
 
2101
--change_user root,,
 
2102
--change_user root,,test
 
2103
 
 
2104
# ----------------------------------------------------------------------------
 
2105
# Test mkdir and rmdir command
 
2106
# ----------------------------------------------------------------------------
 
2107
 
 
2108
mkdir $MYSQLTEST_VARDIR/tmp/testdir;
 
2109
rmdir $MYSQLTEST_VARDIR/tmp/testdir;
 
2110
 
 
2111
# Directory already exist
 
2112
mkdir $MYSQLTEST_VARDIR/tmp/testdir;
 
2113
--error 1
 
2114
mkdir $MYSQLTEST_VARDIR/tmp/testdir;
 
2115
 
 
2116
# Remove dir with file inside
 
2117
write_file $MYSQLTEST_VARDIR/tmp/testdir/file1.txt;
 
2118
hello
 
2119
EOF
 
2120
--error 1
 
2121
rmdir $MYSQLTEST_VARDIR/tmp/testdir;
 
2122
 
 
2123
remove_file $MYSQLTEST_VARDIR/tmp/testdir/file1.txt;
 
2124
rmdir $MYSQLTEST_VARDIR/tmp/testdir;
 
2125
 
 
2126
 
 
2127
--echo End of tests
 
2128