bool

exec-ddl
CREATE TABLE a (k INT PRIMARY KEY, i INT, f FLOAT, s STRING, j JSON)
----
TABLE a
 ├── k int not null
 ├── i int
 ├── f float
 ├── s string
 ├── j jsonb
 └── INDEX primary
      └── k int not null

exec-ddl
CREATE TABLE t.b (x INT PRIMARY KEY, z INT)
----
TABLE b
 ├── x int not null
 ├── z int
 └── INDEX primary
      └── x int not null

# --------------------------------------------------
# EliminateEmptyAnd
# --------------------------------------------------
opt
SELECT * FROM a WHERE True AND True
----
scan a
 └── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)

# --------------------------------------------------
# EliminateEmptyOr
# --------------------------------------------------
opt
SELECT False OR False
----
project
 ├── columns: column1:1(bool)
 ├── values
 │    └── tuple [type=tuple{}]
 └── projections
      └── false [type=bool]

# --------------------------------------------------
# EliminateSingletonAndOr
# --------------------------------------------------
opt
SELECT (i=5 OR False) AND (s<'foo' AND True) FROM a
----
project
 ├── columns: column6:6(bool)
 ├── scan a
 │    └── columns: a.i:2(int) a.s:4(string)
 └── projections [outer=(2,4)]
      └── and [type=bool, outer=(2,4), constraints=(/2: [/5 - /5]; /4: (/NULL - /'foo'); tight)]
           ├── eq [type=bool, outer=(2), constraints=(/2: [/5 - /5]; tight)]
           │    ├── variable: a.i [type=int, outer=(2)]
           │    └── const: 5 [type=int]
           └── lt [type=bool, outer=(4), constraints=(/4: (/NULL - /'foo'); tight)]
                ├── variable: a.s [type=string, outer=(4)]
                └── const: 'foo' [type=string]

# --------------------------------------------------
# SimplifyAnd
# --------------------------------------------------

# Replace with False if any operand is false.
opt
SELECT k=1 AND False AND f=3.5 FROM a
----
project
 ├── columns: column6:6(bool)
 ├── scan a
 └── projections
      └── false [type=bool]

opt
SELECT False AND s='foo' FROM a
----
project
 ├── columns: column6:6(bool)
 ├── scan a
 └── projections
      └── false [type=bool]

# Discard True operands.
opt
SELECT true AND k=1 FROM a
----
project
 ├── columns: column6:6(bool)
 ├── scan a
 │    └── columns: a.k:1(int!null)
 └── projections [outer=(1)]
      └── eq [type=bool, outer=(1), constraints=(/1: [/1 - /1]; tight)]
           ├── variable: a.k [type=int, outer=(1)]
           └── const: 1 [type=int]

opt
SELECT k=1 AND i=2 AND true FROM a
----
project
 ├── columns: column6:6(bool)
 ├── scan a
 │    └── columns: a.k:1(int!null) a.i:2(int)
 └── projections [outer=(1,2)]
      └── and [type=bool, outer=(1,2), constraints=(/1: [/1 - /1]; /2: [/2 - /2]; tight)]
           ├── eq [type=bool, outer=(1), constraints=(/1: [/1 - /1]; tight)]
           │    ├── variable: a.k [type=int, outer=(1)]
           │    └── const: 1 [type=int]
           └── eq [type=bool, outer=(2), constraints=(/2: [/2 - /2]; tight)]
                ├── variable: a.i [type=int, outer=(2)]
                └── const: 2 [type=int]

# No conditions left after rule.
opt
SELECT * FROM a WHERE true AND true
----
scan a
 └── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)

# Flatten nested And operands.
opt
SELECT (k>1 AND k<5) AND (f=3.5 AND s='foo') FROM a
----
project
 ├── columns: column6:6(bool)
 ├── scan a
 │    └── columns: a.k:1(int!null) a.f:3(float) a.s:4(string)
 └── projections [outer=(1,3,4)]
      └── and [type=bool, outer=(1,3,4), constraints=(/1: [/2 - /4]; /3: [/3.5 - /3.5]; /4: [/'foo' - /'foo']; tight)]
           ├── gt [type=bool, outer=(1), constraints=(/1: [/2 - ]; tight)]
           │    ├── variable: a.k [type=int, outer=(1)]
           │    └── const: 1 [type=int]
           ├── lt [type=bool, outer=(1), constraints=(/1: (/NULL - /4]; tight)]
           │    ├── variable: a.k [type=int, outer=(1)]
           │    └── const: 5 [type=int]
           ├── eq [type=bool, outer=(3), constraints=(/3: [/3.5 - /3.5]; tight)]
           │    ├── variable: a.f [type=float, outer=(3)]
           │    └── const: 3.5 [type=float]
           └── eq [type=bool, outer=(4), constraints=(/4: [/'foo' - /'foo']; tight)]
                ├── variable: a.s [type=string, outer=(4)]
                └── const: 'foo' [type=string]

