comp

exec-ddl
CREATE TABLE a (k INT PRIMARY KEY, i INT, f FLOAT, s STRING, j JSON, d DATE)
----

exec-ddl
CREATE TABLE geom_geog (
  geom GEOMETRY,
  geog GEOGRAPHY,
  val FLOAT
)
----

# --------------------------------------------------
# CommuteVarInequality
# --------------------------------------------------

# Put variables on both sides of comparison operator to avoid matching constant
# patterns.
norm expect=CommuteVarInequality
SELECT * FROM a WHERE 1+i<k AND k-1<=i AND i*i>k AND k/2>=i
----
select
 ├── columns: k:1!null i:2!null f:3 s:4 j:5 d:6
 ├── immutable
 ├── key: (1)
 ├── fd: (1)-->(2-6)
 ├── scan a
 │    ├── columns: k:1!null i:2 f:3 s:4 j:5 d:6
 │    ├── key: (1)
 │    └── fd: (1)-->(2-6)
 └── filters
      ├── k:1 > (i:2 + 1) [outer=(1,2), immutable, constraints=(/1: (/NULL - ])]
      ├── i:2 >= (k:1 - 1) [outer=(1,2), immutable, constraints=(/2: (/NULL - ])]
      ├── k:1 < (i:2 * i:2) [outer=(1,2), immutable, constraints=(/1: (/NULL - ])]
      └── i:2 <= (k:1 / 2) [outer=(1,2), constraints=(/2: (/NULL - ])]

# --------------------------------------------------
# CommuteConstInequality
# --------------------------------------------------
norm expect=CommuteConstInequality
SELECT * FROM a WHERE 5+1<i+k AND 5*5/3<=i*2 AND 5>i AND 'foo'>=s
----
select
 ├── columns: k:1!null i:2!null f:3 s:4!null j:5 d:6
 ├── immutable
 ├── key: (1)
 ├── fd: (1)-->(2-6)
 ├── scan a
 │    ├── columns: k:1!null i:2 f:3 s:4 j:5 d:6
 │    ├── key: (1)
 │    └── fd: (1)-->(2-6)
 └── filters
      ├── (i:2 + k:1) > 6 [outer=(1,2), immutable]
      ├── (i:2 * 2) >= 8.3333333333333333333 [outer=(2), immutable]
      ├── i:2 < 5 [outer=(2), constraints=(/2: (/NULL - /4]; tight)]
      └── s:4 <= 'foo' [outer=(4), constraints=(/4: (/NULL - /'foo']; tight)]

norm expect=CommuteConstInequality
SELECT * FROM a WHERE length('foo')+1<i+k AND length('bar')<=i*2
----
select
 ├── columns: k:1!null i:2 f:3 s:4 j:5 d:6
 ├── immutable
 ├── key: (1)
 ├── fd: (1)-->(2-6)
 ├── scan a
 │    ├── columns: k:1!null i:2 f:3 s:4 j:5 d:6
 │    ├── key: (1)
 │    └── fd: (1)-->(2-6)
 └── filters
      ├── (i:2 + k:1) > 4 [outer=(1,2), immutable]
      └── (i:2 * 2) >= 3 [outer=(2), immutable]

# Impure function should not be considered constant.
norm expect-not=CommuteConstInequality
SELECT * FROM a WHERE random()::int>a.i+a.i
----
select
 ├── columns: k:1!null i:2 f:3 s:4 j:5 d:6
 ├── volatile
 ├── key: (1)
 ├── fd: (1)-->(2-6)
 ├── scan a
 │    ├── columns: k:1!null i:2 f:3 s:4 j:5 d:6
 │    ├── key: (1)
 │    └── fd: (1)-->(2-6)
 └── filters
      └── random()::INT8 > (i:2 + i:2) [outer=(2), volatile]

# --------------------------------------------------
# NormalizeCmpPlusConst
# --------------------------------------------------
norm expect=NormalizeCmpPlusConst
SELECT *
FROM a
WHERE
    k+1 = 2 AND
    (f+f)+2 < 5 AND
    1::decimal+i >= length('foo') AND
    i+2+2 > 10 AND
    '1:00:00'::time + i::interval >= '2:00:00'::time
----
select
 ├── columns: k:1!null i:2!null f:3 s:4 j:5 d:6
 ├── cardinality: [0 - 1]
 ├── immutable
 ├── key: ()
 ├── fd: ()-->(1-6)
 ├── scan a
 │    ├── columns: k:1!null i:2 f:3 s:4 j:5 d:6
 │    ├── key: (1)
 │    └── fd: (1)-->(2-6)
 └── filters
      ├── (i:2 >= 2) AND (i:2 > 6) [outer=(2), constraints=(/2: [/7 - ]; tight)]
      ├── k:1 = 1 [outer=(1), constraints=(/1: [/1 - /1]; tight), fd=()-->(1)]
      ├── (f:3 + f:3) < 3.0 [outer=(3), immutable]
      └── i:2::INTERVAL >= '01:00:00' [outer=(2), immutable]

