← Back to branch summary

~vkolesnikov/pbxt/pbxt-07-diskfull

« back to all changes in this revision

Viewing changes to pbxt/mysql-test-update/mysql-test/t/sp-vars.test

  • Committer: paul-mccullagh
  • Date: 2006-10-23 09:14:04 UTC
  • Revision ID: paul-mccullagh-918861e03d351978a9541168a96e58cc826734ee
Initial import

Show diffs side-by-side

added added

removed removed

Lines of Context:
pbxt/mysql-test-update/mysql-test/t/sp-vars.test
 
1
###########################################################################
 
2
#
 
3
# Cleanup.
 
4
#
 
5
###########################################################################
 
6
 
 
7
--disable_warnings
 
8
 
 
9
# Drop stored routines (if any) for general SP-vars test cases. These routines
 
10
# are created in include/sp-vars.inc file.
 
11
 
 
12
DROP PROCEDURE IF EXISTS sp_vars_check_dflt;
 
13
DROP PROCEDURE IF EXISTS sp_vars_check_assignment;
 
14
DROP FUNCTION IF EXISTS sp_vars_check_ret1;
 
15
DROP FUNCTION IF EXISTS sp_vars_check_ret2;
 
16
DROP FUNCTION IF EXISTS sp_vars_check_ret3;
 
17
DROP FUNCTION IF EXISTS sp_vars_check_ret4;
 
18
 
 
19
--enable_warnings
 
20
 
 
21
###########################################################################
 
22
#
 
23
# Some general tests for SP-vars functionality.
 
24
#
 
25
###########################################################################
 
26
 
 
27
# Create the procedure in ANSI mode. Check that all necessary warnings are
 
28
# emitted properly.
 
29
 
 
30
SET @@sql_mode = 'ansi';
 
31
 
 
32
--source include/sp-vars.inc
 
33
 
 
34
--echo
 
35
--echo ---------------------------------------------------------------
 
36
--echo Calling the routines, created in ANSI mode.
 
37
--echo ---------------------------------------------------------------
 
38
--echo
 
39
 
 
40
CALL sp_vars_check_dflt();
 
41
 
 
42
CALL sp_vars_check_assignment();
 
43
 
 
44
SELECT sp_vars_check_ret1();
 
45
 
 
46
SELECT sp_vars_check_ret2();
 
47
 
 
48
SELECT sp_vars_check_ret3();
 
49
 
 
50
SELECT sp_vars_check_ret4();
 
51
 
 
52
# Check that changing sql_mode after creating a store procedure does not
 
53
# matter.
 
54
 
 
55
SET @@sql_mode = 'traditional';
 
56
 
 
57
--echo
 
58
--echo ---------------------------------------------------------------
 
59
--echo Calling in TRADITIONAL mode the routines, created in ANSI mode.
 
60
--echo ---------------------------------------------------------------
 
61
--echo
 
62
 
 
63
CALL sp_vars_check_dflt();
 
64
 
 
65
CALL sp_vars_check_assignment();
 
66
 
 
67
SELECT sp_vars_check_ret1();
 
68
 
 
69
SELECT sp_vars_check_ret2();
 
70
 
 
71
SELECT sp_vars_check_ret3();
 
72
 
 
73
SELECT sp_vars_check_ret4();
 
74
 
 
75
# Create the procedure in TRADITIONAL mode. Check that error will be thrown on
 
76
# execution.
 
77
 
 
78
DROP PROCEDURE sp_vars_check_dflt;
 
79
DROP PROCEDURE sp_vars_check_assignment;
 
80
DROP FUNCTION sp_vars_check_ret1;
 
81
DROP FUNCTION sp_vars_check_ret2;
 
82
DROP FUNCTION sp_vars_check_ret3;
 
83
DROP FUNCTION sp_vars_check_ret4;
 
84
 
 
85
--source include/sp-vars.inc
 
86
 
 
87
--echo
 
88
--echo ---------------------------------------------------------------
 
89
--echo Calling the routines, created in TRADITIONAL mode.
 
90
--echo ---------------------------------------------------------------
 
91
--echo
 
92
 
 
93
--error ER_WARN_DATA_OUT_OF_RANGE
 
94
CALL sp_vars_check_dflt();
 
95
 
 
96
--error ER_WARN_DATA_OUT_OF_RANGE
 
97
CALL sp_vars_check_assignment();
 
98
 
 
99
--error ER_WARN_DATA_OUT_OF_RANGE
 
100
SELECT sp_vars_check_ret1();
 
101
 
 
102
--error ER_WARN_DATA_OUT_OF_RANGE
 
103
SELECT sp_vars_check_ret2();
 
104
 
 
105
--error ER_TRUNCATED_WRONG_VALUE_FOR_FIELD
 
106
SELECT sp_vars_check_ret3();
 
107
 
 
108
# TODO: Is it an error, that only a warning is emitted here? Check the same
 
109
# behaviour with tables.
 
110
 
 
111
SELECT sp_vars_check_ret4();
 
112
 
 
113
SET @@sql_mode = 'ansi';
 
114
 
 
115
#
 
116
# Cleanup.
 
117
#
 
118
 
 
119
DROP PROCEDURE sp_vars_check_dflt;
 
120
DROP PROCEDURE sp_vars_check_assignment;
 
121
DROP FUNCTION sp_vars_check_ret1;
 
122
DROP FUNCTION sp_vars_check_ret2;
 
123
DROP FUNCTION sp_vars_check_ret3;
 
124
DROP FUNCTION sp_vars_check_ret4;
 
125
 
 
126
###########################################################################
 
127
#
 
128
# Tests for BIT data type.
 
129
#
 
130
###########################################################################
 
