# Test that column defaults are redacted.

statement ok
CREATE TABLE a (a STRING DEFAULT 'a')

query TT
SHOW CREATE TABLE a WITH REDACT
----
a  CREATE TABLE public.a (
     a STRING NULL DEFAULT ‹×›:::STRING,
     rowid INT8 NOT VISIBLE NOT NULL DEFAULT unique_rowid(),
     CONSTRAINT a_pkey PRIMARY KEY (rowid ASC)
   )

statement ok
CREATE TABLE b (b BOOLEAN DEFAULT false)

query TT
SHOW CREATE TABLE b WITH REDACT
----
b  CREATE TABLE public.b (
     b BOOL NULL DEFAULT ‹×›,
     rowid INT8 NOT VISIBLE NOT NULL DEFAULT unique_rowid(),
     CONSTRAINT b_pkey PRIMARY KEY (rowid ASC)
   )

statement ok
CREATE TABLE c (c CHAR DEFAULT 'c')

query TT
SHOW CREATE TABLE c WITH REDACT
----
c  CREATE TABLE public.c (
     c CHAR NULL DEFAULT ‹×›:::STRING,
     rowid INT8 NOT VISIBLE NOT NULL DEFAULT unique_rowid(),
     CONSTRAINT c_pkey PRIMARY KEY (rowid ASC)
   )

statement ok
CREATE TABLE d (d DATE DEFAULT '1999-12-31')

query TT
SHOW CREATE TABLE d WITH REDACT
----
d  CREATE TABLE public.d (
     d DATE NULL DEFAULT ‹×›:::DATE,
     rowid INT8 NOT VISIBLE NOT NULL DEFAULT unique_rowid(),
     CONSTRAINT d_pkey PRIMARY KEY (rowid ASC)
   )

statement ok
CREATE TABLE i (i INT DEFAULT 0)

query TT
SHOW CREATE TABLE i WITH REDACT
----
i  CREATE TABLE public.i (
     i INT8 NULL DEFAULT ‹×›:::INT8,
     rowid INT8 NOT VISIBLE NOT NULL DEFAULT unique_rowid(),
     CONSTRAINT i_pkey PRIMARY KEY (rowid ASC)
   )

statement ok
CREATE TABLE j (j JSON DEFAULT '{}')

query TT
SHOW CREATE j WITH REDACT
----
j  CREATE TABLE public.j (
     j JSONB NULL DEFAULT ‹×›:::JSONB,
     rowid INT8 NOT VISIBLE NOT NULL DEFAULT unique_rowid(),
     CONSTRAINT j_pkey PRIMARY KEY (rowid ASC)
   )

statement ok
CREATE TABLE n (n INT DEFAULT NULL)

query TT
SHOW CREATE TABLE n WITH REDACT
----
n  CREATE TABLE public.n (
     n INT8 NULL,
     rowid INT8 NOT VISIBLE NOT NULL DEFAULT unique_rowid(),
     CONSTRAINT n_pkey PRIMARY KEY (rowid ASC)
   )

# Test that constants in computed columns are redacted.

statement ok
CREATE TABLE ef (e INT, f INT AS (e + 1) VIRTUAL)

query TT
SHOW CREATE TABLE ef WITH REDACT
----
ef  CREATE TABLE public.ef (
      e INT8 NULL,
      f INT8 NULL AS (e + ‹×›:::INT8) VIRTUAL,
      rowid INT8 NOT VISIBLE NOT NULL DEFAULT unique_rowid(),
      CONSTRAINT ef_pkey PRIMARY KEY (rowid ASC)
    )

statement ok
CREATE TABLE g (g GEOMETRY AS ('POINT (0 0)') VIRTUAL)

query TT
SHOW CREATE TABLE g WITH REDACT
----
g  CREATE TABLE public.g (
     g GEOMETRY NULL AS (‹×›:::GEOMETRY) VIRTUAL,
     rowid INT8 NOT VISIBLE NOT NULL DEFAULT unique_rowid(),
     CONSTRAINT g_pkey PRIMARY KEY (rowid ASC)
   )

statement ok
CREATE TABLE hi (h INTERVAL PRIMARY KEY, i INTERVAL AS (h - '12:00:00') STORED, FAMILY (h, i))

query TT
SHOW CREATE TABLE hi WITH REDACT
----
hi  CREATE TABLE public.hi (
      h INTERVAL NOT NULL,
      i INTERVAL NULL AS (h - ‹×›:::INTERVAL) STORED,
      CONSTRAINT hi_pkey PRIMARY KEY (h ASC),
      FAMILY fam_0_h_i (h, i)
    )

statement ok
CREATE TABLE jk (j JSONB, k STRING PRIMARY KEY, jk JSONB AS (j->k->'foo') STORED, INVERTED INDEX (jk), FAMILY (k, j, jk))

