exec-ddl
CREATE TABLE abcde (
    a INT NOT NULL,
    b INT,
    c INT NOT NULL DEFAULT (10),
    d INT AS (b + c + 1) STORED,
    "e:write-only" INT
)
----
TABLE abcde
 ├── a int not null
 ├── b int
 ├── c int not null
 ├── d int
 ├── rowid int not null (hidden)
 ├── e int (mutation)
 └── INDEX primary
      └── rowid int not null (hidden)

exec-ddl
CREATE TABLE xyz (
    x TEXT PRIMARY KEY,
    y INT8 NOT NULL,
    z FLOAT8
)
----
TABLE xyz
 ├── x string not null
 ├── y int not null
 ├── z float
 └── INDEX primary
      └── x string not null

# Properties with no RETURNING clause.
build
INSERT INTO abcde (a, b) SELECT y, y FROM xyz ORDER BY y, z LIMIT 10
----
insert abcde
 ├── columns: <none>
 ├── insert-mapping:
 │    ├──  y:8 => a:1
 │    ├──  y:8 => b:2
 │    ├──  column10:10 => c:3
 │    ├──  column13:13 => d:4
 │    ├──  column11:11 => rowid:5
 │    └──  column12:12 => e:6
 ├── cardinality: [0 - 0]
 ├── side-effects, mutations
 └── project
      ├── columns: column13:13(int) y:8(int!null) column10:10(int!null) column11:11(int) column12:12(int)
      ├── cardinality: [0 - 10]
      ├── side-effects
      ├── fd: ()-->(10,12), (8)-->(13)
      ├── prune: (8,10-13)
      ├── interesting orderings: (+8)
      ├── project
      │    ├── columns: column10:10(int!null) column11:11(int) column12:12(int) y:8(int!null)
      │    ├── cardinality: [0 - 10]
      │    ├── side-effects
      │    ├── fd: ()-->(10,12)
      │    ├── prune: (8,10-12)
      │    ├── interesting orderings: (+8)
      │    ├── limit
      │    │    ├── columns: y:8(int!null) z:9(float)
      │    │    ├── internal-ordering: +8,+9
      │    │    ├── cardinality: [0 - 10]
      │    │    ├── interesting orderings: (+8,+9)
      │    │    ├── sort
      │    │    │    ├── columns: y:8(int!null) z:9(float)
      │    │    │    ├── ordering: +8,+9
      │    │    │    ├── prune: (8,9)
      │    │    │    └── project
      │    │    │         ├── columns: y:8(int!null) z:9(float)
      │    │    │         ├── prune: (8,9)
      │    │    │         └── scan xyz
      │    │    │              ├── columns: x:7(string!null) y:8(int!null) z:9(float)
      │    │    │              ├── key: (7)
      │    │    │              ├── fd: (7)-->(8,9)
      │    │    │              ├── prune: (7-9)
      │    │    │              └── interesting orderings: (+7)
      │    │    └── const: 10 [type=int]
      │    └── projections
      │         ├── const: 10 [type=int]
      │         ├── function: unique_rowid [type=int, side-effects]
      │         └── cast: INT8 [type=int]
      │              └── null [type=unknown]
      └── projections
           └── plus [type=int, outer=(8,10)]
                ├── plus [type=int]
                │    ├── variable: y [type=int]
                │    └── variable: column10 [type=int]
                └── const: 1 [type=int]