131
 
 
132
--echo
 
133
--echo ---------------------------------------------------------------
 
134
--echo BIT data type tests
 
135
--echo ---------------------------------------------------------------
 
136
--echo
 
137
 
 
138
#
 
139
# Prepare.
 
140
#
 
141
 
 
142
--disable_warnings
 
143
DROP PROCEDURE IF EXISTS p1;
 
144
--enable_warnings
 
145
 
 
146
#
 
147
# Test case.
 
148
#
 
149
 
 
150
delimiter |;
 
151
CREATE PROCEDURE p1()
 
152
BEGIN
 
153
  DECLARE v1 BIT;
 
154
  DECLARE v2 BIT(1);
 
155
  DECLARE v3 BIT(3) DEFAULT b'101';
 
156
  DECLARE v4 BIT(64) DEFAULT 0x5555555555555555;
 
157
  DECLARE v5 BIT(3);
 
158
  DECLARE v6 BIT(64);
 
159
  DECLARE v7 BIT(8) DEFAULT 128;
 
160
  DECLARE v8 BIT(8) DEFAULT '128';
 
161
  DECLARE v9 BIT(8) DEFAULT ' 128';
 
162
  DECLARE v10 BIT(8) DEFAULT 'x 128';
 
163
 
 
164
  SET v1 = v4;
 
165
  SET v2 = 0;
 
166
  SET v5 = v4; # check overflow
 
167
  SET v6 = v3; # check padding
 
168
 
 
169
  SELECT HEX(v1);
 
170
  SELECT HEX(v2);
 
171
  SELECT HEX(v3);
 
172
  SELECT HEX(v4);
 
173
  SELECT HEX(v5);
 
174
  SELECT HEX(v6);
 
175
  SELECT HEX(v7);
 
176
  SELECT HEX(v8);
 
177
  SELECT HEX(v9);
 
178
  SELECT HEX(v10);
 
179
END|
 
180
delimiter ;|
 
181
 
 
182
CALL p1();
 
183
 
 
184
#
 
185
# Cleanup.
 
186
#
 
187
 
 
188
DROP PROCEDURE p1;
 
189
 
 
190
###########################################################################
 
191
#
 
192
# Tests for CASE statements functionality:
 
193
#   - test for general functionality (scopes, nested cases, CASE in loops);
 
194
#   - test that if type of the CASE expression is changed on each iteration,
 
195
#     the execution will be correct.
 
196
#
 
197
###########################################################################
 
198
 
 
199
--echo
 
200
--echo ---------------------------------------------------------------
 
201
--echo CASE expression tests.
 
202
--echo ---------------------------------------------------------------
 
203
--echo
 
204
 
 
205
#
 
206
# Prepare.
 
207
#
 
208
 
 
209
DROP PROCEDURE IF EXISTS p1;
 
210
DROP PROCEDURE IF EXISTS p2;
 
211
DROP TABLE IF EXISTS t1;
 
212
 
 
213
#
 
214
# Test case.
 
215
#
 
216
 
 
217
CREATE TABLE t1(log_msg VARCHAR(1024));
 
218
 
 
219
delimiter |;
 
220
 
 
221
CREATE PROCEDURE p1(arg VARCHAR(255))
 
222
BEGIN
 
223
  INSERT INTO t1 VALUES('p1: step1');
 
224
 
 
225
  CASE arg * 10
 
226
    WHEN 10 * 10 THEN
 
227
      INSERT INTO t1 VALUES('p1: case1: on 10');
 
228
    WHEN 10 * 10 + 10 * 10 THEN
 
229
      BEGIN
 
230
        CASE arg / 10
 
231
          WHEN 1 THEN
 
232
            INSERT INTO t1 VALUES('p1: case1: case2: on 1');
 
233
          WHEN 2 THEN
 
234
            BEGIN
 
235
              DECLARE i TINYINT DEFAULT 10;
 
236
 
 
237
              WHILE i > 0 DO
 
238
                INSERT INTO t1 VALUES(CONCAT('p1: case1: case2: loop: i: ', i));
 
239
                
 
240
                CASE MOD(i, 2)
 
241
                  WHEN 0 THEN
 
242
                    INSERT INTO t1 VALUES('p1: case1: case2: loop: i is even');
 
243
                  WHEN 1 THEN
 
244
                    INSERT INTO t1 VALUES('p1: case1: case2: loop: i is odd');
 
245
                  ELSE
 
246
                    INSERT INTO t1 VALUES('p1: case1: case2: loop: ERROR');
 
247
                END CASE;
 
248
                    
 
249
                SET i = i - 1;
 
250
              END WHILE;
 
251
            END;
 
252
          ELSE
 
253
            INSERT INTO t1 VALUES('p1: case1: case2: ERROR');
 
254
        END CASE;
 
255
 
 
256
        CASE arg
 
257
          WHEN 10 THEN
 
258
            INSERT INTO t1 VALUES('p1: case1: case3: on 10');
 
259
          WHEN 20 THEN
 
260
            INSERT INTO t1 VALUES('p1: case1: case3: on 20');
 
261
          ELSE
 
262
            INSERT INTO t1 VALUES('p1: case1: case3: ERROR');
 
263
        END CASE;
 
264
      END;
 
265
    ELSE
 
266
      INSERT INTO t1 VALUES('p1: case1: ERROR');
 
267
  END CASE;
 
268
 
 
269
  CASE arg * 10
 
270
    WHEN 10 * 10 THEN
 
271
      INSERT INTO t1 VALUES('p1: case4: on 10');
 
272
    WHEN 10 * 10 + 10 * 10 THEN
 
273
      BEGIN
 
274
        CASE arg / 10
 
275
          WHEN 1 THEN
 
