statement ok
CREATE TABLE f (x FLOAT)

statement ok
INSERT INTO f(x) VALUES (3/2), (1)

query R rowsort
SELECT * FROM f
----
1.5
1

statement ok
CREATE TABLE i (x INT)

statement error value type timestamptz doesn't match type int of column "x"
INSERT INTO i(x) VALUES ('1970-01-01'::timestamptz)

statement ok
INSERT INTO i(x) VALUES (2.0)

statement error numeric constant out of int64 range
INSERT INTO i(x) VALUES (9223372036854775809)

query I rowsort
SELECT * FROM i
----
2

statement ok
CREATE TABLE d (x DECIMAL)

statement ok
INSERT INTO d(x) VALUES (((9 / 3) * (1 / 3))), (2.0), (2.4 + 4.6)

query R rowsort
SELECT * FROM d
----
0.999999999999999999990000000000000000000
2.0
7.0

statement ok
UPDATE d SET x = x + 1 WHERE x + sqrt(x) >= 2 + .1

query R rowsort
SELECT * FROM d
----
0.999999999999999999990000000000000000000
3.0
8.0

statement ok
CREATE TABLE s (x STRING)

query T
SELECT * FROM s WHERE x > b'\x00'
----

statement ok
INSERT INTO s(x) VALUES (b'qwe'), ('start' || b'end')

statement ok
INSERT INTO s(x) VALUES (b'\xfffefd')

query IT rowsort
SELECT length(x), encode(x::bytes, 'escape') from s
----
3 qwe
8 startend
5 \377fefd

statement error incompatible COALESCE expressions: could not parse "foo" as type int
INSERT INTO s VALUES (COALESCE(1, 'foo'))

statement error incompatible COALESCE expressions: could not parse "foo" as type int
INSERT INTO i VALUES (COALESCE(1, 'foo'))

query error incompatible COALESCE expressions: could not parse "foo" as type int
SELECT COALESCE(1, 'foo')

query error incompatible COALESCE expressions: could not parse "foo" as type int
SELECT COALESCE(1::INT, 'foo')

query error expected 2.3 to be of type int, found type decimal
SELECT greatest(-1, 1, 2.3, 123456789, 3 + 5, -(-4))

query I
SELECT greatest(-1, 1, 2, 123456789, 3 + 5, -(-4))
----
123456789

query T
SELECT greatest('2010-09-29', '2010-09-28'::TIMESTAMP)
----
2010-09-29 00:00:00 +0000 +0000

query T
SELECT greatest('PT12H2M', 'PT12H2M'::INTERVAL, '1s')
----
12:02:00

query R
SELECT greatest(-1.123, 1.21313, 2.3, 123456789.321, 3 + 5.3213, -(-4.3213), abs(-9))
----
123456789.321

statement ok
CREATE TABLE untyped (b bool, n INT, f FLOAT, e DECIMAL, d DATE, ts TIMESTAMP, tz TIMESTAMPTZ, i INTERVAL)

statement ok
INSERT INTO untyped VALUES ('f', '42', '4.2', '4.20', '2010-09-28', '2010-09-28 12:00:00.1', '2010-09-29 12:00:00.1', 'PT12H2M')

query BIRRTTTT
SELECT * FROM untyped
----
false  42  4.2  4.20  2010-09-28 00:00:00 +0000 +0000  2010-09-28 12:00:00.1 +0000 +0000  2010-09-29 12:00:00.1 +0000 UTC  12:02:00

# Issue #14527: support string literal coercion during overload resolution
query T
SELECT ts FROM untyped WHERE ts != '2015-09-18 00:00:00'
----
2010-09-28 12:00:00.1 +0000 +0000

# Test qualified type references.
query IITR
SELECT 1::pg_catalog.int4, 1::pg_catalog.int8, 'aa'::pg_catalog.text, 4.2::pg_catalog.float4
----
1 1 aa 4.2

# Test fixed-length types.