# --------------------------------------------------
# SimplifyOr
# --------------------------------------------------

# Replace with True if any operand is True.
opt
SELECT k=1 OR (i=2 OR True) FROM a
----
project
 ├── columns: column6:6(bool)
 ├── scan a
 └── projections
      └── true [type=bool]

opt
SELECT k=1 OR True OR f=3.5 FROM a
----
project
 ├── columns: column6:6(bool)
 ├── scan a
 └── projections
      └── true [type=bool]

# Discard False operands.
opt
SELECT false OR k=1 FROM a
----
project
 ├── columns: column6:6(bool)
 ├── scan a
 │    └── columns: a.k:1(int!null)
 └── projections [outer=(1)]
      └── eq [type=bool, outer=(1), constraints=(/1: [/1 - /1]; tight)]
           ├── variable: a.k [type=int, outer=(1)]
           └── const: 1 [type=int]

opt
SELECT * FROM a WHERE k=1 OR i=2 OR false
----
select
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)
 ├── scan a
 │    └── columns: a.k:1(int!null) a.i:2(int) a.f:3(float) a.s:4(string) a.j:5(jsonb)
 └── filters [type=bool, outer=(1,2)]
      └── or [type=bool, outer=(1,2)]
           ├── eq [type=bool, outer=(1), constraints=(/1: [/1 - /1]; tight)]
           │    ├── variable: a.k [type=int, outer=(1)]
           │    └── const: 1 [type=int]
           └── eq [type=bool, outer=(2), constraints=(/2: [/2 - /2]; tight)]
                ├── variable: a.i [type=int, outer=(2)]
                └── const: 2 [type=int]

# No conditions left after rule.
opt
SELECT * FROM a WHERE false OR false
----
scan a,constrained
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)
 └── constraint: /1: contradiction

# Flatten nested Or operands.
opt
SELECT * FROM a WHERE (k=1 OR i=2) OR (f=3.5 OR s='foo')
----
select
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)
 ├── scan a
 │    └── columns: a.k:1(int!null) a.i:2(int) a.f:3(float) a.s:4(string) a.j:5(jsonb)
 └── filters [type=bool, outer=(1-4)]
      └── or [type=bool, outer=(1-4)]
           ├── eq [type=bool, outer=(1), constraints=(/1: [/1 - /1]; tight)]
           │    ├── variable: a.k [type=int, outer=(1)]
           │    └── const: 1 [type=int]
           ├── eq [type=bool, outer=(2), constraints=(/2: [/2 - /2]; tight)]
           │    ├── variable: a.i [type=int, outer=(2)]
           │    └── const: 2 [type=int]
           ├── eq [type=bool, outer=(3), constraints=(/3: [/3.5 - /3.5]; tight)]
           │    ├── variable: a.f [type=float, outer=(3)]
           │    └── const: 3.5 [type=float]
           └── eq [type=bool, outer=(4), constraints=(/4: [/'foo' - /'foo']; tight)]
                ├── variable: a.s [type=string, outer=(4)]
                └── const: 'foo' [type=string]

# --------------------------------------------------
# SimplifyAnd + SimplifyOr
# --------------------------------------------------
opt
SELECT (k=1 OR false) AND (false OR k=2 OR false) AND true FROM a
----
project
 ├── columns: column6:6(bool)
 ├── scan a
 │    └── columns: a.k:1(int!null)
 └── projections [outer=(1)]
      └── and [type=bool, outer=(1), constraints=(contradiction; tight)]
           ├── eq [type=bool, outer=(1), constraints=(/1: [/1 - /1]; tight)]
           │    ├── variable: a.k [type=int, outer=(1)]
           │    └── const: 1 [type=int]
           └── eq [type=bool, outer=(1), constraints=(/1: [/2 - /2]; tight)]
                ├── variable: a.k [type=int, outer=(1)]
                └── const: 2 [type=int]