276
            INSERT INTO t1 VALUES('p1: case4: case5: on 1');
 
277
          WHEN 2 THEN
 
278
            BEGIN
 
279
              DECLARE i TINYINT DEFAULT 10;
 
280
 
 
281
              WHILE i > 0 DO
 
282
                INSERT INTO t1 VALUES(CONCAT('p1: case4: case5: loop: i: ', i));
 
283
                
 
284
                CASE MOD(i, 2)
 
285
                  WHEN 0 THEN
 
286
                    INSERT INTO t1 VALUES('p1: case4: case5: loop: i is even');
 
287
                  WHEN 1 THEN
 
288
                    INSERT INTO t1 VALUES('p1: case4: case5: loop: i is odd');
 
289
                  ELSE
 
290
                    INSERT INTO t1 VALUES('p1: case4: case5: loop: ERROR');
 
291
                END CASE;
 
292
                    
 
293
                SET i = i - 1;
 
294
              END WHILE;
 
295
            END;
 
296
          ELSE
 
297
            INSERT INTO t1 VALUES('p1: case4: case5: ERROR');
 
298
        END CASE;
 
299
 
 
300
        CASE arg
 
301
          WHEN 10 THEN
 
302
            INSERT INTO t1 VALUES('p1: case4: case6: on 10');
 
303
          WHEN 20 THEN
 
304
            INSERT INTO t1 VALUES('p1: case4: case6: on 20');
 
305
          ELSE
 
306
            INSERT INTO t1 VALUES('p1: case4: case6: ERROR');
 
307
        END CASE;
 
308
      END;
 
309
    ELSE
 
310
      INSERT INTO t1 VALUES('p1: case4: ERROR');
 
311
  END CASE;
 
312
END|
 
313
 
 
314
CREATE PROCEDURE p2()
 
315
BEGIN
 
316
  DECLARE i TINYINT DEFAULT 3;
 
317
 
 
318
  WHILE i > 0 DO
 
319
    IF MOD(i, 2) = 0 THEN
 
320
      SET @_test_session_var = 10;
 
321
    ELSE
 
322
      SET @_test_session_var = 'test';
 
323
    END IF;
 
324
 
 
325
    CASE @_test_session_var
 
326
      WHEN 10 THEN
 
327
        INSERT INTO t1 VALUES('p2: case: numerical type');
 
328
      WHEN 'test' THEN
 
329
        INSERT INTO t1 VALUES('p2: case: string type');
 
330
      ELSE
 
331
        INSERT INTO t1 VALUES('p2: case: ERROR');
 
332
    END CASE;
 
333
 
 
334
    SET i = i - 1;
 
335
  END WHILE;
 
336
END|
 
337
 
 
338
delimiter ;|
 
339
 
 
340
CALL p1(10);
 
341
CALL p1(20);
 
342
 
 
343
CALL p2();
 
344
 
 
345
SELECT * FROM t1;
 
346
 
 
347
#
 
348
# Cleanup.
 
349
#
 
350
 
 
351
DROP PROCEDURE p1;
 
352
DROP PROCEDURE p2;
 
353
DROP TABLE t1;
 
354
 
 
355
###########################################################################
 
356
#
 
357
# Test case for BUG#14161: Stored procedure cannot retrieve bigint unsigned.
 
358
#
 
359
###########################################################################
 
360
 
 
361
--echo
 
362
--echo ---------------------------------------------------------------
 
363
--echo BUG#14161
 
364
--echo ---------------------------------------------------------------
 
365
--echo
 
366
 
 
367
#
 
368
# Prepare.
 
369
#
 
370
 
 
371
--disable_warnings
 
372
DROP TABLE IF EXISTS t1;
 
373
DROP PROCEDURE IF EXISTS p1;
 
374
--enable_warnings
 
375
 
 
376
#
 
377
# Test case.
 
378
#
 
379
 
 
380
CREATE TABLE t1(col BIGINT UNSIGNED);
 
381
 
 
382
INSERT INTO t1 VALUE(18446744073709551614);
 
383
 
 
384
delimiter |;
 
385
CREATE PROCEDURE p1(IN arg BIGINT UNSIGNED)
 
386
BEGIN
 
387
  SELECT arg;
 
388
  SELECT * FROM t1;
 
389
  SELECT * FROM t1 WHERE col = arg;
 
390
END|
 
391
delimiter ;|
 
392
 
 
393
CALL p1(18446744073709551614);
 
394
 
 
395
#
 
396
# Cleanup.
 
397
#
 
398
 
 
399
DROP TABLE t1;
 
400
DROP PROCEDURE p1;
 
401
 
 
402
###########################################################################
 
403
#
 
404
# Test case for BUG#13705: parameters to stored procedures are not verified.
 
405
#
 
406
###########################################################################
 
407
 
 
408
--echo
 
409
--echo ---------------------------------------------------------------
 
410
--echo BUG#13705
 
411
--echo ---------------------------------------------------------------
 
412
--echo
 
413
 
 
414
#
 
415
# Prepare.
 
416
#
 
417
 
 
418
--disable_warnings
 
419
DROP PROCEDURE IF EXISTS p1;
 
420
--enable_warnings
 
421
 
 
422
#
 
423
# Test case.
 
424
#
 
425
 
 
426
delimiter |;
 
427
CREATE PROCEDURE p1(x VARCHAR(10), y CHAR(3)) READS SQL DATA
 
428
BEGIN
 
429
  SELECT x, y;
 
430
END|
 
431
delimiter ;|
 
432
 
 
433
CALL p1('alpha', 'abc');
 
434
CALL p1('alpha', 'abcdef');
 
435
 
 
436
#
 
437
# Cleanup.
 