# Try case that should not match pattern because Minus overload is not defined.
norm expect-not=NormalizeCmpPlusConst
SELECT * FROM a WHERE s::date + '02:00:00'::time = '2000-01-01T02:00:00'::timestamp
----
select
 ├── columns: k:1!null i:2 f:3 s:4 j:5 d:6
 ├── stable
 ├── key: (1)
 ├── fd: (1)-->(2-6)
 ├── scan a
 │    ├── columns: k:1!null i:2 f:3 s:4 j:5 d:6
 │    ├── key: (1)
 │    └── fd: (1)-->(2-6)
 └── filters
      └── (s:4::DATE + '02:00:00') = '2000-01-01 02:00:00' [outer=(4), stable]

# --------------------------------------------------
# NormalizeCmpMinusConst
# --------------------------------------------------
norm expect=NormalizeCmpMinusConst
SELECT *
FROM a
WHERE
    k-1 = 2 AND
    (f+f)-2 < 5 AND
    i-1::decimal >= length('foo') AND
    i-2-2 < 10 AND
    f+i::float-10.0 >= 100.0 AND
    d-'1w'::interval >= '2018-09-23'::date
----
select
 ├── columns: k:1!null i:2!null f:3 s:4 j:5 d:6!null
 ├── cardinality: [0 - 1]
 ├── immutable
 ├── key: ()
 ├── fd: ()-->(1-6)
 ├── scan a
 │    ├── columns: k:1!null i:2 f:3 s:4 j:5 d:6
 │    ├── key: (1)
 │    └── fd: (1)-->(2-6)
 └── filters
      ├── (i:2 >= 4) AND (i:2 < 14) [outer=(2), constraints=(/2: [/4 - /13]; tight)]
      ├── k:1 = 3 [outer=(1), constraints=(/1: [/3 - /3]; tight), fd=()-->(1)]
      ├── (f:3 + f:3) < 7.0 [outer=(3), immutable]
      ├── (f:3 + i:2::FLOAT8) >= 110.0 [outer=(2,3), immutable]
      └── d:6 >= '2018-09-30' [outer=(6), constraints=(/6: [/'2018-09-30' - ]; tight)]

# Try case that should not match pattern because Plus overload is not defined.
norm expect-not=NormalizeCmpMinusConst
SELECT * FROM a WHERE s::json - 1 = '[1]'::json
----
select
 ├── columns: k:1!null i:2 f:3 s:4 j:5 d:6
 ├── immutable
 ├── key: (1)
 ├── fd: (1)-->(2-6)
 ├── scan a
 │    ├── columns: k:1!null i:2 f:3 s:4 j:5 d:6
 │    ├── key: (1)
 │    └── fd: (1)-->(2-6)
 └── filters
      └── (s:4::JSONB - 1) = '[1]' [outer=(4), immutable]

# --------------------------------------------------
# NormalizeCmpConstMinus
# --------------------------------------------------
norm expect=NormalizeCmpConstMinus
SELECT *
FROM a
WHERE
    1-k = 2 AND
    2-(f+f) < 5 AND
    1::decimal-i <= length('foo') AND
    2-(2-i) > 10 AND
    10.0-(f+i::float) >= 100.0
----
select
 ├── columns: k:1!null i:2!null f:3 s:4 j:5 d:6
 ├── cardinality: [0 - 1]
 ├── immutable
 ├── key: ()
 ├── fd: ()-->(1-6)
 ├── scan a
 │    ├── columns: k:1!null i:2 f:3 s:4 j:5 d:6
 │    ├── key: (1)
 │    └── fd: (1)-->(2-6)
 └── filters
      ├── (i:2 >= -2) AND (i:2 > 10) [outer=(2), constraints=(/2: [/11 - ]; tight)]
      ├── k:1 = -1 [outer=(1), constraints=(/1: [/-1 - /-1]; tight), fd=()-->(1)]
      ├── (f:3 + f:3) > -3.0 [outer=(3), immutable]
      └── (f:3 + i:2::FLOAT8) <= -90.0 [outer=(2,3), immutable]

# Try case that should not match pattern because Minus overload is not defined.
norm expect-not=NormalizeCmpConstMinus
SELECT * FROM a WHERE '[1, 2]'::json - i = '[1]'
----
select
 ├── columns: k:1!null i:2 f:3 s:4 j:5 d:6
 ├── immutable
 ├── key: (1)
 ├── fd: (1)-->(2-6)
 ├── scan a
 │    ├── columns: k:1!null i:2 f:3 s:4 j:5 d:6
 │    ├── key: (1)
 │    └── fd: (1)-->(2-6)
 └── filters
      └── ('[1, 2]' - i:2) = '[1]' [outer=(2), immutable]

