# LogicTest: local

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
      └── 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, "?column?", "?column?")  "?column?"=CONST; "?column?"=CONST; x!=NULL; key(x)
           │         render 0  test.public.xyz.x  ·                                  ·
           │         render 1  test.public.xyz.y  ·                                  ·
           │         render 2  test.public.xyz.z  ·                                  ·
           │         render 3  1                  ·                                  ·
           │         render 4  2                  ·                                  ·
           └── scan  ·         ·                  (x, y, z)                          x!=NULL; key(x)
·                    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      ·          ·
      └── scan  ·         ·            (x, y, z)  x!=NULL; key(x)
·               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, "?column?")  "?column?"=CONST; x!=NULL; key(x)
           │         render 0  test.public.xyz.x  ·                      ·
           │         render 1  test.public.xyz.y  ·                      ·
           │         render 2  test.public.xyz.z  ·                      ·
           │         render 3  2                  ·                      ·
           └── scan  ·         ·                  (x, y, z)              x!=NULL; key(x)
·                    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
----
count                     ·         ·
 └── update               ·         ·
      │                   table     kv
      │                   set       v
      │                   strategy  updater
      └── render          ·         ·
           └── 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          ·         ·
           └── limit      ·         ·
                │         count     1
                └── 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)

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 -> /3/4
Del /Table/57/1/1/1/1
Del /Table/57/1/1/2/1
fast path completed
rows affected: 1

# Ensure that the scan for cross-range point updates are parallelized.
statement ok
CREATE TABLE a (a INT PRIMARY KEY, b INT)

query TTT
EXPLAIN UPDATE a SET b = 10 WHERE a IN (10, 20)
----
count                ·         ·
 └── update          ·         ·
      │              table     a
      │              set       b
      │              strategy  updater
      └── render     ·         ·
           └── scan  ·         ·
·                    table     a@primary
·                    spans     /10-/10/# /20-/20/#
·                    parallel  ·

statement ok
ALTER TABLE a SPLIT AT VALUES(5)

# Run a select to prime the range cache to simplify the trace below.
statement ok
SELECT * FROM a

# Make sure that the scan for the update actually gets parallelized.
statement ok
SET tracing = on; UPDATE a SET b=10 WHERE a = 0 OR a = 10; SET tracing = off

# The span "sending partial batch" means that the scan was parallelized.
# If this test is failing and doesn't have that span, it means that the scanNode
# was improperly configured to add a limit to the ScanRequest batch.
# See #30943 for more details.
query T
SELECT message FROM [SHOW TRACE FOR SESSION] WHERE message IN
    ('querying next range at /Table/58/1/0',
     'querying next range at /Table/58/1/10',
     '=== SPAN START: kv.DistSender: sending partial batch ==='
    )
----
querying next range at /Table/58/1/0
=== SPAN START: kv.DistSender: sending partial batch ===
querying next range at /Table/58/1/10