# Use parentheses to make and/or tree right-heavy instead of left-heavy.
opt
SELECT (k=1 OR (i=2 OR f=3.5)) AND (s='foo' AND s<>'bar') FROM a
----
project
 ├── columns: column6:6(bool)
 ├── scan a
 │    └── columns: a.k:1(int!null) a.i:2(int) a.f:3(float) a.s:4(string)
 └── projections [outer=(1-4)]
      └── and [type=bool, outer=(1-4), constraints=(/4: [/'foo' - /'foo'])]
           ├── or [type=bool, outer=(1-3)]
           │    ├── eq [type=bool, outer=(1), constraints=(/1: [/1 - /1]; tight)]
           │    │    ├── variable: a.k [type=int, outer=(1)]
           │    │    └── const: 1 [type=int]
           │    ├── eq [type=bool, outer=(2), constraints=(/2: [/2 - /2]; tight)]
           │    │    ├── variable: a.i [type=int, outer=(2)]
           │    │    └── const: 2 [type=int]
           │    └── eq [type=bool, outer=(3), constraints=(/3: [/3.5 - /3.5]; tight)]
           │         ├── variable: a.f [type=float, outer=(3)]
           │         └── const: 3.5 [type=float]
           ├── eq [type=bool, outer=(4), constraints=(/4: [/'foo' - /'foo']; tight)]
           │    ├── variable: a.s [type=string, outer=(4)]
           │    └── const: 'foo' [type=string]
           └── ne [type=bool, outer=(4)]
                ├── variable: a.s [type=string, outer=(4)]
                └── const: 'bar' [type=string]

# --------------------------------------------------
# SimplifyFilters
# --------------------------------------------------
opt
SELECT * FROM a WHERE Null
----
scan a,constrained
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)
 └── constraint: /1: contradiction

opt
SELECT * FROM a INNER JOIN b ON NULL
----
inner-join
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb) x:6(int!null) z:7(int)
 ├── scan a
 │    └── columns: a.k:1(int!null) a.i:2(int) a.f:3(float) a.s:4(string) a.j:5(jsonb)
 ├── scan b
 │    └── columns: b.x:6(int!null) b.z:7(int)
 └── false [type=bool]

opt
SELECT * FROM a WHERE i=1 AND Null
----
scan a,constrained
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)
 └── constraint: /1: contradiction

# --------------------------------------------------
# FoldNullAndOr
# --------------------------------------------------
opt
SELECT * FROM a WHERE null and null
----
scan a,constrained
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)
 └── constraint: /1: contradiction

opt
SELECT * FROM a WHERE null or null
----
scan a,constrained
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)
 └── constraint: /1: contradiction

opt
SELECT * FROM a WHERE null or (null and null and null) or null
----
scan a,constrained
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)
 └── constraint: /1: contradiction

# Don't fold.
opt
SELECT * FROM a WHERE null or (null and k=1)
----
scan a,constrained
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)
 └── constraint: /1: contradiction

# --------------------------------------------------
# NegateComparison
# --------------------------------------------------

# Equality and inequality comparisons.
opt
SELECT * FROM a WHERE NOT(i=1) AND NOT(i<>1) AND NOT(i>1) AND NOT(i>=1) AND NOT(i<1) AND NOT(i<=1)
----
select
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)
 ├── scan a
 │    └── columns: a.k:1(int!null) a.i:2(int) a.f:3(float) a.s:4(string) a.j:5(jsonb)
 └── filters [type=bool, outer=(2), constraints=(contradiction)]
      ├── ne [type=bool, outer=(2)]
      │    ├── variable: a.i [type=int, outer=(2)]
      │    └── const: 1 [type=int]
      ├── eq [type=bool, outer=(2), constraints=(/2: [/1 - /1]; tight)]
      │    ├── variable: a.i [type=int, outer=(2)]
      │    └── const: 1 [type=int]
      ├── le [type=bool, outer=(2), constraints=(/2: (/NULL - /1]; tight)]
      │    ├── variable: a.i [type=int, outer=(2)]
      │    └── const: 1 [type=int]
      ├── lt [type=bool, outer=(2), constraints=(/2: (/NULL - /0]; tight)]
      │    ├── variable: a.i [type=int, outer=(2)]
      │    └── const: 1 [type=int]
      ├── ge [type=bool, outer=(2), constraints=(/2: [/1 - ]; tight)]
      │    ├── variable: a.i [type=int, outer=(2)]
      │    └── const: 1 [type=int]
      └── gt [type=bool, outer=(2), constraints=(/2: [/2 - ]; tight)]
           ├── variable: a.i [type=int, outer=(2)]
           └── const: 1 [type=int]

