Bug#34852090: Incorrect result with VALUES in a correlated LATERAL subquery

Bug#35087820: VALUES Statement with dependent subquery is wrong

When a table value constructor has to be read multiple times during a
query, it will only return data the first time it is read. When it's
read the second time, it will return EOF immediately.

It is caused by a bug in TableValueConstructorIterator::Read() where
it returns EOF immediately when the number of examined rows is equal
to the number of rows in the table value constructor. Since this
counter is intentionally not reset when the iterator is
re-initialized, the table value constructor will keep returning EOF
forever once every row has been read, and not start again from the
beginning when it's re-initialized.

Fixed by checking the position of the iterator over the row value list
instead of the number of examined rows.

Change-Id: I0e828eb0de0360a16cea9f77b578c68205cefbaf
(cherry picked from commit 7dc427011ed66613edf61dd144867b8728918dcb)

Author: kahatlen

mysql-test/r/table_value_constructor.result

@@ -675,3 +675,30 @@ NULL
 5
 DROP VIEW v1;
 DROP TABLE t1;
+#
+# Bug#35087820: VALUES Statement with dependent subquery is wrong
+#
+CREATE TABLE t(
+id INTEGER PRIMARY KEY,
+a VARCHAR(4),
+b VARCHAR(4),
+c VARCHAR(3));
+INSERT INTO t VALUES (1, 'a1', 'b1', 'c1'), (2, 'a2', 'b2', 'c2');
+SELECT
+id,
+(SELECT MAX(col1) FROM (VALUES ROW(a), ROW(b), ROW(c)) AS x(col1)) AS max
+FROM t;
+id	max
+1	c1
+2	c2
+DROP TABLE t;
+#
+# Bug#34852090: Incorrect result with VALUES in
+#               a correlated LATERAL subquery
+#
+WITH v1(x) AS (VALUES ROW (1), ROW (2), ROW (3))
+SELECT * FROM v1, LATERAL (VALUES ROW(v1.x)) AS v2;
+x	column_0
+1	1
+2	2
+3	3

mysql-test/t/table_value_constructor.test

@@ -475,3 +475,30 @@ INSERT INTO v1 VALUES(5) AS c(a);
 SELECT * FROM v1;
 DROP VIEW v1;
 DROP TABLE t1;
+
+--echo #
+--echo # Bug#35087820: VALUES Statement with dependent subquery is wrong
+--echo #
+
+CREATE TABLE t(
+  id INTEGER PRIMARY KEY,
+  a VARCHAR(4),
+  b VARCHAR(4),
+  c VARCHAR(3));
+INSERT INTO t VALUES (1, 'a1', 'b1', 'c1'), (2, 'a2', 'b2', 'c2');
+
+--sorted_result
+SELECT
+  id,
+  (SELECT MAX(col1) FROM (VALUES ROW(a), ROW(b), ROW(c)) AS x(col1)) AS max
+FROM t;
+
+DROP TABLE t;
+
+--echo #
+--echo # Bug#34852090: Incorrect result with VALUES in
+--echo #               a correlated LATERAL subquery
+--echo #
+
+WITH v1(x) AS (VALUES ROW (1), ROW (2), ROW (3))
+SELECT * FROM v1, LATERAL (VALUES ROW(v1.x)) AS v2;

sql/iterators/ref_row_iterators.cc

@@ -917,7 +917,7 @@ bool TableValueConstructorIterator::Init() {
 }
 
 int TableValueConstructorIterator::Read() {
-  if (*m_examined_rows == m_row_value_list.size()) return -1;
+  if (m_row_it == m_row_value_list.end()) return -1;
 
   // If the TVC has a single row, we don't create Item_values_column reference
   // objects during resolving. We will instead use the single row directly from
@@ -935,9 +935,9 @@ int TableValueConstructorIterator::Read() {
       // Item_values_column object cannot be const.
       ref->set_value(const_cast<Item *>(value));
     }
-    ++m_row_it;
   }
 
+  ++m_row_it;
   ++*m_examined_rows;
   return 0;
 }