# --------------------------------------------------
# NormalizeTupleEquality
# --------------------------------------------------
norm expect=NormalizeTupleEquality
SELECT * FROM a WHERE (i, f, s) = (1, 3.5, 'foo')
----
select
 ├── columns: k:1!null i:2!null f:3!null s:4!null j:5 d:6
 ├── key: (1)
 ├── fd: ()-->(2-4), (1)-->(5,6)
 ├── scan a
 │    ├── columns: k:1!null i:2 f:3 s:4 j:5 d:6
 │    ├── key: (1)
 │    └── fd: (1)-->(2-6)
 └── filters
      ├── i:2 = 1 [outer=(2), constraints=(/2: [/1 - /1]; tight), fd=()-->(2)]
      ├── f:3 = 3.5 [outer=(3), constraints=(/3: [/3.5 - /3.5]; tight), fd=()-->(3)]
      └── s:4 = 'foo' [outer=(4), constraints=(/4: [/'foo' - /'foo']; tight), fd=()-->(4)]

# Empty tuples.
norm expect=NormalizeTupleEquality
SELECT * FROM a WHERE () = ()
----
scan a
 ├── columns: k:1!null i:2 f:3 s:4 j:5 d:6
 ├── key: (1)
 └── fd: (1)-->(2-6)

# --------------------------------------------------
# NormalizeTupleEquality, NormalizeNestedAnds
# --------------------------------------------------

# Nested tuples.
norm expect=(NormalizeTupleEquality,NormalizeNestedAnds)
SELECT * FROM a WHERE (1, (2, 'foo')) = (k, (i, s))
----
select
 ├── columns: k:1!null i:2!null f:3 s:4!null j:5 d:6
 ├── cardinality: [0 - 1]
 ├── key: ()
 ├── fd: ()-->(1-6)
 ├── scan a
 │    ├── columns: k:1!null i:2 f:3 s:4 j:5 d:6
 │    ├── key: (1)
 │    └── fd: (1)-->(2-6)
 └── filters
      ├── k:1 = 1 [outer=(1), constraints=(/1: [/1 - /1]; tight), fd=()-->(1)]
      ├── i:2 = 2 [outer=(2), constraints=(/2: [/2 - /2]; tight), fd=()-->(2)]
      └── s:4 = 'foo' [outer=(4), constraints=(/4: [/'foo' - /'foo']; tight), fd=()-->(4)]

# --------------------------------------------------
# FoldNullComparisonLeft, FoldNullComparisonRight
# --------------------------------------------------

# Use null::type to circumvent type checker constant folding.
norm expect=(FoldNullComparisonLeft,FoldNullComparisonRight)
SELECT *
FROM a
WHERE
    null::int = 1 OR 1 = null::int OR
    null::int <> 1 OR 1 <> null::int OR
    null::int > 1 OR 1 > null::int OR
    null::int >= 1 OR 1 >= null::int OR
    null::int < 1 OR 1 < null::int OR
    null::int <= 1 OR 1 <= null::int OR
    null::string LIKE 'foo' OR 'foo' LIKE null::string OR
    null::string NOT LIKE 'foo' OR 'foo' NOT LIKE null::string OR
    null::string ILIKE 'foo' OR 'foo' ILIKE null::string OR
    null::string NOT ILIKE 'foo' OR 'foo' NOT ILIKE null::string OR
    null::string SIMILAR TO 'foo' OR 'foo' SIMILAR TO null::string OR
    null::string NOT SIMILAR TO 'foo' OR 'foo' NOT SIMILAR TO null::string OR
    null::string ~ 'foo' OR 'foo' ~ null::string OR
    null::string !~ 'foo' OR 'foo' !~ null::string OR
    null::string ~* 'foo' OR 'foo' ~* null::string OR
    null::string !~* 'foo' OR 'foo' !~* null::string OR
    null::string[] && ARRAY['foo'] OR ARRAY['foo'] && null::string[] OR
    null::jsonb @> '"foo"' OR '"foo"' <@ null::jsonb OR
    null::jsonb ? 'foo' OR '{}' ? null::string OR
    null::jsonb ?| ARRAY['foo'] OR '{}' ?| null::string[] OR
    null::jsonb ?& ARRAY['foo'] OR '{}' ?& null::string[]
----
values
 ├── columns: k:1!null i:2!null f:3!null s:4!null j:5!null d:6!null
 ├── cardinality: [0 - 0]
 ├── key: ()
 └── fd: ()-->(1-6)

# --------------------------------------------------
# FoldIsNull
# --------------------------------------------------
norm expect=FoldIsNull
SELECT NULL IS NULL AS r
----
values
 ├── columns: r:1!null
 ├── cardinality: [1 - 1]
 ├── key: ()
 ├── fd: ()-->(1)
 └── (true,)

