Commit ec9b9a98 authored by malff/marcsql@weblab.(none)'s avatar malff/marcsql@weblab.(none)
Browse files

Bug#30625 (Performance, reduce depth for expressions) 

This is a performance bug, affecting in particular the bison generated code
for the parser.

Prior to this fix, the grammar used a long chain of reduces to parse an
expression, like:
  bit_expr -> bit_term
  bit_term -> bit_factor
  bit_factor -> value_expr
  value_expr -> term
  term -> factor
etc

This chain of reduces cause the internal state automaton in the generated
parser to execute more state transitions and more reduces, so that the
generated MySQLParse() function would spend a lot of time looping to execute
all the grammar reductions.

With this patch, the grammar has been reorganized so that rules are more
"flat", limiting the depth of reduces needed to parse <expr>.

Tests have been written to enforce that relative priorities and properties
of operators have not changed while changing the grammar.

See the bug report for performance data.
parent 7a1942d2

mysql-test/r/parser_precedence.result

+391 −0
Original line number Diff line number Diff line
@@ -354,3 +354,394 @@ where (A OR (B XOR C)) != (A OR B XOR C); 
count(*)

0

drop table t1_30237_bool;

Testing that NOT has precedence over OR

select (NOT FALSE) OR TRUE, NOT (FALSE OR TRUE), NOT FALSE OR TRUE;

(NOT FALSE) OR TRUE	NOT (FALSE OR TRUE)	NOT FALSE OR TRUE

1	0	1

Testing that NOT has precedence over XOR

select (NOT FALSE) XOR FALSE, NOT (FALSE XOR FALSE), NOT FALSE XOR FALSE;

(NOT FALSE) XOR FALSE	NOT (FALSE XOR FALSE)	NOT FALSE XOR FALSE

1	1	1

Testing that NOT has precedence over AND

select (NOT FALSE) AND FALSE, NOT (FALSE AND FALSE), NOT FALSE AND FALSE;

(NOT FALSE) AND FALSE	NOT (FALSE AND FALSE)	NOT FALSE AND FALSE

0	1	0

Testing that NOT is associative

select NOT NOT TRUE, NOT NOT NOT FALSE;

NOT NOT TRUE	NOT NOT NOT FALSE

1	1

Testing that IS has precedence over NOT

select (NOT NULL) IS TRUE, NOT (NULL IS TRUE), NOT NULL IS TRUE;

(NOT NULL) IS TRUE	NOT (NULL IS TRUE)	NOT NULL IS TRUE

0	1	1

select (NOT NULL) IS NOT TRUE, NOT (NULL IS NOT TRUE), NOT NULL IS NOT TRUE;

(NOT NULL) IS NOT TRUE	NOT (NULL IS NOT TRUE)	NOT NULL IS NOT TRUE

1	0	0

select (NOT NULL) IS FALSE, NOT (NULL IS FALSE), NOT NULL IS FALSE;

(NOT NULL) IS FALSE	NOT (NULL IS FALSE)	NOT NULL IS FALSE

0	1	1

select (NOT NULL) IS NOT FALSE, NOT (NULL IS NOT FALSE), NOT NULL IS NOT FALSE;

(NOT NULL) IS NOT FALSE	NOT (NULL IS NOT FALSE)	NOT NULL IS NOT FALSE

1	0	0

select (NOT TRUE) IS UNKNOWN, NOT (TRUE IS UNKNOWN), NOT TRUE IS UNKNOWN;

(NOT TRUE) IS UNKNOWN	NOT (TRUE IS UNKNOWN)	NOT TRUE IS UNKNOWN

0	1	1

select (NOT TRUE) IS NOT UNKNOWN, NOT (TRUE IS NOT UNKNOWN), NOT TRUE IS NOT UNKNOWN;

(NOT TRUE) IS NOT UNKNOWN	NOT (TRUE IS NOT UNKNOWN)	NOT TRUE IS NOT UNKNOWN

1	0	0

select (NOT TRUE) IS NULL, NOT (TRUE IS NULL), NOT TRUE IS NULL;

(NOT TRUE) IS NULL	NOT (TRUE IS NULL)	NOT TRUE IS NULL

0	1	1

select (NOT TRUE) IS NOT NULL, NOT (TRUE IS NOT NULL), NOT TRUE IS NOT NULL;

(NOT TRUE) IS NOT NULL	NOT (TRUE IS NOT NULL)	NOT TRUE IS NOT NULL

1	0	0

Testing that IS [NOT] TRUE/FALSE/UNKNOWN predicates are not associative

select TRUE IS TRUE IS TRUE IS TRUE;

ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'IS TRUE IS TRUE' at line 1