# IN and IS comparisons.
opt
SELECT *
FROM a
WHERE NOT(i IN (1,2)) AND NOT(i NOT IN (3,4)) AND NOT(i IS NULL) AND NOT(i IS NOT NULL)
----
select
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)
 ├── scan a
 │    └── columns: a.k:1(int!null) a.i:2(int) a.f:3(float) a.s:4(string) a.j:5(jsonb)
 └── filters [type=bool, outer=(2)]
      ├── not-in [type=bool, outer=(2)]
      │    ├── variable: a.i [type=int, outer=(2)]
      │    └── tuple [type=tuple{int, int}]
      │         ├── const: 1 [type=int]
      │         └── const: 2 [type=int]
      ├── in [type=bool, outer=(2)]
      │    ├── variable: a.i [type=int, outer=(2)]
      │    └── tuple [type=tuple{int, int}]
      │         ├── const: 3 [type=int]
      │         └── const: 4 [type=int]
      ├── is-not [type=bool, outer=(2)]
      │    ├── variable: a.i [type=int, outer=(2)]
      │    └── null [type=unknown]
      └── is [type=bool, outer=(2)]
           ├── variable: a.i [type=int, outer=(2)]
           └── null [type=unknown]

# Like comparisons.
opt
SELECT *
FROM a
WHERE NOT(s LIKE 'foo') AND NOT(s NOT LIKE 'foo') AND NOT(s ILIKE 'foo') AND NOT(s NOT ILIKE 'foo')
----
select
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)
 ├── scan a
 │    └── columns: a.k:1(int!null) a.i:2(int) a.f:3(float) a.s:4(string) a.j:5(jsonb)
 └── filters [type=bool, outer=(4)]
      ├── not-like [type=bool, outer=(4)]
      │    ├── variable: a.s [type=string, outer=(4)]
      │    └── const: 'foo' [type=string]
      ├── like [type=bool, outer=(4)]
      │    ├── variable: a.s [type=string, outer=(4)]
      │    └── const: 'foo' [type=string]
      ├── not-i-like [type=bool, outer=(4)]
      │    ├── variable: a.s [type=string, outer=(4)]
      │    └── const: 'foo' [type=string]
      └── i-like [type=bool, outer=(4)]
           ├── variable: a.s [type=string, outer=(4)]
           └── const: 'foo' [type=string]

# SimilarTo comparisons.
opt
SELECT * FROM a WHERE NOT(s SIMILAR TO 'foo') AND NOT(s NOT SIMILAR TO 'foo')
----
select
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)
 ├── scan a
 │    └── columns: a.k:1(int!null) a.i:2(int) a.f:3(float) a.s:4(string) a.j:5(jsonb)
 └── filters [type=bool, outer=(4)]
      ├── not-similar-to [type=bool, outer=(4)]
      │    ├── variable: a.s [type=string, outer=(4)]
      │    └── const: 'foo' [type=string]
      └── similar-to [type=bool, outer=(4)]
           ├── variable: a.s [type=string, outer=(4)]
           └── const: 'foo' [type=string]

# RegMatch comparisons.
opt
SELECT * FROM a WHERE NOT(s ~ 'foo') AND NOT(s !~ 'foo') AND NOT(s ~* 'foo') AND NOT (s !~* 'foo')
----
select
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)
 ├── scan a
 │    └── columns: a.k:1(int!null) a.i:2(int) a.f:3(float) a.s:4(string) a.j:5(jsonb)
 └── filters [type=bool, outer=(4)]
      ├── not-reg-match [type=bool, outer=(4)]
      │    ├── variable: a.s [type=string, outer=(4)]
      │    └── const: 'foo' [type=string]
      ├── reg-match [type=bool, outer=(4)]
      │    ├── variable: a.s [type=string, outer=(4)]
      │    └── const: 'foo' [type=string]
      ├── not-reg-i-match [type=bool, outer=(4)]
      │    ├── variable: a.s [type=string, outer=(4)]
      │    └── const: 'foo' [type=string]
      └── reg-i-match [type=bool, outer=(4)]
           ├── variable: a.s [type=string, outer=(4)]
           └── const: 'foo' [type=string]