# --------------------------------------------------
# FoldNonNullIsNull
# --------------------------------------------------
norm expect=FoldNonNullIsNull
SELECT 1 IS NULL AS r
----
values
 ├── columns: r:1!null
 ├── cardinality: [1 - 1]
 ├── key: ()
 ├── fd: ()-->(1)
 └── (false,)

norm expect=FoldNonNullIsNull
SELECT (1, 2, 3) IS NOT DISTINCT FROM NULL AS r
----
values
 ├── columns: r:1!null
 ├── cardinality: [1 - 1]
 ├── key: ()
 ├── fd: ()-->(1)
 └── (false,)

norm expect=FoldNonNullIsNull
SELECT (1, NULL) IS NOT DISTINCT FROM NULL AS r
----
values
 ├── columns: r:1!null
 ├── cardinality: [1 - 1]
 ├── key: ()
 ├── fd: ()-->(1)
 └── (false,)

norm expect=FoldNonNullIsNull
SELECT (NULL, NULL) IS NOT DISTINCT FROM NULL AS r
----
values
 ├── columns: r:1!null
 ├── cardinality: [1 - 1]
 ├── key: ()
 ├── fd: ()-->(1)
 └── (false,)

# --------------------------------------------------
# FoldNullTupleIsTupleNull
# --------------------------------------------------
norm expect=FoldNullTupleIsTupleNull
SELECT (NULL, NULL) IS NULL AS r
----
values
 ├── columns: r:1!null
 ├── cardinality: [1 - 1]
 ├── key: ()
 ├── fd: ()-->(1)
 └── (true,)

norm expect=FoldNullTupleIsTupleNull
SELECT () IS NULL AS r
----
values
 ├── columns: r:1!null
 ├── cardinality: [1 - 1]
 ├── key: ()
 ├── fd: ()-->(1)
 └── (true,)

norm expect-not=FoldNullTupleIsTupleNull
SELECT (k, NULL) IS NULL FROM a
----
project
 ├── columns: "?column?":8!null
 ├── scan a
 │    ├── columns: k:1!null
 │    └── key: (1)
 └── projections
      └── (k:1, NULL) IS NULL [as="?column?":8, outer=(1)]

# --------------------------------------------------
# FoldNonNullTupleIsTupleNull
# --------------------------------------------------
norm expect=FoldNonNullTupleIsTupleNull
SELECT (1, 2) IS NULL AS r
----
values
 ├── columns: r:1!null
 ├── cardinality: [1 - 1]
 ├── key: ()
 ├── fd: ()-->(1)
 └── (false,)

norm expect=FoldNonNullTupleIsTupleNull
SELECT (1, NULL) IS NULL AS r
----
values
 ├── columns: r:1!null
 ├── cardinality: [1 - 1]
 ├── key: ()
 ├── fd: ()-->(1)
 └── (false,)

norm expect=FoldNonNullTupleIsTupleNull
SELECT (1, k) IS NULL FROM a
----
project
 ├── columns: "?column?":8!null
 ├── fd: ()-->(8)
 ├── scan a
 └── projections
      └── false [as="?column?":8]

norm expect=FoldNonNullTupleIsTupleNull
SELECT ((NULL, NULL), NULL) IS NULL AS r
----
values
 ├── columns: r:1!null
 ├── cardinality: [1 - 1]
 ├── key: ()
 ├── fd: ()-->(1)
 └── (false,)

norm expect=FoldNonNullTupleIsTupleNull
SELECT (ARRAY[NULL, NULL], NULL) IS NULL AS r
----
values
 ├── columns: r:1!null
 ├── cardinality: [1 - 1]
 ├── key: ()
 ├── fd: ()-->(1)
 └── (false,)

norm expect-not=FoldNonNullTupleIsTupleNull
SELECT (k, NULL) IS NULL FROM a
----
project
 ├── columns: "?column?":8!null
 ├── scan a
 │    ├── columns: k:1!null
 │    └── key: (1)
 └── projections
      └── (k:1, NULL) IS NULL [as="?column?":8, outer=(1)]

# --------------------------------------------------
# FoldIsNotNull
# --------------------------------------------------
norm expect=FoldIsNotNull
SELECT NULL IS NOT NULL AS r, NULL IS NOT TRUE AS s
----
values
 ├── columns: r:1!null s:2!null
 ├── cardinality: [1 - 1]
 ├── key: ()
 ├── fd: ()-->(1,2)
 └── (false, true)

# --------------------------------------------------
# FoldNonNullIsNotNull
# --------------------------------------------------