438
#
 
439
 
 
440
DROP PROCEDURE p1;
 
441
 
 
442
###########################################################################
 
443
#
 
444
# Test case for BUG#13675: DATETIME/DATE type in store proc param seems to be
 
445
# converted as varbinary.
 
446
#
 
447
# TODO: test case failed.
 
448
#
 
449
###########################################################################
 
450
 
 
451
--echo
 
452
--echo ---------------------------------------------------------------
 
453
--echo BUG#13675
 
454
--echo ---------------------------------------------------------------
 
455
--echo
 
456
 
 
457
#
 
458
# Prepare.
 
459
#
 
460
 
 
461
--disable_warnings
 
462
DROP PROCEDURE IF EXISTS p1;
 
463
DROP TABLE IF EXISTS t1;
 
464
--enable_warnings
 
465
 
 
466
#
 
467
# Test case.
 
468
#
 
469
 
 
470
delimiter |;
 
471
CREATE PROCEDURE p1(x DATETIME)
 
472
BEGIN
 
473
  CREATE TABLE t1 SELECT x;
 
474
  SHOW CREATE TABLE t1;
 
475
  DROP TABLE t1;
 
476
END|
 
477
delimiter ;|
 
478
 
 
479
CALL p1(NOW());
 
480
 
 
481
CALL p1('test');
 
482
 
 
483
#
 
484
# Cleanup.
 
485
#
 
486
 
 
487
DROP PROCEDURE p1;
 
488
 
 
489
###########################################################################
 
490
#
 
491
# Test case for BUG#12976: Boolean values reversed in stored procedures?
 
492
#
 
493
# TODO: test case failed.
 
494
#
 
495
###########################################################################
 
496
 
 
497
--echo
 
498
--echo ---------------------------------------------------------------
 
499
--echo BUG#12976
 
500
--echo ---------------------------------------------------------------
 
501
--echo
 
502
 
 
503
#
 
504
# Prepare.
 
505
#
 
506
 
 
507
--disable_warnings
 
508
DROP TABLE IF EXISTS t1;
 
509
DROP PROCEDURE IF EXISTS p1;
 
510
DROP PROCEDURE IF EXISTS p2;
 
511
--enable_warnings
 
512
 
 
513
#
 
514
# Test case.
 
515
#
 
516
 
 
517
CREATE TABLE t1(b BIT(1));
 
518
 
 
519
INSERT INTO t1(b) VALUES(b'0'), (b'1');
 
520
 
 
521
delimiter |;
 
522
CREATE PROCEDURE p1()
 
523
BEGIN
 
524
  SELECT HEX(b),
 
525
    b = 0,
 
526
    b = FALSE,
 
527
    b IS FALSE,
 
528
    b = 1,
 
529
    b = TRUE,
 
530
    b IS TRUE
 
531
  FROM t1;
 
532
END|
 
533
 
 
534
CREATE PROCEDURE p2()
 
535
BEGIN
 
536
  DECLARE vb BIT(1);
 
537
  SELECT b INTO vb FROM t1 WHERE b = 0;
 
538
 
 
539
  SELECT HEX(vb),
 
540
    vb = 0,
 
541
    vb = FALSE,
 
542
    vb IS FALSE,
 
543
    vb = 1,
 
544
    vb = TRUE,
 
545
    vb IS TRUE;
 
546
 
 
547
  SELECT b INTO vb FROM t1 WHERE b = 1;
 
548
 
 
549
  SELECT HEX(vb),
 
550
    vb = 0,
 
551
    vb = FALSE,
 
552
    vb IS FALSE,
 
553
    vb = 1,
 
554
    vb = TRUE,
 
555
    vb IS TRUE;
 
556
END|
 
557
delimiter ;|
 
558
 
 
559
# The expected and correct result.
 
560
 
 
561
call p1();
 
562
 
 
563
# The wrong result. Note that only hex(vb) works, but is printed with two
 
564
# digits for some reason in this case.
 
565
 
 
566
call p2();
 
567
 
 
568
#
 
569
# Cleanup.
 
570
#
 
571
 
 
572
DROP TABLE t1;
 
573
DROP PROCEDURE p1;
 
574
DROP PROCEDURE p2;
 
575
 
 
576
###########################################################################
 
577
#
 
578
# Test case for BUG#9572: Stored procedures: variable type declarations
 
579
# ignored.
 
580
#
 
581
###########################################################################
 
582
 
 
583
--echo
 
584
--echo ---------------------------------------------------------------
 
585
--echo BUG#9572
 
586
--echo ---------------------------------------------------------------
 
587
--echo
 
588
 
 
589
#
 
590
# Prepare.
 
591
#
 
592
 
 
593
--disable_warnings
 
594
DROP PROCEDURE IF EXISTS p1;
 
595
DROP PROCEDURE IF EXISTS p2;
 
596
DROP PROCEDURE IF EXISTS p3;
 
597
 
 
598
DROP PROCEDURE IF EXISTS p4;
 
599
DROP PROCEDURE IF EXISTS p5;
 
600
DROP PROCEDURE IF EXISTS p6;
 
601
--enable_warnings
 
602
 
 
603
#
 
604
# Test case.
 
605
#
 
606
 
 
607
SET @@sql_mode = 'traditional';
 
608
 
 
609
delimiter |;
 
610
 
 
611
CREATE PROCEDURE p1()
 
612
BEGIN
 
613
  DECLARE v TINYINT DEFAULT 1e200;
 
614
  SELECT v;
 
615
END|
 
616
 
 
617
CREATE PROCEDURE p2()
 
618
BEGIN
 
619
  DECLARE v DECIMAL(5) DEFAULT 1e200;
 