# Contains comparison (should not be negated).
opt
SELECT * FROM a WHERE NOT('[1, 2]' @> j) AND NOT(j <@ '[3, 4]')
----
select
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)
 ├── scan a
 │    └── columns: a.k:1(int!null) a.i:2(int) a.f:3(float) a.s:4(string) a.j:5(jsonb)
 └── filters [type=bool, outer=(5)]
      ├── not [type=bool, outer=(5)]
      │    └── contains [type=bool, outer=(5)]
      │         ├── const: '[1, 2]' [type=jsonb]
      │         └── variable: a.j [type=jsonb, outer=(5)]
      └── not [type=bool, outer=(5)]
           └── contains [type=bool, outer=(5)]
                ├── const: '[3, 4]' [type=jsonb]
                └── variable: a.j [type=jsonb, outer=(5)]

# --------------------------------------------------
# EliminateNot
# --------------------------------------------------
opt
SELECT * FROM a WHERE NOT(NOT('[1, 2]' @> j))
----
select
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)
 ├── scan a
 │    └── columns: a.k:1(int!null) a.i:2(int) a.f:3(float) a.s:4(string) a.j:5(jsonb)
 └── filters [type=bool, outer=(5)]
      └── contains [type=bool, outer=(5)]
           ├── const: '[1, 2]' [type=jsonb]
           └── variable: a.j [type=jsonb, outer=(5)]

# --------------------------------------------------
# NegateAnd + NegateComparison
# --------------------------------------------------
opt
SELECT * FROM a WHERE NOT (k >= i AND i < f)
----
select
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)
 ├── scan a
 │    └── columns: a.k:1(int!null) a.i:2(int) a.f:3(float) a.s:4(string) a.j:5(jsonb)
 └── filters [type=bool, outer=(1-3)]
      └── or [type=bool, outer=(1-3)]
           ├── lt [type=bool, outer=(1,2)]
           │    ├── variable: a.k [type=int, outer=(1)]
           │    └── variable: a.i [type=int, outer=(2)]
           └── ge [type=bool, outer=(2,3)]
                ├── variable: a.i [type=int, outer=(2)]
                └── variable: a.f [type=float, outer=(3)]

opt
SELECT * FROM a WHERE NOT (k >= i AND i < f AND (i > 5 AND i < 10 AND f > 1))
----
select
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)
 ├── scan a
 │    └── columns: a.k:1(int!null) a.i:2(int) a.f:3(float) a.s:4(string) a.j:5(jsonb)
 └── filters [type=bool, outer=(1-3)]
      └── or [type=bool, outer=(1-3)]
           ├── lt [type=bool, outer=(1,2)]
           │    ├── variable: a.k [type=int, outer=(1)]
           │    └── variable: a.i [type=int, outer=(2)]
           ├── ge [type=bool, outer=(2,3)]
           │    ├── variable: a.i [type=int, outer=(2)]
           │    └── variable: a.f [type=float, outer=(3)]
           ├── le [type=bool, outer=(2), constraints=(/2: (/NULL - /5]; tight)]
           │    ├── variable: a.i [type=int, outer=(2)]
           │    └── const: 5 [type=int]
           ├── ge [type=bool, outer=(2), constraints=(/2: [/10 - ]; tight)]
           │    ├── variable: a.i [type=int, outer=(2)]
           │    └── const: 10 [type=int]
           └── le [type=bool, outer=(3), constraints=(/3: (/NULL - /1.0]; tight)]
                ├── variable: a.f [type=float, outer=(3)]
                └── const: 1.0 [type=float]


# --------------------------------------------------
# NegateOr + NegateComparison
# --------------------------------------------------
opt
SELECT * FROM a WHERE NOT (k >= i OR i < f OR k + i < f)
----
select
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)
 ├── scan a
 │    └── columns: a.k:1(int!null) a.i:2(int) a.f:3(float) a.s:4(string) a.j:5(jsonb)
 └── filters [type=bool, outer=(1-3)]
      ├── lt [type=bool, outer=(1,2)]
      │    ├── variable: a.k [type=int, outer=(1)]
      │    └── variable: a.i [type=int, outer=(2)]
      ├── ge [type=bool, outer=(2,3)]
      │    ├── variable: a.i [type=int, outer=(2)]
      │    └── variable: a.f [type=float, outer=(3)]
      └── le [type=bool, outer=(1-3)]
           ├── variable: a.f [type=float, outer=(3)]
           └── plus [type=int, outer=(1,2)]
                ├── variable: a.k [type=int, outer=(1)]
                └── variable: a.i [type=int, outer=(2)]

