row2 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.18"
+	Version = "99.99.99"
 )

go/go.mod

@@ -61,7 +61,7 @@ require (
 	github.com/dolthub/dolt-mcp v0.2.2-0.20250917171427-13e4520d1c36
 	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.20251008205317-e24a6e840478
+	github.com/dolthub/go-mysql-server v0.20.1-0.20251013222508-e994e25d6bae
 	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.20251008205317-e24a6e840478 h1:9/iYF7y9cyD1TiEGMJIRo3VNlhNgtB2gNqlPPVATnr0=
-github.com/dolthub/go-mysql-server v0.20.1-0.20251008205317-e24a6e840478/go.mod h1:EeYR0apo+8j2Dyxmn2ghkPlirO2S5mT1xHBrA+Efys8=
+github.com/dolthub/go-mysql-server v0.20.1-0.20251013222508-e994e25d6bae h1:bvy3s+V5skuI3waIUnDgvN84qG0AUhoU+2AmNWZbXHo=
+github.com/dolthub/go-mysql-server v0.20.1-0.20251013222508-e994e25d6bae/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

@@ -16,6 +16,7 @@ package index
 
 import (
 	"context"
+	"github.com/dolthub/vitess/go/sqltypes"
 	"io"
 
 	"github.com/dolthub/go-mysql-server/sql"
@@ -119,6 +120,53 @@ 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] = sqltypes.MakeTrusted(typ, field)
+		}
+		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] = sqltypes.MakeTrusted(typ, field)
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return r, nil
+}
+
+func (p prollyIndexIter) IsRowIter2(ctx *sql.Context) bool {
+	return true
+}
+
 func (p prollyIndexIter) rowFromTuples(ctx context.Context, key, value val.Tuple, r sql.Row) (err error) {
 	keyDesc, valDesc := p.primary.Descriptors()
 
@@ -239,6 +287,40 @@ 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] = sqltypes.MakeTrusted(typ, field)
+	}
+
+	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] = sqltypes.MakeTrusted(typ, field)
+	}
+
+	return row, nil
+}
+
+func (p prollyCoveringIndexIter) IsRowIter2(ctx *sql.Context) bool {
+	return true
+}
+
 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,6 +383,9 @@ type prollyKeylessIndexIter struct {
 	ordMap    val.OrdinalMapping
 	valueDesc val.TupleDesc
 	sqlSch    sql.Schema
+
+	card uint64
+	curr sql.Row2
 }
 
 var _ sql.RowIter = prollyKeylessIndexIter{}
@@ -436,6 +521,52 @@ 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] = sqltypes.MakeTrusted(typ, field)
+		}
+	}
+
+	p.card--
+	return p.curr, nil
+}
+
+func (p prollyKeylessIndexIter) IsRowIter2(ctx *sql.Context) bool {
+	return true
+}
+
 func (p prollyKeylessIndexIter) Close(*sql.Context) error {
 	return nil
 }

go/libraries/doltcore/sqle/index/prolly_row_iter.go

@@ -16,6 +16,7 @@ package index
 
 import (
 	"github.com/dolthub/go-mysql-server/sql"
+	"github.com/dolthub/vitess/go/sqltypes"
 
 	"github.com/dolthub/dolt/go/libraries/doltcore/schema"
 	"github.com/dolthub/dolt/go/store/prolly"
@@ -191,6 +192,39 @@ func (it prollyRowIter) Next(ctx *sql.Context) (sql.Row, error) {
 	return row, nil
 }
 
+func (it prollyRowIter) Next2(ctx *sql.Context) (sql.Row2, error) {
+	key, value, err := it.iter.Next(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	row := make(sql.Row2, it.rowLen)
+	for i, idx := range it.keyProj {
+		outputIdx := it.ordProj[i]
+		typ := val.EncToType[it.keyDesc.Types[idx].Enc]
+		field, err := tree.GetField2(ctx, it.keyDesc, idx, key, it.ns)
+		if err != nil {
+			return nil, err
+		}
+		row[outputIdx] = sqltypes.MakeTrusted(typ, field)
+	}
+
+	for i, idx := range it.valProj {
+		outputIdx := it.ordProj[len(it.keyProj)+i]
+		typ := val.EncToType[it.valDesc.Types[idx].Enc]
+		field, err := tree.GetField2(ctx, it.valDesc, idx, value, it.ns)
+		if err != nil {
+			return nil, err
+		}
+		row[outputIdx] = sqltypes.MakeTrusted(typ, field)
+	}
+	return row, nil
+}
+
+func (it prollyRowIter) IsRowIter2(ctx *sql.Context) bool {
+	return true
+}
+
 func (it prollyRowIter) Close(ctx *sql.Context) error {
 	return nil
 }
@@ -202,6 +236,7 @@ type prollyKeylessIter struct {
 	valProj []int
 	ordProj []int
 	curr    sql.Row
+	curr2   sql.Row2
 	rowLen  int
 	card    uint64
 }
@@ -241,6 +276,33 @@ func (it *prollyKeylessIter) nextTuple(ctx *sql.Context) error {
 	return nil
 }
 
+func (it *prollyKeylessIter) Next2(ctx *sql.Context) (sql.Row2, error) {
+	if it.card == 0 {
+		_, value, err := it.iter.Next(ctx)
+		if err != nil {
+			return nil, err
+		}
+
+		it.card = val.ReadKeylessCardinality(value)
+		it.curr2 = make(sql.Row2, it.rowLen)
+		for i, idx := range it.valProj {
+			outputIdx := it.ordProj[i]
+			typ := val.EncToType[it.valDesc.Types[idx].Enc]
+			field, err := tree.GetField2(ctx, it.valDesc, idx, value, it.ns)
+			if err != nil {
+				return nil, err
+			}
+			it.curr2[outputIdx] = sqltypes.MakeTrusted(typ, field)
+		}
+	}
+	it.card--
+	return it.curr2, nil
+}
+
+func (it *prollyKeylessIter) IsRowIter2(ctx *sql.Context) bool {
+	return true
+}
+
 func (it *prollyKeylessIter) Close(ctx *sql.Context) error {
 	return nil
 }