620
  SELECT v;
 
621
END|
 
622
 
 
623
CREATE PROCEDURE p3()
 
624
BEGIN
 
625
  DECLARE v CHAR(5) DEFAULT 'abcdef';
 
626
  SELECT v LIKE 'abc___';
 
627
END|
 
628
 
 
629
CREATE PROCEDURE p4(arg VARCHAR(2))
 
630
BEGIN
 
631
    DECLARE var VARCHAR(1);
 
632
    SET var := arg;
 
633
    SELECT arg, var;
 
634
END|
 
635
 
 
636
CREATE PROCEDURE p5(arg CHAR(2))
 
637
BEGIN
 
638
    DECLARE var CHAR(1);
 
639
    SET var := arg;
 
640
    SELECT arg, var;
 
641
END|
 
642
 
 
643
CREATE PROCEDURE p6(arg DECIMAL(2))
 
644
BEGIN
 
645
    DECLARE var DECIMAL(1);
 
646
    SET var := arg;
 
647
    SELECT arg, var;
 
648
END|
 
649
 
 
650
delimiter ;|
 
651
 
 
652
--error ER_WARN_DATA_OUT_OF_RANGE
 
653
CALL p1();
 
654
--error ER_WARN_DATA_OUT_OF_RANGE
 
655
CALL p2();
 
656
--error ER_DATA_TOO_LONG
 
657
CALL p3();
 
658
 
 
659
--error ER_DATA_TOO_LONG
 
660
CALL p4('aaa'); 
 
661
--error ER_DATA_TOO_LONG
 
662
CALL p5('aa');
 
663
--error ER_WARN_DATA_OUT_OF_RANGE
 
664
CALL p6(10);
 
665
 
 
666
#
 
667
# Cleanup.
 
668
#
 
669
 
 
670
SET @@sql_mode = 'ansi';
 
671
 
 
672
DROP PROCEDURE p1;
 
673
DROP PROCEDURE p2;
 
674
DROP PROCEDURE p3;
 
675
 
 
676
DROP PROCEDURE p4;
 
677
DROP PROCEDURE p5;
 
678
DROP PROCEDURE p6;
 
679
 
 
680
###########################################################################
 
681
#
 
682
# Test case for BUG#9078: STORED PROCDURE: Decimal digits are not displayed
 
683
# when we use DECIMAL datatype.
 
684
#
 
685
###########################################################################
 
686
 
 
687
--echo
 
688
--echo ---------------------------------------------------------------
 
689
--echo BUG#9078
 
690
--echo ---------------------------------------------------------------
 
691
--echo
 
692
 
 
693
#
 
694
# Prepare.
 
695
#
 
696
 
 
697
--disable_warnings
 
698
DROP PROCEDURE IF EXISTS p1;
 
699
--enable_warnings
 
700
 
 
701
#
 
702
# Test case.
 
703
#
 
704
 
 
705
delimiter |;
 
706
CREATE PROCEDURE p1 (arg DECIMAL(64,2))
 
707
BEGIN
 
708
  DECLARE var DECIMAL(64,2);
 
709
 
 
710
  SET var = arg;
 
711
  SELECT var;
 
712
END|
 
713
delimiter ;|
 
714
 
 
715
CALL p1(1929);
 
716
CALL p1(1929.00);
 
717
CALL p1(1929.003);
 
718
 
 
719
#
 
720
# Cleanup.
 
721
#
 
722
 
 
723
DROP PROCEDURE p1;
 
724
 
 
725
###########################################################################
 
726
#
 
727
# Test case for BUG#8768: Functions: For any unsigned data type, -ve values can
 
728
# be passed and returned.
 
729
#
 
730
# TODO: there is a bug here -- the function created in ANSI mode should not
 
731
# throw errors instead of warnings if called in TRADITIONAL mode.
 
732
#
 
733
###########################################################################
 
734
 
 
735
--echo
 
736
--echo ---------------------------------------------------------------
 
737
--echo BUG#8768
 
738
--echo ---------------------------------------------------------------
 
739
--echo
 
740
 
 
741
#
 
742
# Prepare.
 
743
#
 
744
 
 
745
--disable_warnings
 
746
DROP FUNCTION IF EXISTS f1;
 
747
--enable_warnings
 
748
 
 
749
#
 
750
# Test case.
 
751
#
 
752
 
 
753
# Create a function in ANSI mode.
 
754
 
 
755
delimiter |;
 
756
CREATE FUNCTION f1(arg TINYINT UNSIGNED) RETURNS TINYINT
 
757
BEGIN
 
758
  RETURN arg;
 
759
END|
 
760
delimiter ;|
 
761
 
 
762
SELECT f1(-2500);
 
763
 
 
764
# Call in TRADITIONAL mode the function created in ANSI mode.
 
765
 
 
766
SET @@sql_mode = 'traditional';
 
767
 
 
768
# TODO: a warning should be emitted here.
 
769
--error ER_WARN_DATA_OUT_OF_RANGE
 
770
SELECT f1(-2500);
 
771
 
 
772
# Recreate the function in TRADITIONAL mode.
 
773
 
 
774
DROP FUNCTION f1;
 
775
 
 
776
delimiter |;
 
777
CREATE FUNCTION f1(arg TINYINT UNSIGNED) RETURNS TINYINT
 
778
BEGIN
 
779
  RETURN arg;
 
780
END|
 
781
delimiter ;|
 
782
 
 
783
--error ER_WARN_DATA_OUT_OF_RANGE
 
784
SELECT f1(-2500);
 
785
 
 
786
#
 
787
# Cleanup.
 
788
#
 
789
 
 
790
SET @@sql_mode = 'ansi';
 