query TTT
SELECT VARCHAR(4) 'foo', CHAR(2) 'bar', STRING(1) 'cat'
----
foo  ba  c

# Test that we error out referencing unknown types in pg_catalog.
query error pq: type "pg_catalog.special_int" does not exist
SELECT 1::pg_catalog.special_int

# Test that we error out trying to reference types in schemas that
# don't have types.
query error pq: type "crdb_internal.mytype" does not exist
SELECT 1::crdb_internal.mytype

# Untyped string literals in binary operators assume the type of the other
# argument, if an overload exists with exactly matching parameter types. The
# values are adjusted as necessary, e.g., trailing spaces are trimmed from
# string literals when they assume the BPCHAR type.
query B
SELECT 'foo'::BPCHAR = 'foo   '
----
true

query B
SELECT 'foo'::BPCHAR != 'foo   '
----
false

query B
SELECT 'foo'::BPCHAR >= 'foo   '
----
true

query B
SELECT 'foo'::BPCHAR <= 'foo   '
----
true

query B
SELECT 'foo'::BPCHAR > 'foo   '
----
false

query B
SELECT 'foo'::BPCHAR < 'foo   '
----
false

query B
SELECT 'foo'::BPCHAR IN ('foo   ')
----
true

query B
SELECT 'foo'::BPCHAR IN ('foo   ', 'bar')
----
true

# There is no LIKE overload for BPCHAR, so the string literal does not assume
# the other argument's type.
query B
SELECT 'foo'::BPCHAR LIKE 'foo   '
----
false

# There is no ~ overload for BPCHAR, so the string literal does not assume
# that type.
query B
SELECT 'foo'::BPCHAR ~ 'foo   '
----
false

statement ok
PREPARE p AS SELECT 'foo'::BPCHAR = $1

query B
EXECUTE p('foo   ')
----
true

statement ok
DEALLOCATE p;
PREPARE p AS SELECT 'foo'::BPCHAR = $1

query B
EXECUTE p('foo   ')
----
true

query B
SELECT 'foo'::CHAR = 'f  '
----
true

# The LHS is typed as CHAR(1) and truncated and the RHS is typed as BPCHAR and
# not truncated, so they do not match.
query B
SELECT 'foo'::CHAR = 'foo'
----
false

query B
SELECT 'foo'::CHAR = 'foo  '
----
false

statement ok
CREATE TABLE chars (
  bp BPCHAR,
  c CHAR(20)
)

statement ok
INSERT INTO chars VALUES ('foo   ', 'bar    ');

query TI
SELECT bp, length(bp) FROM chars WHERE bp = 'foo   '
----
foo  3

statement ok
DEALLOCATE p;
PREPARE p AS SELECT bp, length(bp) FROM chars WHERE bp = $1

query TI
EXECUTE p('foo   ')
----
foo  3

query TI
SELECT c, length(c) FROM chars WHERE c = 'bar   '
----
bar                   3

statement ok
DEALLOCATE p;
PREPARE p AS SELECT c, length(c) FROM chars WHERE c = $1

query TI
EXECUTE p('bar   ')
----
bar                   3

query B
SELECT ROW('foo'::BPCHAR) = ROW('foo   ')
----
true

query B
SELECT bp = c FROM
  (VALUES ('foo'::BPCHAR)) v1(bp),
  (VALUES ('foo  ')) v2(c)
----
false

# Regression tests for #15050

statement error pq: parsing as type timestamp: could not parse "Not Timestamp"
CREATE TABLE t15050a (c DECIMAL DEFAULT CASE WHEN now() < 'Not Timestamp' THEN 2 ELSE 2 END);

statement error pq: parsing as type timestamp: could not parse "Not Timestamp"
CREATE TABLE t15050b (c DECIMAL DEFAULT IF(now() < 'Not Timestamp', 2, 2));

# Regression tests for #15632

statement error incompatible IFNULL expressions: could not parse "foo" as type bool
SELECT IFNULL('foo', false)