# We could (but do not currently) infer that k IS NOT NULL is always True given
# that k is declared NOT NULL.
norm expect=FoldNonNullIsNotNull
SELECT 1 IS NOT NULL AS r, k IS NOT NULL AS s, i IS NOT NULL AS t FROM a
----
project
 ├── columns: r:8!null s:9!null t:10!null
 ├── fd: ()-->(8)
 ├── scan a
 │    ├── columns: k:1!null i:2
 │    ├── key: (1)
 │    └── fd: (1)-->(2)
 └── projections
      ├── true [as=r:8]
      ├── k:1 IS NOT NULL [as=s:9, outer=(1)]
      └── i:2 IS NOT NULL [as=t:10, outer=(2)]

norm expect=FoldNonNullIsNotNull
SELECT (1, 2, 3) IS DISTINCT FROM NULL AS r
----
values
 ├── columns: r:1!null
 ├── cardinality: [1 - 1]
 ├── key: ()
 ├── fd: ()-->(1)
 └── (true,)

norm expect=FoldNonNullIsNotNull
SELECT (1, NULL) IS DISTINCT FROM NULL AS r
----
values
 ├── columns: r:1!null
 ├── cardinality: [1 - 1]
 ├── key: ()
 ├── fd: ()-->(1)
 └── (true,)

norm expect=FoldNonNullIsNotNull
SELECT (1, NULL) IS DISTINCT FROM NULL AS r
----
values
 ├── columns: r:1!null
 ├── cardinality: [1 - 1]
 ├── key: ()
 ├── fd: ()-->(1)
 └── (true,)

# --------------------------------------------------
# FoldNonNullTupleIsTupleNotNull
# --------------------------------------------------
norm expect=FoldNonNullTupleIsTupleNotNull
SELECT (1, 1) IS NOT NULL AS r
----
values
 ├── columns: r:1!null
 ├── cardinality: [1 - 1]
 ├── key: ()
 ├── fd: ()-->(1)
 └── (true,)

norm expect=FoldNonNullTupleIsTupleNotNull
SELECT (1, (NULL, NULL)) IS NOT NULL AS r
----
values
 ├── columns: r:1!null
 ├── cardinality: [1 - 1]
 ├── key: ()
 ├── fd: ()-->(1)
 └── (true,)

norm expect=FoldNonNullTupleIsTupleNotNull
SELECT (1, ARRAY[NULL, NULL]) IS NOT NULL AS r
----
values
 ├── columns: r:1!null
 ├── cardinality: [1 - 1]
 ├── key: ()
 ├── fd: ()-->(1)
 └── (true,)

norm expect=FoldNonNullTupleIsTupleNotNull
SELECT () IS NOT NULL AS r
----
values
 ├── columns: r:1!null
 ├── cardinality: [1 - 1]
 ├── key: ()
 ├── fd: ()-->(1)
 └── (true,)

norm expect-not=FoldNonNullTupleIsTupleNotNull
SELECT (1, k) IS NOT NULL FROM a
----
project
 ├── columns: "?column?":8!null
 ├── scan a
 │    ├── columns: k:1!null
 │    └── key: (1)
 └── projections
      └── (1, k:1) IS NOT NULL [as="?column?":8, outer=(1)]

# --------------------------------------------------
# FoldNullTupleIsTupleNotNull
# --------------------------------------------------
norm expect=FoldNullTupleIsTupleNotNull
SELECT (1, NULL) IS NOT NULL AS r
----
values
 ├── columns: r:1!null
 ├── cardinality: [1 - 1]
 ├── key: ()
 ├── fd: ()-->(1)
 └── (false,)

norm expect=FoldNullTupleIsTupleNotNull
SELECT (k, NULL) IS NOT NULL FROM a
----
project
 ├── columns: "?column?":8!null
 ├── fd: ()-->(8)
 ├── scan a
 └── projections
      └── false [as="?column?":8]

norm expect-not=FoldNonNullTupleIsTupleNotNull
SELECT (1, k) IS NOT NULL FROM a
----
project
 ├── columns: "?column?":8!null
 ├── scan a
 │    ├── columns: k:1!null
 │    └── key: (1)
 └── projections
      └── (1, k:1) IS NOT NULL [as="?column?":8, outer=(1)]

# --------------------------------------------------
# CommuteNullIs
# --------------------------------------------------
norm expect=CommuteNullIs
SELECT NULL IS NOT TRUE AS r, NULL IS TRUE AS s
----
values
 ├── columns: r:1!null s:2!null
 ├── cardinality: [1 - 1]
 ├── key: ()
 ├── fd: ()-->(1,2)
 └── (true, false)

# --------------------------------------------------
# NormalizeCmpTimeZoneFunction
# --------------------------------------------------
exec-ddl
CREATE TABLE t (ts TIMESTAMP, tz TIMESTAMPTZ)
----