# Properties with RETURNING clause.
build
INSERT INTO abcde (a, b) SELECT y, y FROM xyz ORDER BY y, z LIMIT 10 RETURNING *
----
project
 ├── columns: a:1(int!null) b:2(int!null) c:3(int!null) d:4(int)
 ├── cardinality: [0 - 10]
 ├── side-effects, mutations
 ├── fd: ()-->(3), (1)==(2), (2)==(1), (1)-->(4)
 ├── prune: (1-4)
 └── insert abcde
      ├── columns: a:1(int!null) b:2(int!null) c:3(int!null) d:4(int) rowid:5(int!null)
      ├── insert-mapping:
      │    ├──  y:8 => a:1
      │    ├──  y:8 => b:2
      │    ├──  column10:10 => c:3
      │    ├──  column13:13 => d:4
      │    ├──  column11:11 => rowid:5
      │    └──  column12:12 => e:6
      ├── cardinality: [0 - 10]
      ├── side-effects, mutations
      ├── fd: ()-->(3), (1)==(2), (2)==(1), (1)-->(4)
      └── project
           ├── columns: column13:13(int) y:8(int!null) column10:10(int!null) column11:11(int) column12:12(int)
           ├── cardinality: [0 - 10]
           ├── side-effects
           ├── fd: ()-->(10,12), (8)-->(13)
           ├── prune: (8,10-13)
           ├── interesting orderings: (+8)
           ├── project
           │    ├── columns: column10:10(int!null) column11:11(int) column12:12(int) y:8(int!null)
           │    ├── cardinality: [0 - 10]
           │    ├── side-effects
           │    ├── fd: ()-->(10,12)
           │    ├── prune: (8,10-12)
           │    ├── interesting orderings: (+8)
           │    ├── limit
           │    │    ├── columns: y:8(int!null) z:9(float)
           │    │    ├── internal-ordering: +8,+9
           │    │    ├── cardinality: [0 - 10]
           │    │    ├── interesting orderings: (+8,+9)
           │    │    ├── sort
           │    │    │    ├── columns: y:8(int!null) z:9(float)
           │    │    │    ├── ordering: +8,+9
           │    │    │    ├── prune: (8,9)
           │    │    │    └── project
           │    │    │         ├── columns: y:8(int!null) z:9(float)
           │    │    │         ├── prune: (8,9)
           │    │    │         └── scan xyz
           │    │    │              ├── columns: x:7(string!null) y:8(int!null) z:9(float)
           │    │    │              ├── key: (7)
           │    │    │              ├── fd: (7)-->(8,9)
           │    │    │              ├── prune: (7-9)
           │    │    │              └── interesting orderings: (+7)
           │    │    └── const: 10 [type=int]
           │    └── projections
           │         ├── const: 10 [type=int]
           │         ├── function: unique_rowid [type=int, side-effects]
           │         └── cast: INT8 [type=int]
           │              └── null [type=unknown]
           └── projections
                └── plus [type=int, outer=(8,10)]
                     ├── plus [type=int]
                     │    ├── variable: y [type=int]
                     │    └── variable: column10 [type=int]
                     └── const: 1 [type=int]

# Properties with RETURNING clause.
build
INSERT INTO abcde (a, b) SELECT y, y FROM xyz ORDER BY y, z RETURNING *
----
project
 ├── columns: a:1(int!null) b:2(int!null) c:3(int!null) d:4(int)
 ├── side-effects, mutations
 ├── fd: ()-->(3), (1)==(2), (2)==(1), (1)-->(4)
 ├── prune: (1-4)
 └── insert abcde
      ├── columns: a:1(int!null) b:2(int!null) c:3(int!null) d:4(int) rowid:5(int!null)
      ├── insert-mapping:
      │    ├──  y:8 => a:1
      │    ├──  y:8 => b:2
      │    ├──  column10:10 => c:3
      │    ├──  column13:13 => d:4
      │    ├──  column11:11 => rowid:5
      │    └──  column12:12 => e:6
      ├── side-effects, mutations
      ├── fd: ()-->(3), (1)==(2), (2)==(1), (1)-->(4)
      └── project
           ├── columns: column13:13(int) y:8(int!null) column10:10(int!null) column11:11(int) column12:12(int)
           ├── side-effects
           ├── fd: ()-->(10,12), (8)-->(13)
           ├── prune: (8,10-13)
           ├── project
           │    ├── columns: column10:10(int!null) column11:11(int) column12:12(int) y:8(int!null)
           │    ├── side-effects
           │    ├── fd: ()-->(10,12)
           │    ├── prune: (8,10-12)
           │    ├── project
           │    │    ├── columns: y:8(int!null) z:9(float)
           │    │    ├── prune: (8,9)
           │    │    └── scan xyz
           │    │         ├── columns: x:7(string!null) y:8(int!null) z:9(float)
           │    │         ├── key: (7)
           │    │         ├── fd: (7)-->(8,9)
           │    │         ├── prune: (7-9)
           │    │         └── interesting orderings: (+7)
           │    └── projections
           │         ├── const: 10 [type=int]
           │         ├── function: unique_rowid [type=int, side-effects]
           │         └── cast: INT8 [type=int]
           │              └── null [type=unknown]
           └── projections
                └── plus [type=int, outer=(8,10)]
                     ├── plus [type=int]
                     │    ├── variable: y [type=int]
                     │    └── variable: column10 [type=int]
                     └── const: 1 [type=int]