select FALSE IS NOT TRUE IS NOT TRUE IS NOT TRUE;

ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'IS NOT TRUE IS NOT TRUE' at line 1

select NULL IS FALSE IS FALSE IS FALSE;

ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'IS FALSE IS FALSE' at line 1

select TRUE IS NOT FALSE IS NOT FALSE IS NOT FALSE;

ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'IS NOT FALSE IS NOT FALSE' at line 1

select FALSE IS UNKNOWN IS UNKNOWN IS UNKNOWN;

ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'IS UNKNOWN IS UNKNOWN' at line 1

select TRUE IS NOT UNKNOWN IS NOT UNKNOWN IS NOT UNKNOWN;

ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'IS NOT UNKNOWN IS NOT UNKNOWN' at line 1

Testing that IS [NOT] NULL predicates are associative

select FALSE IS NULL IS NULL IS NULL;

FALSE IS NULL IS NULL IS NULL

0

select TRUE IS NOT NULL IS NOT NULL IS NOT NULL;

TRUE IS NOT NULL IS NOT NULL IS NOT NULL

1

Testing that comparison operators are left associative

select 1 <=> 2 <=> 2, (1 <=> 2) <=> 2, 1 <=> (2 <=> 2);

1 <=> 2 <=> 2	(1 <=> 2) <=> 2	1 <=> (2 <=> 2)

0	0	1

select 1 = 2 = 2, (1 = 2) = 2, 1 = (2 = 2);

1 = 2 = 2	(1 = 2) = 2	1 = (2 = 2)

0	0	1

select 1 != 2 != 3, (1 != 2) != 3, 1 != (2 != 3);

1 != 2 != 3	(1 != 2) != 3	1 != (2 != 3)

1	1	0

select 1 <> 2 <> 3, (1 <> 2) <> 3, 1 <> (2 <> 3);

1 <> 2 <> 3	(1 <> 2) <> 3	1 <> (2 <> 3)

1	1	0

select 1 < 2 < 3, (1 < 2) < 3, 1 < (2 < 3);

1 < 2 < 3	(1 < 2) < 3	1 < (2 < 3)

1	1	0

select 3 <= 2 <= 1, (3 <= 2) <= 1, 3 <= (2 <= 1);

3 <= 2 <= 1	(3 <= 2) <= 1	3 <= (2 <= 1)

1	1	0

select 1 > 2 > 3, (1 > 2) > 3, 1 > (2 > 3);

1 > 2 > 3	(1 > 2) > 3	1 > (2 > 3)

0	0	1

select 1 >= 2 >= 3, (1 >= 2) >= 3, 1 >= (2 >= 3);

1 >= 2 >= 3	(1 >= 2) >= 3	1 >= (2 >= 3)

0	0	1

Testing that | is associative

select 0xF0 | 0x0F | 0x55, (0xF0 | 0x0F) | 0x55, 0xF0 | (0x0F | 0x55);

0xF0 | 0x0F | 0x55	(0xF0 | 0x0F) | 0x55	0xF0 | (0x0F | 0x55)

255	255	255

Testing that & is associative

select 0xF5 & 0x5F & 0x55, (0xF5 & 0x5F) & 0x55, 0xF5 & (0x5F & 0x55);

0xF5 & 0x5F & 0x55	(0xF5 & 0x5F) & 0x55	0xF5 & (0x5F & 0x55)

85	85	85

Testing that << is left associative

select 4 << 3 << 2, (4 << 3) << 2, 4 << (3 << 2);

4 << 3 << 2	(4 << 3) << 2	4 << (3 << 2)

128	128	16384

Testing that >> is left associative

select 256 >> 3 >> 2, (256 >> 3) >> 2, 256 >> (3 >> 2);

256 >> 3 >> 2	(256 >> 3) >> 2	256 >> (3 >> 2)

8	8	256

Testing that & has precedence over |

select 0xF0 & 0x0F | 0x55, (0xF0 & 0x0F) | 0x55, 0xF0 & (0x0F | 0x55);

0xF0 & 0x0F | 0x55	(0xF0 & 0x0F) | 0x55	0xF0 & (0x0F | 0x55)

85	85	80

select 0x55 | 0xF0 & 0x0F, (0x55 | 0xF0) & 0x0F, 0x55 | (0xF0 & 0x0F);

0x55 | 0xF0 & 0x0F	(0x55 | 0xF0) & 0x0F	0x55 | (0xF0 & 0x0F)

85	5	85

Testing that << has precedence over |

select 0x0F << 4 | 0x0F, (0x0F << 4) | 0x0F, 0x0F << (4 | 0x0F);

0x0F << 4 | 0x0F	(0x0F << 4) | 0x0F	0x0F << (4 | 0x0F)

255	255	491520

