~drizzle-trunk/drizzle/development

--disable_warnings

drop table if exists t1_30237_bool;

--enable_warnings

create table t1_30237_bool(A char, B char, C char);

insert into t1_30237_bool values

(FALSE, FALSE, FALSE),

(FALSE, FALSE, NULL),

(FALSE, FALSE, TRUE),

(FALSE, NULL, FALSE),

(FALSE, NULL, NULL),

(FALSE, NULL, TRUE),

(FALSE, TRUE, FALSE),

(FALSE, TRUE, NULL),

(FALSE, TRUE, TRUE),

(NULL, FALSE, FALSE),

(NULL, FALSE, NULL),

(NULL, FALSE, TRUE),

(NULL, NULL, FALSE),

(NULL, NULL, NULL),

(NULL, NULL, TRUE),

(NULL, TRUE, FALSE),

(NULL, TRUE, NULL),

(NULL, TRUE, TRUE),

(TRUE, FALSE, FALSE),

(TRUE, FALSE, NULL),

(TRUE, FALSE, TRUE),

(TRUE, NULL, FALSE),

(TRUE, NULL, NULL),

(TRUE, NULL, TRUE),

(TRUE, TRUE, FALSE),

(TRUE, TRUE, NULL),

(TRUE, TRUE, TRUE) ;

--echo Testing OR, XOR, AND

select A, B, A OR B, A XOR B, A AND B

  from t1_30237_bool where C is null order by A, B;

--echo Testing that OR is associative 

select A, B, C, (A OR B) OR C, A OR (B OR C), A OR B OR C

 from t1_30237_bool order by A, B, C;

select count(*) from t1_30237_bool

  where ((A OR B) OR C) != (A OR (B OR C));

--echo Testing that XOR is associative 

select A, B, C, (A XOR B) XOR C, A XOR (B XOR C), A XOR B XOR C

  from t1_30237_bool order by A, B, C;

select count(*) from t1_30237_bool

  where ((A XOR B) XOR C) != (A XOR (B XOR C));

--echo Testing that AND is associative 

select A, B, C, (A AND B) AND C, A AND (B AND C), A AND B AND C

  from t1_30237_bool order by A, B, C;

select count(*) from t1_30237_bool

  where ((A AND B) AND C) != (A AND (B AND C));

--echo Testing that AND has precedence over OR

select A, B, C, (A OR B) AND C, A OR (B AND C), A OR B AND C

  from t1_30237_bool order by A, B, C;

select count(*) from t1_30237_bool

  where (A OR (B AND C)) != (A OR B AND C);

select A, B, C, (A AND B) OR C, A AND (B OR C), A AND B OR C

  from t1_30237_bool order by A, B, C;

select count(*) from t1_30237_bool

  where ((A AND B) OR C) != (A AND B OR C);

--echo Testing that AND has precedence over XOR

select A, B, C, (A XOR B) AND C, A XOR (B AND C), A XOR B AND C

  from t1_30237_bool order by A, B, C;

select count(*) from t1_30237_bool

  where (A XOR (B AND C)) != (A XOR B AND C);

select A, B, C, (A AND B) XOR C, A AND (B XOR C), A AND B XOR C

  from t1_30237_bool order by A, B, C;

select count(*) from t1_30237_bool

  where ((A AND B) XOR C) != (A AND B XOR C);

--echo Testing that XOR has precedence over OR

select A, B, C, (A XOR B) OR C, A XOR (B OR C), A XOR B OR C

  from t1_30237_bool order by A, B, C;

select count(*) from t1_30237_bool

  where ((A XOR B) OR C) != (A XOR B OR C);

select A, B, C, (A OR B) XOR C, A OR (B XOR C), A OR B XOR C

  from t1_30237_bool order by A, B, C;

select count(*) from t1_30237_bool

  where (A OR (B XOR C)) != (A OR B XOR C);

drop table t1_30237_bool;

--echo Testing that NOT has precedence over OR

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

--echo Testing that NOT has precedence over XOR

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

--echo Testing that NOT has precedence over AND

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

--echo Testing that NOT is associative

select NOT NOT TRUE, NOT NOT NOT FALSE;

--echo Testing that IS has precedence over NOT

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

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

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

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

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

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

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

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

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

# Documenting existing behavior in 5.0.48

-- error ER_PARSE_ERROR

select TRUE IS TRUE IS TRUE IS TRUE;

-- error ER_PARSE_ERROR

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

-- error ER_PARSE_ERROR

select NULL IS FALSE IS FALSE IS FALSE;

-- error ER_PARSE_ERROR

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

-- error ER_PARSE_ERROR

select FALSE IS UNKNOWN IS UNKNOWN IS UNKNOWN;

-- error ER_PARSE_ERROR

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

--echo Testing that IS [NOT] NULL predicates are associative

# Documenting existing behavior in 5.0.48

select FALSE IS NULL IS NULL IS NULL;

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

--echo Testing that comparison operators are left associative

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

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

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

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

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

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

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

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

--echo Testing that binary + is associative

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

--echo Testing that binary - is left associative

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

--echo Testing that binary + and binary - have the same precedence

# evaluated left to right

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

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

--echo Testing that * is associative

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

--echo Testing that * has precedence over binary +

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

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

--echo Testing that * has precedence over binary -

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

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

--echo Testing that / is left associative

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

--echo Testing that / has precedence over binary +

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

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

--echo Testing that / has precedence over binary -

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

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