# Input is cardinality 1 VALUES expression.
build
INSERT INTO abcde (a, b) (VALUES (1, 2)) RETURNING *, rowid;
----
insert abcde
 ├── columns: a:1(int!null) b:2(int) c:3(int!null) d:4(int) rowid:5(int!null)
 ├── insert-mapping:
 │    ├──  column1:7 => a:1
 │    ├──  column2:8 => b:2
 │    ├──  column9:9 => c:3
 │    ├──  column12:12 => d:4
 │    ├──  column10:10 => rowid:5
 │    └──  column11:11 => e:6
 ├── cardinality: [1 - 1]
 ├── side-effects, mutations
 ├── key: ()
 ├── fd: ()-->(1-5)
 └── project
      ├── columns: column12:12(int) column1:7(int) column2:8(int) column9:9(int!null) column10:10(int) column11:11(int)
      ├── cardinality: [1 - 1]
      ├── side-effects
      ├── key: ()
      ├── fd: ()-->(7-12)
      ├── prune: (7-12)
      ├── project
      │    ├── columns: column9:9(int!null) column10:10(int) column11:11(int) column1:7(int) column2:8(int)
      │    ├── cardinality: [1 - 1]
      │    ├── side-effects
      │    ├── key: ()
      │    ├── fd: ()-->(7-11)
      │    ├── prune: (7-11)
      │    ├── values
      │    │    ├── columns: column1:7(int) column2:8(int)
      │    │    ├── cardinality: [1 - 1]
      │    │    ├── key: ()
      │    │    ├── fd: ()-->(7,8)
      │    │    ├── prune: (7,8)
      │    │    └── tuple [type=tuple{int, int}]
      │    │         ├── const: 1 [type=int]
      │    │         └── const: 2 [type=int]
      │    └── projections
      │         ├── const: 10 [type=int]
      │         ├── function: unique_rowid [type=int, side-effects]
      │         └── cast: INT8 [type=int]
      │              └── null [type=unknown]
      └── projections
           └── plus [type=int, outer=(8,9)]
                ├── plus [type=int]
                │    ├── variable: column2 [type=int]
                │    └── variable: column9 [type=int]
                └── const: 1 [type=int]

# Filter FD set.
build
INSERT INTO abcde (a, b) SELECT y, (z+1)::int FROM xyz WHERE y=1 RETURNING a, c;
----
project
 ├── columns: a:1(int!null) c:3(int!null)
 ├── side-effects, mutations
 ├── fd: ()-->(1,3)
 ├── prune: (1,3)
 └── insert abcde
      ├── columns: a:1(int!null) b:2(int) c:3(int!null) d:4(int) rowid:5(int!null)
      ├── insert-mapping:
      │    ├──  y:8 => a:1
      │    ├──  int8:10 => b:2
      │    ├──  column11:11 => c:3
      │    ├──  column14:14 => d:4
      │    ├──  column12:12 => rowid:5
      │    └──  column13:13 => e:6
      ├── side-effects, mutations
      ├── fd: ()-->(1,3), (2)-->(4)
      └── project
           ├── columns: column14:14(int) y:8(int!null) int8:10(int) column11:11(int!null) column12:12(int) column13:13(int)
           ├── side-effects
           ├── fd: ()-->(8,11,13), (10)-->(14)
           ├── prune: (8,10-14)
           ├── project
           │    ├── columns: column11:11(int!null) column12:12(int) column13:13(int) y:8(int!null) int8:10(int)
           │    ├── side-effects
           │    ├── fd: ()-->(8,11,13)
           │    ├── prune: (8,10-13)
           │    ├── project
           │    │    ├── columns: int8:10(int) y:8(int!null)
           │    │    ├── fd: ()-->(8)
           │    │    ├── prune: (8,10)
           │    │    ├── select
           │    │    │    ├── columns: x:7(string!null) y:8(int!null) z:9(float)
           │    │    │    ├── key: (7)
           │    │    │    ├── fd: ()-->(8), (7)-->(9)
           │    │    │    ├── prune: (7,9)
           │    │    │    ├── interesting orderings: (+7)
           │    │    │    ├── scan xyz
           │    │    │    │    ├── columns: x:7(string!null) y:8(int!null) z:9(float)
           │    │    │    │    ├── key: (7)
           │    │    │    │    ├── fd: (7)-->(8,9)
           │    │    │    │    ├── prune: (7-9)
           │    │    │    │    └── interesting orderings: (+7)
           │    │    │    └── filters
           │    │    │         └── eq [type=bool, outer=(8), constraints=(/8: [/1 - /1]; tight), fd=()-->(8)]
           │    │    │              ├── variable: y [type=int]
           │    │    │              └── const: 1 [type=int]
           │    │    └── projections
           │    │         └── cast: INT8 [type=int, outer=(9)]
           │    │              └── plus [type=float]
           │    │                   ├── variable: z [type=float]
           │    │                   └── const: 1.0 [type=float]
           │    └── projections
           │         ├── const: 10 [type=int]
           │         ├── function: unique_rowid [type=int, side-effects]
           │         └── cast: INT8 [type=int]
           │              └── null [type=unknown]
           └── projections
                └── plus [type=int, outer=(10,11)]
                     ├── plus [type=int]
                     │    ├── variable: int8 [type=int]
                     │    └── variable: column11 [type=int]
                     └── const: 1 [type=int]