select 0x0F | 0x0F << 4, (0x0F | 0x0F) << 4, 0x0F | (0x0F << 4);

0x0F | 0x0F << 4	(0x0F | 0x0F) << 4	0x0F | (0x0F << 4)

255	240	255

Testing that >> has precedence over |

select 0xF0 >> 4 | 0xFF, (0xF0 >> 4) | 0xFF, 0xF0 >> (4 | 0xFF);

0xF0 >> 4 | 0xFF	(0xF0 >> 4) | 0xFF	0xF0 >> (4 | 0xFF)

255	255	0

select 0xFF | 0xF0 >> 4, (0xFF | 0xF0) >> 4, 0xFF | (0xF0 >> 4);

0xFF | 0xF0 >> 4	(0xFF | 0xF0) >> 4	0xFF | (0xF0 >> 4)

255	15	255

Testing that << has precedence over &

select 0x0F << 4 & 0xF0, (0x0F << 4) & 0xF0, 0x0F << (4 & 0xF0);

0x0F << 4 & 0xF0	(0x0F << 4) & 0xF0	0x0F << (4 & 0xF0)

240	240	15

select 0xF0 & 0x0F << 4, (0xF0 & 0x0F) << 4, 0xF0 & (0x0F << 4);

0xF0 & 0x0F << 4	(0xF0 & 0x0F) << 4	0xF0 & (0x0F << 4)

240	0	240

Testing that >> has precedence over &

select 0xF0 >> 4 & 0x55, (0xF0 >> 4) & 0x55, 0xF0 >> (4 & 0x55);

0xF0 >> 4 & 0x55	(0xF0 >> 4) & 0x55	0xF0 >> (4 & 0x55)

5	5	15

select 0x0F & 0xF0 >> 4, (0x0F & 0xF0) >> 4, 0x0F & (0xF0 >> 4);

0x0F & 0xF0 >> 4	(0x0F & 0xF0) >> 4	0x0F & (0xF0 >> 4)

15	0	15

Testing that >> and << have the same precedence

select 0xFF >> 4 << 2, (0xFF >> 4) << 2, 0xFF >> (4 << 2);

0xFF >> 4 << 2	(0xFF >> 4) << 2	0xFF >> (4 << 2)

60	60	0

select 0x0F << 4 >> 2, (0x0F << 4) >> 2, 0x0F << (4 >> 2);

0x0F << 4 >> 2	(0x0F << 4) >> 2	0x0F << (4 >> 2)

60	60	30

Testing that binary + is associative

select 1 + 2 + 3, (1 + 2) + 3, 1 + (2 + 3);

1 + 2 + 3	(1 + 2) + 3	1 + (2 + 3)

6	6	6

Testing that binary - is left associative

select 1 - 2 - 3, (1 - 2) - 3, 1 - (2 - 3);

1 - 2 - 3	(1 - 2) - 3	1 - (2 - 3)

-4	-4	2

Testing that binary + and binary - have the same precedence

select 1 + 2 - 3, (1 + 2) - 3, 1 + (2 - 3);

1 + 2 - 3	(1 + 2) - 3	1 + (2 - 3)

0	0	0

select 1 - 2 + 3, (1 - 2) + 3, 1 - (2 + 3);

1 - 2 + 3	(1 - 2) + 3	1 - (2 + 3)

2	2	-4

Testing that binary + has precedence over |

select 0xF0 + 0x0F | 0x55, (0xF0 + 0x0F) | 0x55, 0xF0 + (0x0F | 0x55);

0xF0 + 0x0F | 0x55	(0xF0 + 0x0F) | 0x55	0xF0 + (0x0F | 0x55)

255	255	335

select 0x55 | 0xF0 + 0x0F, (0x55 | 0xF0) + 0x0F, 0x55 | (0xF0 + 0x0F);

0x55 | 0xF0 + 0x0F	(0x55 | 0xF0) + 0x0F	0x55 | (0xF0 + 0x0F)

255	260	255

Testing that binary + has precedence over &

select 0xF0 + 0x0F & 0x55, (0xF0 + 0x0F) & 0x55, 0xF0 + (0x0F & 0x55);

0xF0 + 0x0F & 0x55	(0xF0 + 0x0F) & 0x55	0xF0 + (0x0F & 0x55)

85	85	245

select 0x55 & 0xF0 + 0x0F, (0x55 & 0xF0) + 0x0F, 0x55 & (0xF0 + 0x0F);

0x55 & 0xF0 + 0x0F	(0x55 & 0xF0) + 0x0F	0x55 & (0xF0 + 0x0F)

85	95	85

Testing that binary + has precedence over <<

select 2 + 3 << 4, (2 + 3) << 4, 2 + (3 << 4);