791
 
 
792
DROP FUNCTION f1;
 
793
 
 
794
###########################################################################
 
795
#
 
796
# Test case for BUG#8769: Functions: For Int datatypes, out of range values can
 
797
# be passed and returned.
 
798
#
 
799
# TODO: there is a bug here -- the function created in ANSI mode should not
 
800
# throw errors instead of warnings if called in TRADITIONAL mode.
 
801
#
 
802
###########################################################################
 
803
 
 
804
--echo
 
805
--echo ---------------------------------------------------------------
 
806
--echo BUG#8769
 
807
--echo ---------------------------------------------------------------
 
808
--echo
 
809
 
 
810
#
 
811
# Prepare.
 
812
#
 
813
 
 
814
--disable_warnings
 
815
DROP FUNCTION IF EXISTS f1;
 
816
--enable_warnings
 
817
 
 
818
#
 
819
# Test case.
 
820
#
 
821
 
 
822
# Create a function in ANSI mode.
 
823
 
 
824
delimiter |;
 
825
CREATE FUNCTION f1(arg MEDIUMINT) RETURNS MEDIUMINT
 
826
BEGIN
 
827
  RETURN arg;
 
828
END|
 
829
delimiter ;|
 
830
 
 
831
SELECT f1(8388699);
 
832
 
 
833
# Call in TRADITIONAL mode the function created in ANSI mode.
 
834
 
 
835
SET @@sql_mode = 'traditional';
 
836
 
 
837
# TODO: a warning should be emitted here.
 
838
--error ER_WARN_DATA_OUT_OF_RANGE
 
839
SELECT f1(8388699);
 
840
 
 
841
# Recreate the function in TRADITIONAL mode.
 
842
 
 
843
DROP FUNCTION f1;
 
844
 
 
845
delimiter |;
 
846
CREATE FUNCTION f1(arg MEDIUMINT) RETURNS MEDIUMINT
 
847
BEGIN
 
848
  RETURN arg;
 
849
END|
 
850
delimiter ;|
 
851
 
 
852
--error ER_WARN_DATA_OUT_OF_RANGE
 
853
SELECT f1(8388699);
 
854
 
 
855
#
 
856
# Cleanup.
 
857
#
 
858
 
 
859
SET @@sql_mode = 'ansi';
 
860
 
 
861
DROP FUNCTION f1;
 
862
 
 
863
###########################################################################
 
864
#
 
865
# Test case for BUG#8702: Stored Procedures: No Error/Warning shown for
 
866
# inappropriate data type matching.
 
867
#
 
868
###########################################################################
 
869
 
 
870
--echo
 
871
--echo ---------------------------------------------------------------
 
872
--echo BUG#8702
 
873
--echo ---------------------------------------------------------------
 
874
--echo
 
875
 
 
876
#
 
877
# Prepare.
 
878
#
 
879
 
 
880
--disable_warnings
 
881
DROP PROCEDURE IF EXISTS p1;
 
882
DROP TABLE IF EXISTS t1;
 
883
--enable_warnings
 
884
 
 
885
#
 
886
# Test case.
 
887
#
 
888
 
 
889
CREATE TABLE t1(col VARCHAR(255));
 
890
 
 
891
INSERT INTO t1(col) VALUES('Hello, world!');
 
892
 
 
893
delimiter |;
 
894
CREATE PROCEDURE p1()
 
895
BEGIN
 
896
  DECLARE sp_var INTEGER;
 
897
 
 
898
  SELECT col INTO sp_var FROM t1 LIMIT 1;
 
899
  SET @user_var = sp_var;
 
900
 
 
901
  SELECT sp_var;
 
902
  SELECT @user_var;
 
903
END|
 
904
delimiter ;|
 
905
 
 
906
CALL p1();
 
907
 
 
908
#
 
909
# Cleanup.
 
910
#
 
911
 
 
912
DROP PROCEDURE p1;
 
913
DROP TABLE t1;
 
914
 
 
915
###########################################################################
 
916
#
 
917
# Test case for BUG#12903: upper function does not work inside a function.
 
918
#
 
919
###########################################################################
 
920
 
 
921
--echo
 
922
--echo ---------------------------------------------------------------
 
923
--echo BUG#12903
 
924
--echo ---------------------------------------------------------------
 
925
--echo
 
926
 
 
927
#
 
928
# Prepare.
 
929
#
 
930
 
 
931
--disable_warnings
 
932
DROP FUNCTION IF EXISTS f1;
 
933
DROP TABLE IF EXISTS t1;
 
934
--enable_warnings
 
935
 
 
936
#
 
937
# Test case.
 
938
#
 
939
 
 
940
CREATE TABLE t1(txt VARCHAR(255));
 
941
 
 
942
delimiter |;
 
943
CREATE FUNCTION f1(arg VARCHAR(255)) RETURNS VARCHAR(255)
 
944
BEGIN
 
945
  DECLARE v1 VARCHAR(255);
 
946
  DECLARE v2 VARCHAR(255);
 
947
 
 
948
  SET v1 = CONCAT(LOWER(arg), UPPER(arg));
 
949
  SET v2 = CONCAT(LOWER(v1), UPPER(v1));
 
950
 
 
951
  INSERT INTO t1 VALUES(v1), (v2);
 
952
 
 
953
  RETURN CONCAT(LOWER(arg), UPPER(arg));
 
954
END|
 
955
delimiter ;|
 
956
 
 
957
SELECT f1('_aBcDe_');
 
958
 
 
959
SELECT * FROM t1;
 
960
 
 
961
#
 
962
# Cleanup.
 
963
#
 
964
 
 
965
DROP FUNCTION f1;
 
966
DROP TABLE t1;
 
967
 
 
968
###########################################################################
 