query TT
SHOW CREATE TABLE jk WITH REDACT
----
jk  CREATE TABLE public.jk (
      j JSONB NULL,
      k STRING NOT NULL,
      jk JSONB NULL AS ((j->k)->‹×›:::STRING) STORED,
      CONSTRAINT jk_pkey PRIMARY KEY (k ASC),
      INVERTED INDEX jk_jk_idx (jk),
      FAMILY fam_0_k_j_jk (k, j, jk)
    )

# Test that constants in constraints are redacted.

statement ok
CREATE TABLE k (k INT PRIMARY KEY, CHECK (k > 0), CHECK (true))

query TT
SHOW CREATE k WITH REDACT
----
k  CREATE TABLE public.k (
     k INT8 NOT NULL,
     CONSTRAINT k_pkey PRIMARY KEY (k ASC),
     CONSTRAINT check_k CHECK (k > ‹×›:::INT8),
     CONSTRAINT "check" CHECK (‹×›)
   )

statement ok
CREATE TABLE dl (d DECIMAL PRIMARY KEY, l DECIMAL, CHECK (d != l + 2.0), FAMILY (d, l))

query TT
SHOW CREATE TABLE dl WITH REDACT
----
dl  CREATE TABLE public.dl (
      d DECIMAL NOT NULL,
      l DECIMAL NULL,
      CONSTRAINT dl_pkey PRIMARY KEY (d ASC),
      FAMILY fam_0_d_l (d, l),
      CONSTRAINT check_d_l CHECK (d != (l + ‹×›:::DECIMAL))
    )

# Test that constants in expression indexes are redacted.

statement ok
CREATE TABLE m (m STRING[], INDEX (array_cat(m, ARRAY['', NULL, 'm'])))

query TT
SHOW CREATE TABLE m WITH REDACT
----
m  CREATE TABLE public.m (
     m STRING[] NULL,
     rowid INT8 NOT VISIBLE NOT NULL DEFAULT unique_rowid(),
     CONSTRAINT m_pkey PRIMARY KEY (rowid ASC),
     INDEX m_expr_idx (array_cat(m, ARRAY[‹×›:::STRING, ‹×›, ‹×›:::STRING]:::STRING[]) ASC)
   )

statement ok
CREATE TABLE no (n NUMERIC PRIMARY KEY, o FLOAT, UNIQUE INDEX ((o / 1.1e7)), FAMILY (n, o))

query TT
SHOW CREATE TABLE no WITH REDACT
----
no  CREATE TABLE public.no (
      n DECIMAL NOT NULL,
      o FLOAT8 NULL,
      CONSTRAINT no_pkey PRIMARY KEY (n ASC),
      UNIQUE INDEX no_expr_key ((o / ‹×›:::FLOAT8) ASC),
      FAMILY fam_0_n_o (n, o)
    )

# Test that constants in partial indexes are redacted.

statement ok
CREATE TABLE p (p UUID PRIMARY KEY, INDEX (p) WHERE p != 'acde070d-8c4c-4f0d-9d8a-162843c10333')

query TT
SHOW CREATE TABLE p WITH REDACT
----
p  CREATE TABLE public.p (
     p UUID NOT NULL,
     CONSTRAINT p_pkey PRIMARY KEY (p ASC),
     INDEX p_p_idx (p ASC) WHERE p != ‹×›:::UUID
   )

# Test that constants in views are redacted.

statement ok
CREATE VIEW q (q) AS SELECT 0

query TT
SHOW CREATE VIEW q WITH REDACT
----
q  CREATE VIEW public.q (
     q
   ) AS SELECT ‹×›

statement ok
CREATE VIEW r (r) AS SELECT TIMESTAMP '1999-12-31 23:59:59' + i FROM hi WHERE h != '00:00:01'

query TT
SHOW CREATE VIEW r WITH REDACT
----
r  CREATE VIEW public.r (
     r
   ) AS SELECT TIMESTAMP ‹×› + i FROM test.public.hi WHERE h != ‹×›

statement ok
CREATE VIEW s (s) AS SELECT IF(b, 'abc', 'def') FROM b ORDER BY b AND NOT false LIMIT 10

query TT
SHOW CREATE VIEW s WITH REDACT
----
s  CREATE VIEW public.s (
     s
   ) AS SELECT
       IF(b, ‹×›, ‹×›)
     FROM
       test.public.b
     ORDER BY
       b AND (NOT ‹×›)
     LIMIT
       ‹×›

statement ok
CREATE VIEW t (t, u) AS SELECT jk || '[null]', j->a FROM a JOIN jk ON a = k || 'u' ORDER BY concat(a, 'ut')

query TT
SHOW CREATE VIEW t WITH REDACT
----
t  CREATE VIEW public.t (
     t,
     u
   ) AS SELECT
       jk || ‹×›, j->a
     FROM
       test.public.a JOIN test.public.jk ON a = (k || ‹×›)
     ORDER BY
       concat(a, ‹×›)
