# LogicTest: local-opt

statement ok
CREATE TABLE kv2 (
  k CHAR PRIMARY KEY,
  v CHAR,
  UNIQUE INDEX a (v),
  FAMILY (k),
  FAMILY (v)
)

statement count 4
INSERT INTO kv2 VALUES ('a', 'b'), ('c', 'd'), ('e', 'f'), ('f', 'g')

statement ok
SET tracing = on,kv,results; SELECT * FROM kv2; SET tracing = off

query T
SELECT message FROM [SHOW KV TRACE FOR SESSION]
 WHERE message LIKE 'fetched:%' OR message LIKE 'output row%'
----
fetched: /kv2/primary/'a' -> NULL
fetched: /kv2/primary/'a'/v -> 'b'
output row: ['a' 'b']
fetched: /kv2/primary/'c' -> NULL
fetched: /kv2/primary/'c'/v -> 'd'
output row: ['c' 'd']
fetched: /kv2/primary/'e' -> NULL
fetched: /kv2/primary/'e'/v -> 'f'
output row: ['e' 'f']
fetched: /kv2/primary/'f' -> NULL
fetched: /kv2/primary/'f'/v -> 'g'
output row: ['f' 'g']

statement ok
SET tracing = on,kv,results; SELECT * FROM kv2@a; SET tracing = off

query T
SELECT message FROM [SHOW KV TRACE FOR SESSION]
 WHERE message LIKE 'fetched:%' OR message LIKE 'output row%'
----
fetched: /kv2/a/'b' -> /'a'
output row: ['a' 'b']
fetched: /kv2/a/'d' -> /'c'
output row: ['c' 'd']
fetched: /kv2/a/'f' -> /'e'
output row: ['e' 'f']
fetched: /kv2/a/'g' -> /'f'
output row: ['f' 'g']

statement error duplicate key value \(v\)=\('g'\) violates unique constraint "a"
UPDATE kv2 SET v = 'g' WHERE k IN ('a')

statement ok
SET tracing = on,kv,results; SELECT * FROM kv2; SET tracing = off

query T
SELECT message FROM [SHOW KV TRACE FOR SESSION]
 WHERE message LIKE 'fetched:%' OR message LIKE 'output row%'
----
fetched: /kv2/primary/'a' -> NULL
fetched: /kv2/primary/'a'/v -> 'b'
output row: ['a' 'b']
fetched: /kv2/primary/'c' -> NULL
fetched: /kv2/primary/'c'/v -> 'd'
output row: ['c' 'd']
fetched: /kv2/primary/'e' -> NULL
fetched: /kv2/primary/'e'/v -> 'f'
output row: ['e' 'f']
fetched: /kv2/primary/'f' -> NULL
fetched: /kv2/primary/'f'/v -> 'g'
output row: ['f' 'g']

statement ok
SET tracing = on,kv,results; SELECT * FROM kv2@a; SET tracing = off

query T
SELECT message FROM [SHOW KV TRACE FOR SESSION]
 WHERE message LIKE 'fetched:%' OR message LIKE 'output row%'
----
fetched: /kv2/a/'b' -> /'a'
output row: ['a' 'b']
fetched: /kv2/a/'d' -> /'c'
output row: ['c' 'd']
fetched: /kv2/a/'f' -> /'e'
output row: ['e' 'f']
fetched: /kv2/a/'g' -> /'f'
output row: ['f' 'g']

statement ok
CREATE TABLE xyz (
  x INT PRIMARY KEY,
  y INT,
  z INT
)

query TTT
EXPLAIN UPDATE xyz SET y = x
----
count                ·         ·
 └── update          ·         ·
      │              table     xyz
      │              set       y
      │              strategy  updater
      └── render     ·         ·
           └── scan  ·         ·
·                    table     xyz@primary
·                    spans     ALL