2 + 3 << 4	(2 + 3) << 4	2 + (3 << 4)

80	80	50

select 3 << 4 + 2, (3 << 4) + 2, 3 << (4 + 2);

3 << 4 + 2	(3 << 4) + 2	3 << (4 + 2)

192	50	192

Testing that binary + has precedence over >>

select 4 + 3 >> 2, (4 + 3) >> 2, 4 + (3 >> 2);

4 + 3 >> 2	(4 + 3) >> 2	4 + (3 >> 2)

1	1	4

select 3 >> 2 + 1, (3 >> 2) + 1, 3 >> (2 + 1);

3 >> 2 + 1	(3 >> 2) + 1	3 >> (2 + 1)

0	1	0

Testing that binary - has precedence over |

select 0xFF - 0x0F | 0x55, (0xFF - 0x0F) | 0x55, 0xFF - (0x0F | 0x55);

0xFF - 0x0F | 0x55	(0xFF - 0x0F) | 0x55	0xFF - (0x0F | 0x55)

245	245	160

select 0x55 | 0xFF - 0xF0, (0x55 | 0xFF) - 0xF0, 0x55 | (0xFF - 0xF0);

0x55 | 0xFF - 0xF0	(0x55 | 0xFF) - 0xF0	0x55 | (0xFF - 0xF0)

95	15	95

Testing that binary - has precedence over &

select 0xFF - 0xF0 & 0x55, (0xFF - 0xF0) & 0x55, 0xFF - (0xF0 & 0x55);

0xFF - 0xF0 & 0x55	(0xFF - 0xF0) & 0x55	0xFF - (0xF0 & 0x55)

5	5	175

select 0x55 & 0xFF - 0xF0, (0x55 & 0xFF) - 0xF0, 0x55 & (0xFF - 0xF0);

0x55 & 0xFF - 0xF0	(0x55 & 0xFF) - 0xF0	0x55 & (0xFF - 0xF0)

5	-155	5

Testing that binary - has precedence over <<

select 16 - 3 << 2, (16 - 3) << 2, 16 - (3 << 2);

16 - 3 << 2	(16 - 3) << 2	16 - (3 << 2)

52	52	4

select 4 << 3 - 2, (4 << 3) - 2, 4 << (3 - 2);

4 << 3 - 2	(4 << 3) - 2	4 << (3 - 2)

8	30	8

Testing that binary - has precedence over >>

select 16 - 3 >> 2, (16 - 3) >> 2, 16 - (3 >> 2);

16 - 3 >> 2	(16 - 3) >> 2	16 - (3 >> 2)

3	3	16

select 16 >> 3 - 2, (16 >> 3) - 2, 16 >> (3 - 2);

16 >> 3 - 2	(16 >> 3) - 2	16 >> (3 - 2)

8	0	8

Testing that * is associative

select 2 * 3 * 4, (2 * 3) * 4, 2 * (3 * 4);

2 * 3 * 4	(2 * 3) * 4	2 * (3 * 4)

24	24	24

Testing that * has precedence over |

select 2 * 0x40 | 0x0F, (2 * 0x40) | 0x0F, 2 * (0x40 | 0x0F);

2 * 0x40 | 0x0F	(2 * 0x40) | 0x0F	2 * (0x40 | 0x0F)

143	143	158

select 0x0F | 2 * 0x40, (0x0F | 2) * 0x40, 0x0F | (2 * 0x40);

0x0F | 2 * 0x40	(0x0F | 2) * 0x40	0x0F | (2 * 0x40)

143	960	143

Testing that * has precedence over &

select 2 * 0x40 & 0x55, (2 * 0x40) & 0x55, 2 * (0x40 & 0x55);

2 * 0x40 & 0x55	(2 * 0x40) & 0x55	2 * (0x40 & 0x55)

0	0	128

select 0xF0 & 2 * 0x40, (0xF0 & 2) * 0x40, 0xF0 & (2 * 0x40);

0xF0 & 2 * 0x40	(0xF0 & 2) * 0x40	0xF0 & (2 * 0x40)

128	0	128

Testing that * has precedence over << 

select 5 * 3 << 4, (5 * 3) << 4, 5 * (3 << 4);

5 * 3 << 4	(5 * 3) << 4	5 * (3 << 4)

240	240	240

select 2 << 3 * 4, (2 << 3) * 4, 2 << (3 * 4);

2 << 3 * 4	(2 << 3) * 4	2 << (3 * 4)

8192	64	8192

Testing that * has precedence over >>

select 3 * 4 >> 2, (3 * 4) >> 2, 3 * (4 >> 2);

3 * 4 >> 2	(3 * 4) >> 2	3 * (4 >> 2)

3	3	3