statement error incompatible IFNULL expressions: could not parse "foo" as type bool
SELECT IFNULL(true, 'foo')

query B
SELECT IFNULL(false, 'true')
----
false

query B
SELECT IFNULL('true', false)
----
true

# Regression tests for #19770

query B
SELECT 1 in (SELECT 1)
----
true

statement error could not parse "a" as type int
SELECT 1 IN (SELECT 'a')

statement error unsupported comparison operator: <int> IN <tuple{tuple{int, int}}>
SELECT 1 IN (SELECT (1, 2))

query B
SELECT (1, 2) IN (SELECT 1, 2)
----
true

query B
SELECT (1, 2) IN (SELECT (1, 2))
----
true

statement ok
CREATE TABLE t1 (a DATE)

statement ok
CREATE TABLE t2 (b TIMESTAMPTZ)

statement ok
INSERT INTO t1 VALUES (DATE '2018-01-01'); INSERT INTO t2 VALUES (TIMESTAMPTZ '2018-01-01');

# Make sure that we do not create invalid filters due to substituting columns
# with different types.
query TT
SELECT * FROM t1, t2 WHERE a = b AND age(b, TIMESTAMPTZ '2017-01-01') > INTERVAL '1 day'
----
2018-01-01 00:00:00 +0000 +0000  2018-01-01 00:00:00 +0000 UTC

# Regression test for #44181: allow left side of BETWEEN to be typed
# differently in the two comparisons.
query B
SELECT '' BETWEEN ''::BYTES AND '';
----
true

# Regression test for #44632: NULLIF should have the type of the first argument.
query I
SELECT NULLIF(NULL, 0) + NULLIF(NULL, 0)
----
NULL

query I
SELECT NULLIF(0, 0) + NULLIF(0, 0)
----
NULL

query I
SELECT NULLIF(0, NULL) + NULLIF(0, NULL)
----
0

# Regression test for #46196.
query T
SELECT max(t0.c0) FROM (VALUES (NULL), (NULL)) t0(c0)
----
NULL

query T
SELECT max(NULL) FROM (VALUES (NULL), (NULL)) t0(c0)
----
NULL

# Regression test for #50978.
query T
SELECT CASE WHEN true THEN 1234:::OID ELSE COALESCE(NULL, NULL) END
----
1234

# Regression test for #51099.
query B rowsort
SELECT CASE WHEN x > 1 THEN true ELSE NULL AND true END FROM (VALUES (1), (2)) AS v(x)
----
NULL
true

query B rowsort
SELECT CASE WHEN x > 1 THEN true ELSE NULL OR false END FROM (VALUES (1), (2)) AS v(x)
----
NULL
true

query B
SELECT ARRAY[]::TIMESTAMPTZ[] >
       SOME (ARRAY[TIMESTAMPTZ '1969-12-29T21:20:13+01'], ARRAY[NULL])
----
false

query B
SELECT ARRAY[]::TIMESTAMPTZ[] <
       SOME (ARRAY[TIMESTAMPTZ '1969-12-29T21:20:13+01'], ARRAY[NULL])
----
true

# Regression test for #102110. Ensure CASE is typed correctly.
statement ok
CREATE TABLE t102110_1 (t TEXT);
INSERT INTO t102110_1 VALUES ('tt');

statement ok
CREATE TABLE t102110_2 (c CHAR);
INSERT INTO t102110_2 VALUES ('c');

query T
SELECT t102110_1.t FROM t102110_1, t102110_2
WHERE t102110_1.t NOT BETWEEN t102110_1.t AND
  (CASE WHEN NULL THEN t102110_2.c ELSE t102110_1.t END);
----

query T
SELECT t102110_1.t FROM t102110_1, t102110_2
WHERE t102110_1.t NOT BETWEEN t102110_1.t AND
  IF(NULL, t102110_2.c, t102110_1.t);
----

statement ok
CREATE TABLE t108360_1 (t TEXT);
INSERT INTO t108360_1 VALUES ('tt');