norm expect=NormalizeCmpTimeZoneFunction
SELECT timezone('America/Denver', ts) >= '2020-06-01 12:35:55-07' FROM t
----
project
 ├── columns: "?column?":5
 ├── scan t
 │    └── columns: ts:1
 └── projections
      └── ts:1 >= '2020-06-01 13:35:55' [as="?column?":5, outer=(1)]

# Apply after commuting the inequality.
norm expect=NormalizeCmpTimeZoneFunction
SELECT '2020-06-01 12:35:55-07' >= timezone('America/Denver', ts)  FROM t
----
project
 ├── columns: "?column?":5
 ├── scan t
 │    └── columns: ts:1
 └── projections
      └── ts:1 <= '2020-06-01 13:35:55' [as="?column?":5, outer=(1)]

# Don't normalize when the right-hand-side is not a constant.
norm expect-not=NormalizeCmpTimeZoneFunction
SELECT timezone('America/Denver', ts) >= tz FROM t
----
project
 ├── columns: "?column?":5
 ├── immutable
 ├── scan t
 │    └── columns: ts:1 tz:2
 └── projections
      └── tz:2 <= timezone('America/Denver', ts:1) [as="?column?":5, outer=(1,2), immutable]

# Don't normalize when the timezone() arguments are constants.
norm expect-not=NormalizeCmpTimeZoneFunction
SELECT timezone('America/Denver', '2020-06-01 12:35:55'::TIMESTAMP) >= tz FROM t
----
project
 ├── columns: "?column?":5
 ├── scan t
 │    └── columns: tz:2
 └── projections
      └── tz:2 <= '2020-06-01 18:35:55+00:00' [as="?column?":5, outer=(2)]

# --------------------------------------------------
# NormalizeCmpTimeZoneFunctionTZ
# --------------------------------------------------
norm expect=NormalizeCmpTimeZoneFunctionTZ
SELECT timezone('America/Denver', tz) >= '2020-06-01 12:35:55' FROM t
----
project
 ├── columns: "?column?":5
 ├── scan t
 │    └── columns: tz:2
 └── projections
      └── tz:2 >= '2020-06-01 18:35:55+00:00' [as="?column?":5, outer=(2)]

# Apply after commuting the inequality.
norm expect=NormalizeCmpTimeZoneFunctionTZ
SELECT '2020-06-01 12:35:55' >= timezone('America/Denver', tz)  FROM t
----
project
 ├── columns: "?column?":5
 ├── scan t
 │    └── columns: tz:2
 └── projections
      └── tz:2 <= '2020-06-01 18:35:55+00:00' [as="?column?":5, outer=(2)]

# Don't normalize when the right-hand-side is not a constant.
norm expect-not=NormalizeCmpTimeZoneFunctionTZ
SELECT timezone('America/Denver', tz) >= ts FROM t
----
project
 ├── columns: "?column?":5
 ├── immutable
 ├── scan t
 │    └── columns: ts:1 tz:2
 └── projections
      └── ts:1 <= timezone('America/Denver', tz:2) [as="?column?":5, outer=(1,2), immutable]

# Don't normalize when the timezone() arguments are constants.
norm expect-not=NormalizeCmpTimeZoneFunctionTZ
SELECT timezone('America/Denver', '2020-06-01 12:35:55-07'::TIMESTAMPTZ) >= ts FROM t
----
project
 ├── columns: "?column?":5
 ├── scan t
 │    └── columns: ts:1
 └── projections
      └── ts:1 <= '2020-06-01 13:35:55' [as="?column?":5, outer=(1)]

# --------------------------------------------------
# FoldEqZeroSTDistance
# --------------------------------------------------

# Geometry case.
norm expect=FoldEqZeroSTDistance
SELECT * FROM geom_geog WHERE st_distance(geom, 'POINT(0.0 0.0)') = 0
----
select
 ├── columns: geom:1 geog:2 val:3
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1 geog:2 val:3
 └── filters
      └── st_intersects(geom:1, '010100000000000000000000000000000000000000') [outer=(1), immutable]

# Geography case.
norm expect=FoldEqZeroSTDistance
SELECT * FROM geom_geog WHERE st_distance(geog, 'POINT(0.0 0.0)') = 0
----
select
 ├── columns: geom:1 geog:2 val:3
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1 geog:2 val:3
 └── filters
      └── st_intersects(geog:2, '0101000020E610000000000000000000000000000000000000') [outer=(2), immutable]

# No-op case because the constant is nonzero.
norm expect-not=FoldEqZeroSTDistance
SELECT * FROM geom_geog WHERE st_distance(geom, 'POINT(0.0 0.0)') = 1
----
select
 ├── columns: geom:1 geog:2 val:3
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1 geog:2 val:3
 └── filters
      └── st_distance(geom:1, '010100000000000000000000000000000000000000') = 1.0 [outer=(1), immutable]

# --------------------------------------------------
# FoldCmpSTDistanceLeft
# --------------------------------------------------

