# LogicTest: local

statement ok
CREATE TABLE kv (
  k INT PRIMARY KEY,
  v INT,
  UNIQUE INDEX foo (v),
  INDEX bar (k, v)
)

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

statement ok
CREATE TABLE indexed (id int primary key, value int, other int, index (value))

statement count 4
INSERT INTO kv VALUES (1, 2), (3, 4), (5, 6), (7, 8)

statement count 2
DELETE FROM kv WHERE k=3 OR v=6

query II
DELETE FROM kv RETURNING k, v
----
1 2
7 8

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

query T
SELECT message FROM [SHOW KV TRACE FOR SESSION]
 WHERE message LIKE 'fetched:%' OR message LIKE 'output row%'
----

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

query T
SELECT message FROM [SHOW KV TRACE FOR SESSION]
 WHERE message LIKE 'fetched:%' OR message LIKE 'output row%'
----

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

query T
SELECT message FROM [SHOW KV TRACE FOR SESSION]
 WHERE message LIKE 'fetched:%' OR message LIKE 'output row%'
----

# Check that EXPLAIN does not destroy data (#6613)
query TTT colnames
EXPLAIN DELETE FROM unindexed
----
tree               field  description
count              ·      ·
 └── delete range  ·      ·
·                  from   unindexed
·                  spans  ALL

query TTT
EXPLAIN DELETE FROM unindexed WHERE v = 7 ORDER BY v
----
count                ·         ·
 └── delete          ·         ·
      │              from      unindexed
      │              strategy  deleter
      └── nosort     ·         ·
           │         order     +v
           └── scan  ·         ·
·                    table     unindexed@primary
·                    spans     ALL
·                    filter    v = 7

# Check DELETE with LIMIT clause (MySQL extension)
query TTT
EXPLAIN DELETE FROM unindexed WHERE v = 5 LIMIT 10
----
count                     ·         ·
 └── delete               ·         ·
      │                   from      unindexed
      │                   strategy  deleter
      └── limit           ·         ·
           │              count     10
           └── render     ·         ·
                └── scan  ·         ·
·                         table     unindexed@primary
·                         spans     ALL
·                         filter    v = 5

# Check fast DELETE.
query TTT
EXPLAIN DELETE FROM unindexed WHERE k > 0
----
count              ·      ·
 └── delete range  ·      ·
·                  from   unindexed
·                  spans  /1-


# Check fast DELETE with reverse scan (not supported by heuristic planner)
query TTT
EXPLAIN DELETE FROM unindexed WHERE k > 0 ORDER BY k DESC
----
count                   ·         ·
 └── delete             ·         ·
      │                 from      unindexed
      │                 strategy  deleter
      └── render        ·         ·
           └── revscan  ·         ·
·                       table     unindexed@primary
·                       spans     /1-

# Check that limits don't permit fast deletes.
query TTT
EXPLAIN DELETE FROM unindexed WHERE k > 0 LIMIT 1
----
count                     ·         ·
 └── delete               ·         ·
      │                   from      unindexed
      │                   strategy  deleter
      └── limit           ·         ·
           │              count     1
           └── render     ·         ·
                └── scan  ·         ·
·                         table     unindexed@primary
·                         spans     /1-
·                         limit     1

query TTT
EXPLAIN DELETE FROM indexed WHERE value = 5 LIMIT 10
----
count                     ·         ·
 └── delete               ·         ·
      │                   from      indexed
      │                   strategy  deleter
      └── limit           ·         ·
           │              count     10
           └── render     ·         ·
                └── scan  ·         ·
·                         table     indexed@indexed_value_idx
·                         spans     /5-/6
·                         limit     10

query TTT
EXPLAIN DELETE FROM indexed LIMIT 10
----
count                     ·         ·
 └── delete               ·         ·
      │                   from      indexed
      │                   strategy  deleter
      └── limit           ·         ·
           │              count     10
           └── render     ·         ·
                └── scan  ·         ·
·                         table     indexed@primary
·                         spans     ALL
·                         limit     10

query TTT
EXPLAIN DELETE FROM indexed WHERE value = 5 LIMIT 10 RETURNING id
----
render                          ·         ·
 └── run                        ·         ·
      └── delete                ·         ·
           │                    from      indexed
           │                    strategy  deleter
           └── limit            ·         ·
                │               count     10
                └── index-join  ·         ·
                     │          table     indexed@primary
                     └── scan   ·         ·
·                               table     indexed@indexed_value_idx
·                               spans     /5-/6
·                               limit     10

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

query TTT
EXPLAIN DELETE FROM a WHERE a IN (10, 20)
----
count           ·         ·
 └── delete     ·         ·
      │         from      a
      │         strategy  deleter
      └── 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; DELETE FROM a 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/56/1/0',
     'querying next range at /Table/56/1/10',
     '=== SPAN START: kv.DistSender: sending partial batch ==='
    )
----
querying next range at /Table/56/1/0
=== SPAN START: kv.DistSender: sending partial batch ===
querying next range at /Table/56/1/10