statement ok
CREATE TABLE t108360_2 (c CHAR);
INSERT INTO t108360_2 VALUES ('c');

query T
SELECT (CASE WHEN t108360_1.t > t108360_2.c THEN t108360_1.t ELSE t108360_2.c END)
FROM t108360_1, t108360_2
WHERE t108360_1.t = (CASE WHEN t108360_1.t > t108360_2.c THEN t108360_1.t ELSE t108360_2.c END);
----
tt

# Regression test for #131346. Ensure CASE is typed correctly and that a cast to
# the BIT type with an unspecified length behaves correctly during distributed
# execution.
statement ok
CREATE TABLE t131346v (v VARBIT);
INSERT INTO t131346v VALUES ('11');

statement ok
CREATE TABLE t131346b (b BIT);
INSERT INTO t131346b VALUES ('0');

query T
SELECT v FROM t131346v, t131346b
WHERE v NOT BETWEEN v AND
  (CASE WHEN NULL THEN '0'::BIT ELSE v END)
----

query T
SELECT v FROM t131346v, t131346b
WHERE v NOT BETWEEN v AND
  (CASE WHEN NULL THEN b ELSE v END)
----

query T
SELECT v FROM t131346v, t131346b
WHERE v NOT BETWEEN v AND
  IF(NULL, '0'::BIT, v);
----

query T
SELECT v FROM t131346v, t131346b
WHERE v NOT BETWEEN v AND
  IF(NULL, b, v);
----

query T
SELECT (CASE WHEN v > '0'::BIT THEN v ELSE '0'::BIT END)
FROM t131346v, t131346b
WHERE v = (CASE WHEN v > '0'::BIT THEN v ELSE '0'::BIT END)
----
11

query T
SELECT (CASE WHEN v > b THEN v ELSE b END)
FROM t131346v, t131346b
WHERE v = (CASE WHEN v > b THEN v ELSE b END)
----
11

query T
SELECT (CASE WHEN v > '0'::BIT THEN v ELSE '0'::BIT END)
FROM t131346v, t131346b
WHERE v = (CASE WHEN v < '0'::BIT THEN '0'::BIT ELSE v END)
----
11

query T
SELECT (CASE WHEN v > b THEN v ELSE b END)
FROM t131346v, t131346b
WHERE v = (CASE WHEN v < b THEN b ELSE v END)
----
11

# Static analysis types should never make it to execution.
statement ok
CREATE TABLE t83496 (
  a STRING,
  b STRING
);
CREATE TYPE typ83496 AS ENUM ('foo', 'bar');

statement ok
SELECT * FROM t83496
WHERE (
  (SELECT 'bar':::typ83496 FROM t83496 WHERE false)
  IS NOT DISTINCT FROM CASE WHEN NULL THEN NULL ELSE NULL END
);

# Issue #115054: ignore trailing whitespace in varchar
statement ok
CREATE TABLE t115054_1 (v varchar(2));

statement ok
INSERT INTO t115054_1 (v) VALUES ('c     ');

statement ok
INSERT INTO t115054_1 (v) VALUES (' c    ');

statement ok
INSERT INTO t115054_1 (v) VALUES ('cc    ');

statement error pq: value too long for type VARCHAR\(2\)
INSERT INTO t115054_1 (v) VALUES ('ccc   ');

query T nosort
SELECT json_agg(v ORDER BY v) FROM t115054_1
----
[" c", "c ", "cc"]

statement ok
CREATE TABLE t115054_2 (v varchar);

statement ok
INSERT INTO t115054_2 (v) VALUES ('c     ');

statement ok
INSERT INTO t115054_2 (v) VALUES (' c    ');

statement ok
INSERT INTO t115054_2 (v) VALUES ('cc    ');

statement ok
INSERT INTO t115054_2 (v) VALUES ('ccc   ');

query T nosort
SELECT json_agg(v ORDER BY v) FROM t115054_2
----
[" c    ", "c     ", "cc    ", "ccc   "]