select 4 >> 2 * 3, (4 >> 2) * 3, 4 >> (2 * 3);

4 >> 2 * 3	(4 >> 2) * 3	4 >> (2 * 3)

0	3	0

Testing that * has precedence over binary +

select 2 * 3 + 4, (2 * 3) + 4, 2 * (3 + 4);

2 * 3 + 4	(2 * 3) + 4	2 * (3 + 4)

10	10	14

select 2 + 3 * 4, (2 + 3) * 4, 2 + (3 * 4);

2 + 3 * 4	(2 + 3) * 4	2 + (3 * 4)

14	20	14

Testing that * has precedence over binary -

select 4 * 3 - 2, (4 * 3) - 2, 4 * (3 - 2);

4 * 3 - 2	(4 * 3) - 2	4 * (3 - 2)

10	10	4

select 4 - 3 * 2, (4 - 3) * 2, 4 - (3 * 2);

4 - 3 * 2	(4 - 3) * 2	4 - (3 * 2)

-2	2	-2

Testing that / is left associative

select 15 / 5 / 3, (15 / 5) / 3, 15 / (5 / 3);

15 / 5 / 3	(15 / 5) / 3	15 / (5 / 3)

1.00000000	1.00000000	9.0000

Testing that / has precedence over |

select 105 / 5 | 2, (105 / 5) | 2, 105 / (5 | 2);

105 / 5 | 2	(105 / 5) | 2	105 / (5 | 2)

23	23	15.0000

select 105 | 2 / 5, (105 | 2) / 5, 105 | (2 / 5);

105 | 2 / 5	(105 | 2) / 5	105 | (2 / 5)

105	21.4000	105

Testing that / has precedence over &

select 105 / 5 & 0x0F, (105 / 5) & 0x0F, 105 / (5 & 0x0F);

105 / 5 & 0x0F	(105 / 5) & 0x0F	105 / (5 & 0x0F)

5	5	21.0000

select 0x0F & 105 / 5, (0x0F & 105) / 5, 0x0F & (105 / 5);

0x0F & 105 / 5	(0x0F & 105) / 5	0x0F & (105 / 5)

5	1.8000	5

Testing that / has precedence over << 

select 0x80 / 4 << 2, (0x80 / 4) << 2, 0x80 / (4 << 2);

0x80 / 4 << 2	(0x80 / 4) << 2	0x80 / (4 << 2)

128	128	8.0000

select 0x80 << 4 / 2, (0x80 << 4) / 2, 0x80 << (4 / 2);

0x80 << 4 / 2	(0x80 << 4) / 2	0x80 << (4 / 2)

512	1024.0000	512

Testing that / has precedence over >>

select 0x80 / 4 >> 2, (0x80 / 4) >> 2, 0x80 / (4 >> 2);

0x80 / 4 >> 2	(0x80 / 4) >> 2	0x80 / (4 >> 2)

8	8	128.0000

select 0x80 >> 4 / 2, (0x80 >> 4) / 2, 0x80 >> (4 / 2);

0x80 >> 4 / 2	(0x80 >> 4) / 2	0x80 >> (4 / 2)

32	4.0000	32

Testing that / has precedence over binary +

select 0x80 / 2 + 2, (0x80 / 2) + 2, 0x80 / (2 + 2);

0x80 / 2 + 2	(0x80 / 2) + 2	0x80 / (2 + 2)

66.0000	66.0000	32.0000

select 0x80 + 2 / 2, (0x80 + 2) / 2, 0x80 + (2 / 2);

0x80 + 2 / 2	(0x80 + 2) / 2	0x80 + (2 / 2)

129.0000	65.0000	129.0000

Testing that / has precedence over binary -

select 0x80 / 4 - 2, (0x80 / 4) - 2, 0x80 / (4 - 2);

0x80 / 4 - 2	(0x80 / 4) - 2	0x80 / (4 - 2)

30.0000	30.0000	64.0000

select 0x80 - 4 / 2, (0x80 - 4) / 2, 0x80 - (4 / 2);

0x80 - 4 / 2	(0x80 - 4) / 2	0x80 - (4 / 2)

126.0000	62.0000	126.0000

Testing that ^ is associative

select 0xFF ^ 0xF0 ^ 0x0F, (0xFF ^ 0xF0) ^ 0x0F, 0xFF ^ (0xF0 ^ 0x0F);

0xFF ^ 0xF0 ^ 0x0F	(0xFF ^ 0xF0) ^ 0x0F	0xFF ^ (0xF0 ^ 0x0F)

0	0	0

select 0xFF ^ 0xF0 ^ 0x55, (0xFF ^ 0xF0) ^ 0x55, 0xFF ^ (0xF0 ^ 0x55);