969
#
 
970
# Test case for BUG#13808: ENUM type stored procedure parameter accepts
 
971
# non-enumerated data.
 
972
#
 
973
###########################################################################
 
974
 
 
975
--echo
 
976
--echo ---------------------------------------------------------------
 
977
--echo BUG#13808
 
978
--echo ---------------------------------------------------------------
 
979
--echo
 
980
 
 
981
#
 
982
# Prepare.
 
983
#
 
984
 
 
985
--disable_warnings
 
986
DROP PROCEDURE IF EXISTS p1;
 
987
DROP PROCEDURE IF EXISTS p2;
 
988
DROP FUNCTION IF EXISTS f1;
 
989
--enable_warnings
 
990
 
 
991
#
 
992
# Test case.
 
993
#
 
994
 
 
995
delimiter |;
 
996
 
 
997
CREATE PROCEDURE p1(arg ENUM('a', 'b'))
 
998
BEGIN
 
999
  SELECT arg;
 
1000
END|
 
1001
 
 
1002
CREATE PROCEDURE p2(arg ENUM('a', 'b'))
 
1003
BEGIN
 
1004
  DECLARE var ENUM('c', 'd') DEFAULT arg;
 
1005
 
 
1006
  SELECT arg, var;
 
1007
END|
 
1008
 
 
1009
CREATE FUNCTION f1(arg ENUM('a', 'b')) RETURNS ENUM('c', 'd')
 
1010
BEGIN
 
1011
  RETURN arg;
 
1012
END|
 
1013
 
 
1014
delimiter ;|
 
1015
 
 
1016
CALL p1('c');
 
1017
 
 
1018
CALL p2('a');
 
1019
 
 
1020
SELECT f1('a');
 
1021
 
 
1022
#
 
1023
# Cleanup.
 
1024
#
 
1025
 
 
1026
DROP PROCEDURE p1;
 
1027
DROP PROCEDURE p2;
 
1028
DROP FUNCTION f1;
 
1029
 
 
1030
###########################################################################
 
1031
#
 
1032
# Test case for BUG#13909: Varchar Stored Procedure Parameter always BINARY
 
1033
# string (ignores CHARACTER SET).
 
1034
#
 
1035
###########################################################################
 
1036
 
 
1037
--echo
 
1038
--echo ---------------------------------------------------------------
 
1039
--echo BUG#13909
 
1040
--echo ---------------------------------------------------------------
 
1041
--echo
 
1042
 
 
1043
#
 
1044
# Prepare.
 
1045
#
 
1046
 
 
1047
--disable_warnings
 
1048
DROP PROCEDURE IF EXISTS p1;
 
1049
DROP PROCEDURE IF EXISTS p2;
 
1050
--enable_warnings
 
1051
 
 
1052
#
 
1053
# Test case.
 
1054
#
 
1055
 
 
1056
delimiter |;
 
1057
 
 
1058
CREATE PROCEDURE p1(arg VARCHAR(255))
 
1059
BEGIN
 
1060
  SELECT CHARSET(arg);
 
1061
END|
 
1062
 
 
1063
CREATE PROCEDURE p2(arg VARCHAR(255) CHARACTER SET UTF8)
 
1064
BEGIN
 
1065
    SELECT CHARSET(arg);
 
1066
END|
 
1067
 
 
1068
delimiter ;|
 
1069
 
 
1070
CALL p1('t');
 
1071
CALL p1(_UTF8 't');
 
1072
 
 
1073
 
 
1074
CALL p2('t');
 
1075
CALL p2(_LATIN1 't');
 
1076
 
 
1077
#
 
1078
# Cleanup.
 
1079
#
 
1080
 
 
1081
DROP PROCEDURE p1;
 
1082
DROP PROCEDURE p2;
 
1083
 
 
1084
###########################################################################
 
1085
#
 
1086
# Test case for BUG#14188: BINARY variables have no 0x00 padding.
 
1087
#
 
1088
###########################################################################
 
1089
 
 
1090
--echo
 
1091
--echo ---------------------------------------------------------------
 
1092
--echo BUG#14188
 
1093
--echo ---------------------------------------------------------------
 
1094
--echo
 
1095
 
 
1096
#
 
1097
# Prepare.
 
1098
#
 
1099
 
 
1100
--disable_warnings
 
1101
DROP PROCEDURE IF EXISTS p1;
 
1102
--enable_warnings
 
1103
 
 
1104
#
 
1105
# Test case.
 
1106
#
 
1107
 
 
1108
delimiter |;
 
1109
CREATE PROCEDURE p1(arg1 BINARY(2), arg2 VARBINARY(2))
 
1110
BEGIN
 
1111
  DECLARE var1 BINARY(2) DEFAULT 0x41;
 
1112
  DECLARE var2 VARBINARY(2) DEFAULT 0x42;
 
1113
 
 
1114
  SELECT HEX(arg1), HEX(arg2);
 
1115
  SELECT HEX(var1), HEX(var2);
 
1116
END|
 
1117
delimiter ;|
 
1118
 
 
1119
CALL p1(0x41, 0x42);
 
1120
 
 
1121
#
 
1122
# Cleanup.
 
1123
#
 
1124
 
 
1125
DROP PROCEDURE p1;
 
1126
 
 
1127
###########################################################################
 
1128
#
 
1129
# Test case for BUG#15148: Stored procedure variables accept non-scalar values.
 
1130
#
 
1131
###########################################################################
 
1132
 
 
1133
--echo
 
1134
--echo ---------------------------------------------------------------
 
1135
--echo BUG#15148
 
1136
--echo ---------------------------------------------------------------
 
1137
--echo
 
1138
 
 
1139
#
 