# Geometry case with '<=' operator.
norm expect=FoldCmpSTDistanceLeft
SELECT * FROM geom_geog WHERE st_distance(geom, 'point(0.0 0.0)') <= 5
----
select
 ├── columns: geom:1 geog:2 val:3
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1 geog:2 val:3
 └── filters
      └── st_dwithin(geom:1, '010100000000000000000000000000000000000000', 5.0) [outer=(1), immutable]

# Geometry case with '<' operator.
norm expect=FoldCmpSTDistanceLeft
SELECT * FROM geom_geog WHERE st_distance('point(0.0 0.0)', geom) < 5
----
select
 ├── columns: geom:1 geog:2 val:3
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1 geog:2 val:3
 └── filters
      └── st_dwithinexclusive('010100000000000000000000000000000000000000', geom:1, 5.0) [outer=(1), immutable]

# Geometry case with '>=' operator.
norm expect=FoldCmpSTDistanceLeft
SELECT * FROM geom_geog WHERE st_distance(geom, 'point(0.0 0.0)') >= 5
----
select
 ├── columns: geom:1 geog:2 val:3
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1 geog:2 val:3
 └── filters
      └── NOT st_dwithinexclusive(geom:1, '010100000000000000000000000000000000000000', 5.0) [outer=(1), immutable]

# Geometry case with '>' operator.
norm expect=FoldCmpSTDistanceLeft
SELECT * FROM geom_geog WHERE st_distance(geom, 'point(0.0 0.0)') > 5
----
select
 ├── columns: geom:1 geog:2 val:3
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1 geog:2 val:3
 └── filters
      └── NOT st_dwithin(geom:1, '010100000000000000000000000000000000000000', 5.0) [outer=(1), immutable]

# Geography case with '<=' operator.
norm expect=FoldCmpSTDistanceLeft
SELECT * FROM geom_geog WHERE st_distance(geog, 'point(0.0 0.0)') <= 5
----
select
 ├── columns: geom:1 geog:2 val:3
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1 geog:2 val:3
 └── filters
      └── st_dwithin(geog:2, '0101000020E610000000000000000000000000000000000000', 5.0) [outer=(2), immutable]

# Geography case with '<' operator.
norm expect=FoldCmpSTDistanceLeft
SELECT * FROM geom_geog WHERE st_distance(geog, 'point(0.0 0.0)') < 5
----
select
 ├── columns: geom:1 geog:2 val:3
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1 geog:2 val:3
 └── filters
      └── st_dwithinexclusive(geog:2, '0101000020E610000000000000000000000000000000000000', 5.0) [outer=(2), immutable]

# Regression test for #54326. Ensure the distance param is cast to a float.
norm expect=FoldCmpSTDistanceLeft format=(show-scalars,show-types)
SELECT * FROM geom_geog WHERE st_distance(geog, 'point(0.0 0.0)') < 5::int
----
select
 ├── columns: geom:1(geometry) geog:2(geography) val:3(float)
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1(geometry) geog:2(geography) val:3(float)
 └── filters
      └── function: st_dwithinexclusive [type=bool, outer=(2), immutable]
           ├── variable: geog:2 [type=geography]
           ├── const: '0101000020E610000000000000000000000000000000000000' [type=geography]
           └── const: 5.0 [type=float]

norm expect=FoldCmpSTDistanceLeft format=(show-scalars,show-types)
SELECT * FROM geom_geog WHERE st_distance(geog, 'point(0.0 0.0)') < val::int
----
select
 ├── columns: geom:1(geometry) geog:2(geography) val:3(float)
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1(geometry) geog:2(geography) val:3(float)
 └── filters
      └── function: st_dwithinexclusive [type=bool, outer=(2,3), immutable]
           ├── variable: geog:2 [type=geography]
           ├── const: '0101000020E610000000000000000000000000000000000000' [type=geography]
           └── cast: FLOAT8 [type=float]
                └── cast: INT8 [type=int]
                     └── variable: val:3 [type=float]

# --------------------------------------------------
# FoldCmpSTDistanceRight
# --------------------------------------------------

# Case with '<=' operator.
norm expect=FoldCmpSTDistanceRight
SELECT * FROM geom_geog WHERE val <= st_distance(geom, 'point(0.0 0.0)')
----
select
 ├── columns: geom:1 geog:2 val:3
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1 geog:2 val:3
 └── filters
      └── NOT st_dwithinexclusive(geom:1, '010100000000000000000000000000000000000000', val:3) [outer=(1,3), immutable]

# Case with '<' operator.
norm expect=FoldCmpSTDistanceRight
SELECT * FROM geom_geog WHERE val < st_distance(geom, 'point(0.0 0.0)')
----
select
 ├── columns: geom:1 geog:2 val:3
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1 geog:2 val:3
 └── filters
      └── NOT st_dwithin(geom:1, '010100000000000000000000000000000000000000', val:3) [outer=(1,3), immutable]

