RowFrame test

.github/scripts/sql-correctness/current_correctness.txt

@@ -1 +1 @@
-100
+99.806921

go/cmd/dolt/doltversion/version.go

@@ -15,5 +15,5 @@
 package doltversion
 
 const (
-	Version = "1.59.20"
+	Version = "99.99.99"
 )

go/go.mod

@@ -61,7 +61,7 @@ require (
 	github.com/dolthub/dolt-mcp v0.2.2
 	github.com/dolthub/eventsapi_schema v0.0.0-20250915094920-eadfd39051ca
 	github.com/dolthub/flatbuffers/v23 v23.3.3-dh.2
-	github.com/dolthub/go-mysql-server v0.20.1-0.20251014182637-bbd06591d968
+	github.com/dolthub/go-mysql-server v0.20.1-0.20251015225635-aaa30654d7ac
 	github.com/dolthub/gozstd v0.0.0-20240423170813-23a2903bca63
 	github.com/edsrzf/mmap-go v1.2.0
 	github.com/esote/minmaxheap v1.0.0

go/go.sum

@@ -213,8 +213,8 @@ github.com/dolthub/fslock v0.0.3 h1:iLMpUIvJKMKm92+N1fmHVdxJP5NdyDK5bK7z7Ba2s2U=
 github.com/dolthub/fslock v0.0.3/go.mod h1:QWql+P17oAAMLnL4HGB5tiovtDuAjdDTPbuqx7bYfa0=
 github.com/dolthub/go-icu-regex v0.0.0-20250916051405-78a38d478790 h1:zxMsH7RLiG+dlZ/y0LgJHTV26XoiSJcuWq+em6t6VVc=
 github.com/dolthub/go-icu-regex v0.0.0-20250916051405-78a38d478790/go.mod h1:F3cnm+vMRK1HaU6+rNqQrOCyR03HHhR1GWG2gnPOqaE=
-github.com/dolthub/go-mysql-server v0.20.1-0.20251014182637-bbd06591d968 h1:NsdiQwKCjnzSZfOBQc0eKU3diZTyEdPY1NY5mrUdYmo=
-github.com/dolthub/go-mysql-server v0.20.1-0.20251014182637-bbd06591d968/go.mod h1:EeYR0apo+8j2Dyxmn2ghkPlirO2S5mT1xHBrA+Efys8=
+github.com/dolthub/go-mysql-server v0.20.1-0.20251015225635-aaa30654d7ac h1:GUCPH6HVWVCv1m1haEeU8Gqt1CH+lROswat86GNKbno=
+github.com/dolthub/go-mysql-server v0.20.1-0.20251015225635-aaa30654d7ac/go.mod h1:EeYR0apo+8j2Dyxmn2ghkPlirO2S5mT1xHBrA+Efys8=
 github.com/dolthub/gozstd v0.0.0-20240423170813-23a2903bca63 h1:OAsXLAPL4du6tfbBgK0xXHZkOlos63RdKYS3Sgw/dfI=
 github.com/dolthub/gozstd v0.0.0-20240423170813-23a2903bca63/go.mod h1:lV7lUeuDhH5thVGDCKXbatwKy2KW80L4rMT46n+Y2/Q=
 github.com/dolthub/ishell v0.0.0-20240701202509-2b217167d718 h1:lT7hE5k+0nkBdj/1UOSFwjWpNxf+LCApbRHgnCA17XE=

go/libraries/doltcore/sqle/enginetest/dolt_engine_test.go

@@ -113,53 +113,18 @@ func TestSchemaOverridesWithAdaptiveEncoding(t *testing.T) {
 
 // Convenience test for debugging a single query. Unskip and set to the desired query.
 func TestSingleScript(t *testing.T) {
-	t.Skip()
+	//t.Skip()
 	var scripts = []queries.ScriptTest{
 		{
 			Name: "Database syntax properly handles inter-CALL communication",
 			SetUpScript: []string{
-				`CREATE PROCEDURE p1()
-BEGIN
-	DECLARE str VARCHAR(20);
-   CALL p2(str);
-	SET str = CONCAT('a', str);
-   SELECT str;
-END`,
-				`CREATE PROCEDURE p2(OUT param VARCHAR(20))
-BEGIN
-	SET param = 'b';
-END`,
-				"CALL DOLT_ADD('-A');",
-				"CALL DOLT_COMMIT('-m', 'First procedures');",
-				"CALL DOLT_BRANCH('p12');",
-				"DROP PROCEDURE p1;",
-				"DROP PROCEDURE p2;",
-				`CREATE PROCEDURE p1()
-BEGIN
-	DECLARE str VARCHAR(20);
-    CALL p2(str);
-	SET str = CONCAT('c', str);
-   SELECT str;
-END`,
-				`CREATE PROCEDURE p2(OUT param VARCHAR(20))
-BEGIN
-	SET param = 'd';
-END`,
-				"CALL DOLT_ADD('-A');",
-				"CALL DOLT_COMMIT('-m', 'Second procedures');",
+				"create table t (i int primary key, j int);",
+				"insert into t values (1, 1), (2, 2), (3, 3), (4, 4), (5, 5);",
 			},
 			Assertions: []queries.ScriptTestAssertion{
 				{
-					Query:    "CALL p1();",
-					Expected: []sql.Row{{"cd"}},
-				},
-				{
-					Query:    "CALL `mydb/main`.p1();",
-					Expected: []sql.Row{{"cd"}},
-				},
-				{
-					Query:    "CALL `mydb/p12`.p1();",
-					Expected: []sql.Row{{"ab"}},
+					Query:    "select * from t where j > 2;",
+					Expected: []sql.Row{},
 				},
 			},
 		},

go/libraries/doltcore/sqle/index/prolly_index_iter.go

@@ -49,6 +49,8 @@ type prollyIndexIter struct {
 }
 
 var _ sql.RowIter = prollyIndexIter{}
+var _ sql.RowIter2 = prollyIndexIter{}
+var _ sql.RowFrameIter = prollyIndexIter{}
 
 // NewProllyIndexIter returns a new prollyIndexIter.
 func newProllyIndexIter(
@@ -119,6 +121,68 @@ func (p prollyIndexIter) Next(ctx *sql.Context) (sql.Row, error) {
 	return r, nil
 }
 
+func (p prollyIndexIter) Next2(ctx *sql.Context) (sql.Row2, error) {
+	idxKey, _, err := p.indexIter.Next(ctx)
+	if err != nil {
+		return nil, err
+	}
+	for to := range p.pkMap {
+		from := p.pkMap.MapOrdinal(to)
+		p.pkBld.PutRaw(to, idxKey.GetField(from))
+	}
+	pk, err := p.pkBld.Build(sharePool)
+	if err != nil {
+		return nil, err
+	}
+
+	r := make(sql.Row2, len(p.projections))
+	err = p.primary.Get(ctx, pk, func(key, value val.Tuple) error {
+		keyDesc, valDesc := p.primary.Descriptors()
+		for i, idx := range p.keyMap {
+			outputIdx := p.ordMap[i]
+			typ := val.EncToType[keyDesc.Types[idx].Enc]
+			field, err := tree.GetField2(ctx, keyDesc, idx, key, p.primary.NodeStore())
+			if err != nil {
+				return err
+			}
+			r[outputIdx] = sql.Value{
+				Val: field,
+				Typ: typ,
+			}
+		}
+		for i, idx := range p.valMap {
+			outputIdx := p.ordMap[len(p.keyMap)+i]
+			typ := val.EncToType[valDesc.Types[idx].Enc]
+			field, err := tree.GetField2(ctx, valDesc, idx, value, p.primary.NodeStore())
+			if err != nil {
+				return err
+			}
+			r[outputIdx] = sql.Value{
+				Val: field,
+				Typ: typ,
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return r, nil
+}
+
+func (p prollyIndexIter) IsRowIter2(ctx *sql.Context) bool {
+	return true
+}
+
+func (p prollyIndexIter) NextRowFrame(ctx *sql.Context, rowFrame *sql.RowFrame) error {
+	row, err := p.Next2(ctx)
+	if err != nil {
+		return err
+	}
+	rowFrame.Append(row...)
+	return nil
+}
+
 func (p prollyIndexIter) rowFromTuples(ctx context.Context, key, value val.Tuple, r sql.Row) (err error) {
 	keyDesc, valDesc := p.primary.Descriptors()
 
@@ -184,6 +248,8 @@ type prollyCoveringIndexIter struct {
 }
 
 var _ sql.RowIter = prollyCoveringIndexIter{}
+var _ sql.RowIter2 = prollyCoveringIndexIter{}
+var _ sql.RowFrameIter = prollyCoveringIndexIter{}
 
 func newProllyCoveringIndexIter(
 	ctx *sql.Context,
@@ -239,6 +305,55 @@ func (p prollyCoveringIndexIter) Next(ctx *sql.Context) (sql.Row, error) {
 	return r, nil
 }
 
+func (p prollyCoveringIndexIter) Next2(ctx *sql.Context) (sql.Row2, error) {
+	k, v, err := p.indexIter.Next(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	row := make(sql.Row2, len(p.projections))
+	for i, idx := range p.keyMap {
+		outputIdx := p.ordMap[i]
+		typ := val.EncToType[p.keyDesc.Types[idx].Enc]
+		field, err := tree.GetField2(ctx, p.keyDesc, idx, k, p.ns)
+		if err != nil {
+			return nil, err
+		}
+		row[outputIdx] = sql.Value{
+			Val: field,
+			Typ: typ,
+		}
+	}
+
+	for i, idx := range p.valMap {
+		outputIdx := p.ordMap[len(p.keyMap)+i]
+		typ := val.EncToType[p.valDesc.Types[idx].Enc]
+		field, err := tree.GetField2(ctx, p.valDesc, idx, v, p.ns)
+		if err != nil {
+			return nil, err
+		}
+		row[outputIdx] = sql.Value{
+			Val: field,
+			Typ: typ,
+		}
+	}
+
+	return row, nil
+}
+
+func (p prollyCoveringIndexIter) IsRowIter2(ctx *sql.Context) bool {
+	return true
+}
+
+func (p prollyCoveringIndexIter) NextRowFrame(ctx *sql.Context, rowFrame *sql.RowFrame) error {
+	row, err := p.Next2(ctx)
+	if err != nil {
+		return err
+	}
+	rowFrame.Append(row...)
+	return nil
+}
+
 func (p prollyCoveringIndexIter) writeRowFromTuples(ctx context.Context, key, value val.Tuple, r sql.Row) (err error) {
 	for i, idx := range p.keyMap {
 		outputIdx := p.ordMap[i]
@@ -301,9 +416,14 @@ type prollyKeylessIndexIter struct {
 	ordMap    val.OrdinalMapping
 	valueDesc val.TupleDesc
 	sqlSch    sql.Schema
+
+	card uint64
+	curr sql.Row2
 }
 
 var _ sql.RowIter = prollyKeylessIndexIter{}
+var _ sql.RowIter2 = prollyKeylessIndexIter{}
+var _ sql.RowFrameIter = prollyKeylessIndexIter{}
 
 func newProllyKeylessIndexIter(ctx *sql.Context, idx DoltIndex, rng prolly.Range, doltgresRange *DoltgresRange, pkSch sql.PrimaryKeySchema, projections []uint64, rows, dsecondary durable.Index, reverse bool) (prollyKeylessIndexIter, error) {
 	secondary, err := durable.ProllyMapFromIndex(dsecondary)
@@ -436,6 +556,64 @@ func (p prollyKeylessIndexIter) keylessRowsFromValueTuple(ctx context.Context, n
 	return
 }
 
+func (p prollyKeylessIndexIter) Next2(ctx *sql.Context) (sql.Row2, error) {
+	if p.card == 0 {
+		idxKey, _, err := p.indexIter.Next(ctx)
+		if err != nil {
+			return nil, err
+		}
+		for to := range p.clusteredMap {
+			from := p.clusteredMap.MapOrdinal(to)
+			p.clusteredBld.PutRaw(to, idxKey.GetField(from))
+		}
+		pk, err := p.clusteredBld.Build(sharePool)
+		if err != nil {
+			return nil, err
+		}
+
+		var value val.Tuple
+		err = p.clustered.Get(ctx, pk, func(k, v val.Tuple) error {
+			value = v
+			return nil
+		})
+		if err != nil {
+			return nil, err
+		}
+
+		p.card = val.ReadKeylessCardinality(value)
+		ns := p.clustered.NodeStore()
+		p.curr = make(sql.Row2, len(p.valueMap))
+		for i, idx := range p.valueMap {
+			outputIdx := p.ordMap[i]
+			typ := val.EncToType[p.valueDesc.Types[idx].Enc]
+			field, err := tree.GetField2(ctx, p.valueDesc, idx, value, ns)
+			if err != nil {
+				return nil, err
+			}
+			p.curr[outputIdx] = sql.Value{
+				Val: field,
+				Typ: typ,
+			}
+		}
+	}
+
+	p.card--
+	return p.curr, nil
+}
+
+func (p prollyKeylessIndexIter) IsRowIter2(ctx *sql.Context) bool {
+	return true
+}
+
+func (p prollyKeylessIndexIter) NextRowFrame(ctx *sql.Context, rowFrame *sql.RowFrame) error {
+	row, err := p.Next2(ctx)
+	if err != nil {
+		return err
+	}
+	rowFrame.Append(row...)
+	return nil
+}
+
 func (p prollyKeylessIndexIter) Close(*sql.Context) error {
 	return nil
 }