query TTTTT
EXPLAIN (VERBOSE) UPDATE xyz SET (x, y) = (1, 2)
----
count                ·         ·            ()                           ·
 └── update          ·         ·            ()                           ·
      │              table     xyz          ·                            ·
      │              set       x, y         ·                            ·
      │              strategy  updater      ·                            ·
      └── render     ·         ·            (x, y, z, column7, column8)  ·
           │         render 0  x            ·                            ·
           │         render 1  y            ·                            ·
           │         render 2  z            ·                            ·
           │         render 3  1            ·                            ·
           │         render 4  2            ·                            ·
           └── scan  ·         ·            (x, y, z)                    ·
·                    table     xyz@primary  ·                            ·
·                    spans     ALL          ·                            ·

query TTTTT
EXPLAIN (VERBOSE) UPDATE xyz SET (x, y) = (y, x)
----
count                ·         ·            ()               ·
 └── update          ·         ·            ()               ·
      │              table     xyz          ·                ·
      │              set       x, y         ·                ·
      │              strategy  updater      ·                ·
      └── render     ·         ·            (x, y, z, y, x)  ·
           │         render 0  x            ·                ·
           │         render 1  y            ·                ·
           │         render 2  z            ·                ·
           │         render 3  y            ·                ·
           │         render 4  x            ·                ·
           └── scan  ·         ·            (x, y, z)        ·
·                    table     xyz@primary  ·                ·
·                    spans     ALL          ·                ·

query TTTTT
EXPLAIN (VERBOSE) UPDATE xyz SET (x, y) = (2, 2)
----
count                     ·         ·            ()                           ·
 └── update               ·         ·            ()                           ·
      │                   table     xyz          ·                            ·
      │                   set       x, y         ·                            ·
      │                   strategy  updater      ·                            ·
      └── render          ·         ·            (x, y, z, column7, column7)  ·
           │              render 0  x            ·                            ·
           │              render 1  y            ·                            ·
           │              render 2  z            ·                            ·
           │              render 3  column7      ·                            ·
           │              render 4  column7      ·                            ·
           └── render     ·         ·            (column7, x, y, z)           ·
                │         render 0  2            ·                            ·
                │         render 1  x            ·                            ·
                │         render 2  y            ·                            ·
                │         render 3  z            ·                            ·
                └── scan  ·         ·            (x, y, z)                    ·
·                         table     xyz@primary  ·                            ·
·                         spans     ALL          ·                            ·

statement ok
CREATE TABLE pks (
  k1 INT,
  k2 INT,
  v INT,
  PRIMARY KEY (k1, k2),
  UNIQUE INDEX i (k2, v),
  FAMILY (k1, k2),
  FAMILY (v)
)

statement count 2
INSERT INTO pks VALUES (1, 2, 3), (4, 5, 3)

statement error duplicate key value \(k2,v\)=\(5,3\) violates unique constraint "i"
UPDATE pks SET k2 = 5 where k1 = 1

# Test updating only one of the columns of a multi-column primary key.

statement count 1
UPDATE pks SET k1 = 2 WHERE k1 = 1

statement ok
SET tracing = on,kv,results; SELECT * FROM pks WHERE k1 = 2; SET tracing = off

query T
SELECT message FROM [SHOW KV TRACE FOR SESSION]
 WHERE message LIKE 'fetched:%' OR message LIKE 'output row%'
----
fetched: /pks/primary/2/2 -> NULL
fetched: /pks/primary/2/2/v -> 3
output row: [2 2 3]

# Check that UPDATE properly supports ORDER BY (MySQL extension)

statement ok
CREATE TABLE kv (
  k INT PRIMARY KEY,
  v INT
)

query TTT
EXPLAIN UPDATE kv SET v = v + 1 ORDER BY v DESC LIMIT 10
----
count                          ·         ·
 └── update                    ·         ·
      │                        table     kv
      │                        set       v
      │                        strategy  updater
      └── render               ·         ·
           └── limit           ·         ·
                │              count     10
                └── sort       ·         ·
                     │         order     -v
                     └── scan  ·         ·
·                              table     kv@primary
·                              spans     ALL

# Use case for UPDATE ... ORDER BY: renumbering a PK without unique violation.
query TTT
EXPLAIN UPDATE kv SET v = v - 1 WHERE k < 3 LIMIT 1
----
count                ·         ·
 └── update          ·         ·
      │              table     kv
      │              set       v
      │              strategy  updater
      └── render     ·         ·
           └── scan  ·         ·