0xFF ^ 0xF0 ^ 0x55	(0xFF ^ 0xF0) ^ 0x55	0xFF ^ (0xF0 ^ 0x55)

90	90	90

Testing that ^ has precedence over |

select 0xFF ^ 0xF0 | 0x0F, (0xFF ^ 0xF0) | 0x0F, 0xFF ^ (0xF0 | 0x0F);

0xFF ^ 0xF0 | 0x0F	(0xFF ^ 0xF0) | 0x0F	0xFF ^ (0xF0 | 0x0F)

15	15	0

select 0xF0 | 0xFF ^ 0xF0, (0xF0 | 0xFF) ^ 0xF0, 0xF0 | (0xFF ^ 0xF0);

0xF0 | 0xFF ^ 0xF0	(0xF0 | 0xFF) ^ 0xF0	0xF0 | (0xFF ^ 0xF0)

255	15	255

Testing that ^ has precedence over &

select 0xFF ^ 0xF0 & 0x0F, (0xFF ^ 0xF0) & 0x0F, 0xFF ^ (0xF0 & 0x0F);

0xFF ^ 0xF0 & 0x0F	(0xFF ^ 0xF0) & 0x0F	0xFF ^ (0xF0 & 0x0F)

15	15	255

select 0x0F & 0xFF ^ 0xF0, (0x0F & 0xFF) ^ 0xF0, 0x0F & (0xFF ^ 0xF0);

0x0F & 0xFF ^ 0xF0	(0x0F & 0xFF) ^ 0xF0	0x0F & (0xFF ^ 0xF0)

15	255	15

Testing that ^ has precedence over <<

select 0xFF ^ 0xF0 << 2, (0xFF ^ 0xF0) << 2, 0xFF ^ (0xF0 << 2);

0xFF ^ 0xF0 << 2	(0xFF ^ 0xF0) << 2	0xFF ^ (0xF0 << 2)

60	60	831

select 0x0F << 2 ^ 0xFF, (0x0F << 2) ^ 0xFF, 0x0F << (2 ^ 0xFF);

0x0F << 2 ^ 0xFF	(0x0F << 2) ^ 0xFF	0x0F << (2 ^ 0xFF)

0	195	0

Testing that ^ has precedence over >>

select 0xFF ^ 0xF0 >> 2, (0xFF ^ 0xF0) >> 2, 0xFF ^ (0xF0 >> 2);

0xFF ^ 0xF0 >> 2	(0xFF ^ 0xF0) >> 2	0xFF ^ (0xF0 >> 2)

3	3	195

select 0xFF >> 2 ^ 0xF0, (0xFF >> 2) ^ 0xF0, 0xFF >> (2 ^ 0xF0);

0xFF >> 2 ^ 0xF0	(0xFF >> 2) ^ 0xF0	0xFF >> (2 ^ 0xF0)

0	207	0

Testing that ^ has precedence over binary +

select 0xFF ^ 0xF0 + 0x0F, (0xFF ^ 0xF0) + 0x0F, 0xFF ^ (0xF0 + 0x0F);

0xFF ^ 0xF0 + 0x0F	(0xFF ^ 0xF0) + 0x0F	0xFF ^ (0xF0 + 0x0F)

30	30	0

select 0x0F + 0xFF ^ 0xF0, (0x0F + 0xFF) ^ 0xF0, 0x0F + (0xFF ^ 0xF0);

0x0F + 0xFF ^ 0xF0	(0x0F + 0xFF) ^ 0xF0	0x0F + (0xFF ^ 0xF0)

30	510	30

Testing that ^ has precedence over binary -

select 0xFF ^ 0xF0 - 1, (0xFF ^ 0xF0) - 1, 0xFF ^ (0xF0 - 1);

0xFF ^ 0xF0 - 1	(0xFF ^ 0xF0) - 1	0xFF ^ (0xF0 - 1)

14	14	16

select 0x55 - 0x0F ^ 0x55, (0x55 - 0x0F) ^ 0x55, 0x55 - (0x0F ^ 0x55);

0x55 - 0x0F ^ 0x55	(0x55 - 0x0F) ^ 0x55	0x55 - (0x0F ^ 0x55)

-5	19	-5

Testing that ^ has precedence over *

select 0xFF ^ 0xF0 * 2, (0xFF ^ 0xF0) * 2, 0xFF ^ (0xF0 * 2);

0xFF ^ 0xF0 * 2	(0xFF ^ 0xF0) * 2	0xFF ^ (0xF0 * 2)

30	30	287

select 2 * 0xFF ^ 0xF0, (2 * 0xFF) ^ 0xF0, 2 * (0xFF ^ 0xF0);

2 * 0xFF ^ 0xF0	(2 * 0xFF) ^ 0xF0	2 * (0xFF ^ 0xF0)