# Case with '>=' operator.
norm expect=FoldCmpSTDistanceRight
SELECT * FROM geom_geog WHERE val >= st_distance(geom, 'point(0.0 0.0)')
----
select
 ├── columns: geom:1 geog:2 val:3
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1 geog:2 val:3
 └── filters
      └── st_dwithin(geom:1, '010100000000000000000000000000000000000000', val:3) [outer=(1,3), immutable]

# Case with '>' operator.
norm expect=FoldCmpSTDistanceRight
SELECT * FROM geom_geog WHERE val > st_distance(geom, 'point(0.0 0.0)')
----
select
 ├── columns: geom:1 geog:2 val:3
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1 geog:2 val:3
 └── filters
      └── st_dwithinexclusive(geom:1, '010100000000000000000000000000000000000000', val:3) [outer=(1,3), immutable]

# --------------------------------------------------
# FoldCmpSTMaxDistanceLeft
# --------------------------------------------------

# Case with '<=' operator.
norm expect=FoldCmpSTMaxDistanceLeft
SELECT * FROM geom_geog WHERE st_maxdistance(geom, 'point(0.0 0.0)') <= 5
----
select
 ├── columns: geom:1 geog:2 val:3
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1 geog:2 val:3
 └── filters
      └── st_dfullywithin(geom:1, '010100000000000000000000000000000000000000', 5.0) [outer=(1), immutable]

# Case with '<' operator.
norm expect=FoldCmpSTMaxDistanceLeft
SELECT * FROM geom_geog WHERE st_maxdistance('point(0.0 0.0)', geom) < 5
----
select
 ├── columns: geom:1 geog:2 val:3
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1 geog:2 val:3
 └── filters
      └── st_dfullywithinexclusive('010100000000000000000000000000000000000000', geom:1, 5.0) [outer=(1), immutable]

# Case with '>=' operator.
norm expect=FoldCmpSTMaxDistanceLeft
SELECT * FROM geom_geog WHERE st_maxdistance(geom, 'point(0.0 0.0)') >= 5
----
select
 ├── columns: geom:1 geog:2 val:3
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1 geog:2 val:3
 └── filters
      └── NOT st_dfullywithinexclusive(geom:1, '010100000000000000000000000000000000000000', 5.0) [outer=(1), immutable]

# Case with '>' operator.
norm expect=FoldCmpSTMaxDistanceLeft
SELECT * FROM geom_geog WHERE st_maxdistance(geom, 'point(0.0 0.0)') > 5
----
select
 ├── columns: geom:1 geog:2 val:3
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1 geog:2 val:3
 └── filters
      └── NOT st_dfullywithin(geom:1, '010100000000000000000000000000000000000000', 5.0) [outer=(1), immutable]

# --------------------------------------------------
# FoldCmpSTMaxDistanceRight
# --------------------------------------------------

# Case with '<=' operator.
norm expect=FoldCmpSTMaxDistanceRight
SELECT * FROM geom_geog WHERE val <= st_maxdistance(geom, 'point(0.0 0.0)')
----
select
 ├── columns: geom:1 geog:2 val:3
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1 geog:2 val:3
 └── filters
      └── NOT st_dfullywithinexclusive(geom:1, '010100000000000000000000000000000000000000', val:3) [outer=(1,3), immutable]

# Case with '<' operator.
norm expect=FoldCmpSTMaxDistanceRight
SELECT * FROM geom_geog WHERE val < st_maxdistance(geom, 'point(0.0 0.0)')
----
select
 ├── columns: geom:1 geog:2 val:3
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1 geog:2 val:3
 └── filters
      └── NOT st_dfullywithin(geom:1, '010100000000000000000000000000000000000000', val:3) [outer=(1,3), immutable]

# Case with '>=' operator.
norm expect=FoldCmpSTMaxDistanceRight
SELECT * FROM geom_geog WHERE val >= st_maxdistance(geom, 'point(0.0 0.0)')
----
select
 ├── columns: geom:1 geog:2 val:3
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1 geog:2 val:3
 └── filters
      └── st_dfullywithin(geom:1, '010100000000000000000000000000000000000000', val:3) [outer=(1,3), immutable]

# Case with '>' operator.
norm expect=FoldCmpSTMaxDistanceRight
SELECT * FROM geom_geog WHERE val > st_maxdistance(geom, 'point(0.0 0.0)')
----
select
 ├── columns: geom:1 geog:2 val:3
 ├── immutable
 ├── scan geom_geog
 │    └── columns: geom:1 geog:2 val:3
 └── filters
      └── st_dfullywithinexclusive(geom:1, '010100000000000000000000000000000000000000', val:3) [outer=(1,3), immutable]