opt
SELECT * FROM a WHERE NOT (k >= i OR i < f OR (i > 5 OR i < 10 OR f > 1))
----
select
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)
 ├── scan a
 │    └── columns: a.k:1(int!null) a.i:2(int) a.f:3(float) a.s:4(string) a.j:5(jsonb)
 └── filters [type=bool, outer=(1-3), constraints=(contradiction)]
      ├── lt [type=bool, outer=(1,2)]
      │    ├── variable: a.k [type=int, outer=(1)]
      │    └── variable: a.i [type=int, outer=(2)]
      ├── ge [type=bool, outer=(2,3)]
      │    ├── variable: a.i [type=int, outer=(2)]
      │    └── variable: a.f [type=float, outer=(3)]
      ├── le [type=bool, outer=(2), constraints=(/2: (/NULL - /5]; tight)]
      │    ├── variable: a.i [type=int, outer=(2)]
      │    └── const: 5 [type=int]
      ├── ge [type=bool, outer=(2), constraints=(/2: [/10 - ]; tight)]
      │    ├── variable: a.i [type=int, outer=(2)]
      │    └── const: 10 [type=int]
      └── le [type=bool, outer=(3), constraints=(/3: (/NULL - /1.0]; tight)]
           ├── variable: a.f [type=float, outer=(3)]
           └── const: 1.0 [type=float]

# --------------------------------------------------
# NegateAnd + NegateOr + NegateComparison
# --------------------------------------------------
opt
SELECT * FROM a WHERE NOT ((k >= i OR i < f) AND (i > 5 OR f > 1))
----
select
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)
 ├── scan a
 │    └── columns: a.k:1(int!null) a.i:2(int) a.f:3(float) a.s:4(string) a.j:5(jsonb)
 └── filters [type=bool, outer=(1-3)]
      └── or [type=bool, outer=(1-3)]
           ├── and [type=bool, outer=(1-3)]
           │    ├── lt [type=bool, outer=(1,2)]
           │    │    ├── variable: a.k [type=int, outer=(1)]
           │    │    └── variable: a.i [type=int, outer=(2)]
           │    └── ge [type=bool, outer=(2,3)]
           │         ├── variable: a.i [type=int, outer=(2)]
           │         └── variable: a.f [type=float, outer=(3)]
           └── and [type=bool, outer=(2,3), constraints=(/2: (/NULL - /5]; /3: (/NULL - /1.0]; tight)]
                ├── le [type=bool, outer=(2), constraints=(/2: (/NULL - /5]; tight)]
                │    ├── variable: a.i [type=int, outer=(2)]
                │    └── const: 5 [type=int]
                └── le [type=bool, outer=(3), constraints=(/3: (/NULL - /1.0]; tight)]
                     ├── variable: a.f [type=float, outer=(3)]
                     └── const: 1.0 [type=float]

opt
SELECT * FROM a WHERE NOT ((k >= i AND i < f) OR (i > 5 AND f > 1))
----
select
 ├── columns: k:1(int!null) i:2(int) f:3(float) s:4(string) j:5(jsonb)
 ├── scan a
 │    └── columns: a.k:1(int!null) a.i:2(int) a.f:3(float) a.s:4(string) a.j:5(jsonb)
 └── filters [type=bool, outer=(1-3)]
      ├── or [type=bool, outer=(1-3)]
      │    ├── lt [type=bool, outer=(1,2)]
      │    │    ├── variable: a.k [type=int, outer=(1)]
      │    │    └── variable: a.i [type=int, outer=(2)]
      │    └── ge [type=bool, outer=(2,3)]
      │         ├── variable: a.i [type=int, outer=(2)]
      │         └── variable: a.f [type=float, outer=(3)]
      └── or [type=bool, outer=(2,3)]
           ├── le [type=bool, outer=(2), constraints=(/2: (/NULL - /5]; tight)]
           │    ├── variable: a.i [type=int, outer=(2)]
           │    └── const: 5 [type=int]
           └── le [type=bool, outer=(3), constraints=(/3: (/NULL - /1.0]; tight)]
                ├── variable: a.f [type=float, outer=(3)]
                └── const: 1.0 [type=float]