·                    table     kv@primary
·                    spans     -/2/#
·                    limit     1

# Check that updates on tables with multiple column families behave as
# they should.

statement ok
CREATE TABLE tu (a INT PRIMARY KEY, b INT, c INT, d INT, FAMILY (a), FAMILY (b), FAMILY (c,d));
  INSERT INTO tu VALUES (1, 2, 3, 4)

# Update single column family.
query TTT
SELECT tree, field, description FROM [
EXPLAIN (VERBOSE) UPDATE tu SET c=c+1
]
----
count                ·         ·
 └── update          ·         ·
      │              table     tu
      │              set       c
      │              strategy  updater
      └── render     ·         ·
           │         render 0  a
           │         render 1  c
           │         render 2  d
           │         render 3  c + 1
           └── scan  ·         ·
·                    table     tu@primary
·                    spans     ALL

statement ok
SET tracing = on,kv,results; UPDATE tu SET c=c+1; SET tracing = off

query T
SELECT message FROM [SHOW KV TRACE FOR SESSION]
 WHERE operation != 'dist sender send'
----
Scan /Table/57/{1-2}
fetched: /tu/primary/1 -> NULL
fetched: /tu/primary/1/b -> 2
fetched: /tu/primary/1/c/d -> /3/4
Put /Table/57/1/1/2/1 -> /TUPLE/3:3:Int/4/1:4:Int/4
fast path completed
rows affected: 1

statement ok
SET tracing = on,kv,results; UPDATE tu SET b = NULL, c = NULL, d = NULL; SET tracing = off

query T
SELECT message FROM [SHOW KV TRACE FOR SESSION]
 WHERE operation != 'dist sender send'
----
Scan /Table/57/{1-2}
fetched: /tu/primary/1 -> NULL
fetched: /tu/primary/1/b -> 2
fetched: /tu/primary/1/c/d -> /4/4
Del /Table/57/1/1/1/1
Del /Table/57/1/1/2/1
fast path completed
rows affected: 1

# Regression test for #35564: make sure we use the Update's input required
# ordering for the internal projection.

statement ok
CREATE TABLE abc (a INT, b INT, c INT, INDEX(c) STORING(a,b))

query TTTTT
EXPLAIN (VERBOSE) SELECT * FROM [ UPDATE abc SET a=c RETURNING a ] ORDER BY a
----
render                    ·         ·              (a)                       +a
 │                        render 0  a              ·                         ·
 └── run                  ·         ·              (a, b, c, rowid[hidden])  ·
      └── update          ·         ·              (a, b, c, rowid[hidden])  ·
           │              table     abc            ·                         ·
           │              set       a              ·                         ·
           │              strategy  updater        ·                         ·
           └── render     ·         ·              (a, b, c, rowid, c)       +c
                │         render 0  a              ·                         ·
                │         render 1  b              ·                         ·
                │         render 2  c              ·                         ·
                │         render 3  rowid          ·                         ·
                │         render 4  c              ·                         ·
                └── scan  ·         ·              (a, b, c, rowid[hidden])  +c
·                         table     abc@abc_c_idx  ·                         ·
·                         spans     ALL            ·                         ·

# ------------------------------------------------------------------------------
# Regression for #35364. This tests behavior that is different between the CBO
# and the HP. The CBO will (deliberately) round any input columns *before*
# evaluating any computed columns, as well as rounding the output.
# ------------------------------------------------------------------------------

statement ok
CREATE TABLE t35364(
    x DECIMAL(10,0) CHECK(round(x) = x) PRIMARY KEY,
    y DECIMAL(10,0) DEFAULT (1.5),
    z DECIMAL(10,0) AS (x+y+2.5) STORED CHECK(z >= 7)
)

query TTT
INSERT INTO t35364 (x) VALUES (1.5) RETURNING *
----
2  2  7

query TTT
UPDATE t35364 SET x=2.5 RETURNING *
----
3  2  8