30	270	30

Testing that ^ has precedence over /

select 0xFF ^ 0xF0 / 2, (0xFF ^ 0xF0) / 2, 0xFF ^ (0xF0 / 2);

0xFF ^ 0xF0 / 2	(0xFF ^ 0xF0) / 2	0xFF ^ (0xF0 / 2)

7.5000	7.5000	135

select 0xF2 / 2 ^ 0xF0, (0xF2 / 2) ^ 0xF0, 0xF2 / (2 ^ 0xF0);

0xF2 / 2 ^ 0xF0	(0xF2 / 2) ^ 0xF0	0xF2 / (2 ^ 0xF0)

1.0000	137	1.0000

Testing that ^ has precedence over %

select 0xFF ^ 0xF0 % 0x20, (0xFF ^ 0xF0) % 0x20, 0xFF ^ (0xF0 % 0x20);

0xFF ^ 0xF0 % 0x20	(0xFF ^ 0xF0) % 0x20	0xFF ^ (0xF0 % 0x20)

15	15	239

select 0xFF % 0x20 ^ 0xF0, (0xFF % 0x20) ^ 0xF0, 0xFF % (0x20 ^ 0xF0);

0xFF % 0x20 ^ 0xF0	(0xFF % 0x20) ^ 0xF0	0xFF % (0x20 ^ 0xF0)

47	239	47

Testing that ^ has precedence over DIV

select 0xFF ^ 0xF0 DIV 2, (0xFF ^ 0xF0) DIV 2, 0xFF ^ (0xF0 DIV 2);

0xFF ^ 0xF0 DIV 2	(0xFF ^ 0xF0) DIV 2	0xFF ^ (0xF0 DIV 2)

7	7	135

select 0xF2 DIV 2 ^ 0xF0, (0xF2 DIV 2) ^ 0xF0, 0xF2 DIV (2 ^ 0xF0);

0xF2 DIV 2 ^ 0xF0	(0xF2 DIV 2) ^ 0xF0	0xF2 DIV (2 ^ 0xF0)

1	137	1

Testing that ^ has precedence over MOD

select 0xFF ^ 0xF0 MOD 0x20, (0xFF ^ 0xF0) MOD 0x20, 0xFF ^ (0xF0 MOD 0x20);

0xFF ^ 0xF0 MOD 0x20	(0xFF ^ 0xF0) MOD 0x20	0xFF ^ (0xF0 MOD 0x20)

15	15	239

select 0xFF MOD 0x20 ^ 0xF0, (0xFF MOD 0x20) ^ 0xF0, 0xFF MOD (0x20 ^ 0xF0);

0xFF MOD 0x20 ^ 0xF0	(0xFF MOD 0x20) ^ 0xF0	0xFF MOD (0x20 ^ 0xF0)

47	239	47

mysql-test/t/parser_precedence.test

+240 −0

File changed.

Preview size limit exceeded, changes collapsed.

sql/sql_yacc.yy

+55 −60
Original line number Diff line number Diff line
@@ -1068,9 +1068,9 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize); 
%type <item>

	literal text_literal insert_ident order_ident

	simple_ident select_item2 expr opt_expr opt_else sum_expr in_sum_expr

	variable variable_aux bool_factor

        bool_test bool_pri

	predicate bit_expr bit_term bit_factor value_expr term factor

	variable variable_aux

        bool_pri

	predicate bit_expr

	table_wild simple_expr udf_expr

	expr_or_default set_expr_or_default interval_expr

	param_marker geometry_function
@@ -4468,8 +4468,7 @@ optional_braces: 


/* all possible expressions */