1140
# Prepare.
 
1141
#
 
1142
 
 
1143
--disable_warnings
 
1144
DROP PROCEDURE IF EXISTS p1;
 
1145
DROP TABLE IF EXISTS t1;
 
1146
--enable_warnings
 
1147
 
 
1148
#
 
1149
# Test case.
 
1150
#
 
1151
 
 
1152
CREATE TABLE t1(col1 TINYINT, col2 TINYINT);
 
1153
 
 
1154
INSERT INTO t1 VALUES(1, 2), (11, 12);
 
1155
 
 
1156
delimiter |;
 
1157
CREATE PROCEDURE p1(arg TINYINT)
 
1158
BEGIN
 
1159
  SELECT arg;
 
1160
END|
 
1161
delimiter ;|
 
1162
 
 
1163
--error ER_OPERAND_COLUMNS
 
1164
CALL p1((1, 2));
 
1165
 
 
1166
--error ER_OPERAND_COLUMNS
 
1167
CALL p1((SELECT * FROM t1 LIMIT 1));
 
1168
 
 
1169
--error ER_OPERAND_COLUMNS
 
1170
CALL p1((SELECT col1, col2 FROM t1 LIMIT 1));
 
1171
 
 
1172
#
 
1173
# Cleanup.
 
1174
#
 
1175
 
 
1176
DROP PROCEDURE p1;
 
1177
DROP TABLE t1;
 
1178
 
 
1179
###########################################################################
 
1180
#
 
1181
# Test case for BUG#13613: substring function in stored procedure.
 
1182
#
 
1183
###########################################################################
 
1184
 
 
1185
--echo
 
1186
--echo ---------------------------------------------------------------
 
1187
--echo BUG#13613
 
1188
--echo ---------------------------------------------------------------
 
1189
--echo
 
1190
 
 
1191
#
 
1192
# Prepare.
 
1193
#
 
1194
 
 
1195
--disable_warnings
 
1196
DROP PROCEDURE IF EXISTS p1;
 
1197
DROP FUNCTION IF EXISTS f1;
 
1198
--enable_warnings
 
1199
 
 
1200
#
 
1201
# Test case.
 
1202
#
 
1203
 
 
1204
delimiter |;
 
1205
 
 
1206
CREATE PROCEDURE p1(x VARCHAR(50))
 
1207
BEGIN
 
1208
  SET x = SUBSTRING(x, 1, 3);
 
1209
  SELECT x;
 
1210
END|
 
1211
 
 
1212
CREATE FUNCTION f1(x VARCHAR(50)) RETURNS VARCHAR(50)
 
1213
BEGIN
 
1214
  RETURN SUBSTRING(x, 1, 3);
 
1215
END|
 
1216
 
 
1217
delimiter ;|
 
1218
 
 
1219
CALL p1('abcdef');
 
1220
 
 
1221
SELECT f1('ABCDEF');
 
1222
 
 
1223
#
 
1224
# Cleanup.
 
1225
#
 
1226
 
 
1227
DROP PROCEDURE p1;
 
1228
DROP FUNCTION f1;
 
1229
 
 
1230
###########################################################################
 
1231
#
 
1232
# Test case for BUG#13665: concat with '' produce incorrect results in SP.
 
1233
#
 
1234
###########################################################################
 
1235
 
 
1236
--echo
 
1237
--echo ---------------------------------------------------------------
 
1238
--echo BUG#13665
 
1239
--echo ---------------------------------------------------------------
 
1240
--echo
 
1241
 
 
1242
#
 
1243
# Prepare.
 
1244
#
 
1245
 
 
1246
--disable_warnings
 
1247
DROP FUNCTION IF EXISTS f1;
 
1248
--enable_warnings
 
1249
 
 
1250
#
 
1251
# Test case.
 
1252
#
 
1253
 
 
1254
delimiter |;
 
1255
CREATE FUNCTION f1() RETURNS VARCHAR(20000)
 
1256
BEGIN
 
1257
  DECLARE var VARCHAR(2000);
 
1258
 
 
1259
  SET var = '';
 
1260
  SET var = CONCAT(var, 'abc');
 
1261
  SET var = CONCAT(var, '');
 
1262
 
 
1263
  RETURN var;
 
1264
END|
 
1265
delimiter ;|
 
1266
 
 
1267
SELECT f1();
 
1268
 
 
1269
#
 
1270
# Cleanup.
 
1271
#
 
1272
 
 
1273
DROP FUNCTION f1;
 
1274
 
 
1275
 
 
1276
#
 
1277
# Bug#17226: Variable set in cursor on first iteration is assigned
 
1278
# second iterations value
 
1279
#
 
1280
# The problem was in incorrect handling of local variables of type
 
1281
# TEXT (BLOB).
 
1282
#
 
1283
--disable_warnings
 
1284
DROP PROCEDURE IF EXISTS p1;
 
1285
--enable_warnings
 
1286
 
 
1287
delimiter |;
 
1288
CREATE PROCEDURE p1()
 
1289
BEGIN
 
1290
  DECLARE v_char VARCHAR(255);
 
1291
  DECLARE v_text TEXT DEFAULT '';
 
1292
 
 
1293
  SET v_char = 'abc';
 
1294
 
 
1295
  SET v_text = v_char;
 
1296
 
 
1297
  SET v_char = 'def';
 
1298
 
 
1299
  SET v_text = concat(v_text, '|', v_char);
 
1300
 
 
1301
  SELECT v_text;
 
1302
END|
 
1303
delimiter ;|
 
1304
 
 
1305
CALL p1();
 
1306
 
 
1307
DROP PROCEDURE p1;
 
1308
 
 
1309
# End of 5.0 tests.