# LogicTest: local

statement ok
CREATE TABLE abc (a int primary key, b int, c int)

# Updating using self join.
query T
EXPLAIN UPDATE abc SET b = other.b + 1, c = other.c + 1 FROM abc AS other WHERE abc.a = other.a
----
distribution: local
vectorized: true
·
• update
│ table: abc
│ set: b, c
│ auto commit
│
└── • render
    │
    └── • render
        │
        └── • scan
              missing stats
              table: abc@abc_pkey
              spans: FULL SCAN
              locking strength: for update

# Update from another table.
statement ok
CREATE TABLE new_abc (a int, b int, c int)

query T
EXPLAIN UPDATE abc SET b = other.b, c = other.c FROM new_abc AS other WHERE abc.a = other.a
----
distribution: local
vectorized: true
·
• update
│ table: abc
│ set: b, c
│ auto commit
│
└── • distinct
    │ distinct on: a
    │
    └── • lookup join
        │ table: abc@abc_pkey
        │ equality: (a) = (a)
        │ equality cols are key
        │
        └── • scan
              missing stats
              table: new_abc@new_abc_pkey
              spans: FULL SCAN

# Returning old values.
query T
EXPLAIN UPDATE abc
SET
  b = old.b + 1, c = old.c + 2
FROM
  abc AS old
WHERE
  abc.a = old.a
RETURNING
  abc.a, abc.b AS new_b, old.b as old_b, abc.c as new_c, old.c as old_c
----
distribution: local
vectorized: true
·
• update
│ table: abc
│ set: b, c
│ auto commit
│
└── • render
    │
    └── • render
        │
        └── • scan
              missing stats
              table: abc@abc_pkey
              spans: FULL SCAN
              locking strength: for update

# Check if RETURNING * returns everything
query T
EXPLAIN (VERBOSE) UPDATE abc SET b = old.b + 1, c = old.c + 2 FROM abc AS old WHERE abc.a = old.a RETURNING *
----
distribution: local
vectorized: true
·
• update
│ columns: (a, b, c, a, b, c)
│ estimated row count: 1,000 (missing stats)
│ table: abc
│ set: b, c
│ auto commit
│
└── • render
    │ columns: (a, b, c, b_new, c_new, a, b, c)
    │ render b_new: b + 1
    │ render c_new: c + 2
    │ render a: a
    │ render b: b
    │ render c: c
    │ render a: a
    │ render b: b
    │ render c: c
    │
    └── • render
        │ columns: (a, b, c, a, b, c)
        │ render a: a
        │ render b: b
        │ render c: c
        │ render a: a
        │ render b: b
        │ render c: c
        │
        └── • scan
              columns: (a, b, c)
              estimated row count: 1,000 (missing stats)
              table: abc@abc_pkey
              spans: FULL SCAN
              locking strength: for update

# Update values of table from values expression
query T
EXPLAIN UPDATE abc SET b = other.b, c = other.c FROM (values (1, 2, 3), (2, 3, 4)) as other ("a", "b", "c") WHERE abc.a = other.a
----
distribution: local
vectorized: true
·
• update
│ table: abc
│ set: b, c
│ auto commit
│
└── • distinct
    │ distinct on: a
    │
    └── • lookup join
        │ table: abc@abc_pkey
        │ equality: (column1) = (a)
        │ equality cols are key
        │
        └── • values
              size: 3 columns, 2 rows

# Check if UPDATE ... FROM works with multiple tables.
statement ok
CREATE TABLE ab (a INT, b INT)

statement ok
CREATE TABLE ac (a INT, c INT)

query T
EXPLAIN UPDATE abc SET b = ab.b, c = ac.c FROM ab, ac WHERE abc.a = ab.a AND abc.a = ac.a
----
distribution: local
vectorized: true
·
• update
│ table: abc
│ set: b, c
│ auto commit
│
└── • distinct
    │ distinct on: a
    │
    └── • hash join
        │ equality: (a) = (a)
        │
        ├── • scan
        │     missing stats
        │     table: ab@ab_pkey
        │     spans: FULL SCAN
        │
        └── • lookup join
            │ table: abc@abc_pkey
            │ equality: (a) = (a)
            │ equality cols are key
            │
            └── • scan
                  missing stats
                  table: ac@ac_pkey
                  spans: FULL SCAN

# Make sure UPDATE ... FROM works with LATERAL.
query T
EXPLAIN UPDATE abc
SET
  b=ab.b, c = other.c
FROM
  ab, LATERAL
    (SELECT * FROM ac WHERE ab.a=ac.a) AS other
WHERE
  abc.a=ab.a
RETURNING
  *
----
distribution: local
vectorized: true
·
• update
│ table: abc
│ set: b, c
│ auto commit
│
└── • distinct
    │ distinct on: a
    │
    └── • hash join
        │ equality: (a) = (a)
        │
        ├── • scan
        │     missing stats
        │     table: ab@ab_pkey
        │     spans: FULL SCAN
        │
        └── • lookup join
            │ table: abc@abc_pkey
            │ equality: (a) = (a)
            │ equality cols are key
            │
            └── • scan
                  missing stats
                  table: ac@ac_pkey
                  spans: FULL SCAN