expr:

          bool_factor

        | expr or expr %prec OR_SYM

          expr or expr %prec OR_SYM

          {

            /*

              Design notes:
@@ -4564,30 +4563,30 @@ expr: 
              $$ = new (YYTHD->mem_root) Item_cond_and($1, $3);

            }

          }

        ;



bool_factor:

	NOT_SYM bool_factor	{ $$= negate_expression(YYTHD, $2); }

	| bool_test ;



bool_test:

          bool_pri IS TRUE_SYM

	| NOT_SYM expr %prec NOT_SYM

          { $$= negate_expression(YYTHD, $2); }

        | bool_pri IS TRUE_SYM %prec IS

          { $$= new (YYTHD->mem_root) Item_func_istrue($1); }

        | bool_pri IS not TRUE_SYM

        | bool_pri IS not TRUE_SYM %prec IS

          { $$= new (YYTHD->mem_root) Item_func_isnottrue($1); }

        | bool_pri IS FALSE_SYM

        | bool_pri IS FALSE_SYM %prec IS

          { $$= new (YYTHD->mem_root) Item_func_isfalse($1); }

        | bool_pri IS not FALSE_SYM

        | bool_pri IS not FALSE_SYM %prec IS

          { $$= new (YYTHD->mem_root) Item_func_isnotfalse($1); }

        | bool_pri IS UNKNOWN_SYM { $$= new Item_func_isnull($1); }

        | bool_pri IS not UNKNOWN_SYM { $$= new Item_func_isnotnull($1); }

        | bool_pri IS UNKNOWN_SYM %prec IS

          { $$= new Item_func_isnull($1); }

        | bool_pri IS not UNKNOWN_SYM %prec IS

          { $$= new Item_func_isnotnull($1); }

        | bool_pri

        ;



bool_pri:

	bool_pri IS NULL_SYM	{ $$= new Item_func_isnull($1); }

	| bool_pri IS not NULL_SYM { $$= new Item_func_isnotnull($1); }

	| bool_pri EQUAL_SYM predicate	{ $$= new Item_func_equal($1,$3); }

	bool_pri IS NULL_SYM %prec IS

          { $$= new Item_func_isnull($1); }

	| bool_pri IS not NULL_SYM %prec IS

          { $$= new Item_func_isnotnull($1); }

	| bool_pri EQUAL_SYM predicate %prec EQUAL_SYM

          { $$= new Item_func_equal($1,$3); }

	| bool_pri comp_op predicate %prec EQ

	  { $$= (*$2)(0)->create($1,$3); }

	| bool_pri comp_op all_or_any '(' subselect ')' %prec EQ
@@ -4648,40 +4647,36 @@ predicate: 
	| bit_expr ;



bit_expr:

	bit_expr '|' bit_term	{ $$= new Item_func_bit_or($1,$3); }

	| bit_term ;



bit_term:

	bit_term '&' bit_factor	{ $$= new Item_func_bit_and($1,$3); }

	| bit_factor ;



bit_factor:

	bit_factor SHIFT_LEFT value_expr

          bit_expr '|' bit_expr %prec '|'

          { $$= new Item_func_bit_or($1,$3); }

        | bit_expr '&' bit_expr %prec '&'

          { $$= new Item_func_bit_and($1,$3); }

        | bit_expr SHIFT_LEFT bit_expr %prec SHIFT_LEFT

          { $$= new Item_func_shift_left($1,$3); }

	| bit_factor SHIFT_RIGHT value_expr 

        | bit_expr SHIFT_RIGHT bit_expr %prec SHIFT_RIGHT

          { $$= new Item_func_shift_right($1,$3); }

	| value_expr ;



value_expr:

	value_expr '+' term	{ $$= new Item_func_plus($1,$3); }

	| value_expr '-' term	{ $$= new Item_func_minus($1,$3); }

	| value_expr '+' interval_expr interval

        | bit_expr '+' bit_expr %prec '+'

          { $$= new Item_func_plus($1,$3); }

        | bit_expr '-' bit_expr %prec '-'

          { $$= new Item_func_minus($1,$3); }

        | bit_expr '+' interval_expr interval %prec '+'

          { $$= new Item_date_add_interval($1,$3,$4,0); }

	| value_expr '-' interval_expr interval

        | bit_expr '-' interval_expr interval %prec '-'

          { $$= new Item_date_add_interval($1,$3,$4,1); }

	| term ;



term:

	term '*' factor		{ $$= new Item_func_mul($1,$3); }

	| term '/' factor	{ $$= new Item_func_div($1,$3); }

	| term '%' factor	{ $$= new Item_func_mod($1,$3); }

	| term DIV_SYM factor	{ $$= new Item_func_int_div($1,$3); }

	| term MOD_SYM factor	{ $$= new Item_func_mod($1,$3); }

	| factor ;



factor:

        factor '^' simple_expr	{ $$= new Item_func_bit_xor($1,$3); }

	| simple_expr ;

        | bit_expr '*' bit_expr %prec '*'

          { $$= new Item_func_mul($1,$3); }

        | bit_expr '/' bit_expr %prec '/'

          { $$= new Item_func_div($1,$3); }

        | bit_expr '%' bit_expr %prec '%'

          { $$= new Item_func_mod($1,$3); }

        | bit_expr DIV_SYM bit_expr %prec DIV_SYM

          { $$= new Item_func_int_div($1,$3); }

        | bit_expr MOD_SYM bit_expr %prec MOD_SYM

          { $$= new Item_func_mod($1,$3); }

        | bit_expr '^' bit_expr

          { $$= new Item_func_bit_xor($1,$3); }

        | simple_expr

        ;



or:	OR_SYM | OR2_SYM;

and:	AND_SYM | AND_AND_SYM;