[auto-bump] [no-release-notes] dependency by angelamayxie

go/cmd/dolt/commands/cherry-pick.go

@@ -26,6 +26,7 @@ import (
 	"github.com/dolthub/dolt/go/cmd/dolt/errhand"
 	"github.com/dolthub/dolt/go/libraries/doltcore/branch_control"
 	"github.com/dolthub/dolt/go/libraries/doltcore/env"
+	"github.com/dolthub/dolt/go/libraries/doltcore/env/actions"
 	"github.com/dolthub/dolt/go/libraries/utils/argparser"
 	"github.com/dolthub/dolt/go/store/util/outputpager"
 	eventsapi "github.com/dolthub/eventsapi_schema/dolt/services/eventsapi/v1alpha1"
@@ -51,6 +52,12 @@ var ErrCherryPickConflictsOrViolations = errors.NewKind("error: Unable to apply
 	"To undo all changes from this cherry-pick operation, use `dolt cherry-pick --abort`.\n" +
 	"For more information on handling conflicts, see: https://docs.dolthub.com/concepts/dolt/git/conflicts")
 
+var ErrCherryPickVerificationFailed = errors.NewKind("error: Commit verification failed. Your changes are staged " +
+	"in the working set. Fix the failing tests, use `dolt add` to stage your changes, then " +
+	"`dolt cherry-pick --continue` to complete the cherry-pick.\n" +
+	"To undo all changes from this cherry-pick operation, use `dolt cherry-pick --abort`.\n" +
+	"Run `dolt sql -q 'select * from dolt_test_run()` to see which tests are failing.")
+
 type CherryPickCmd struct{}
 
 // Name returns the name of the Dolt cli command. This is what is used on the command line to invoke the command.
@@ -166,6 +173,10 @@ hint: commit your changes (dolt commit -am \"<message>\") or reset them (dolt re
 	}
 	rows, err := cli.GetRowsForSql(queryist, sqlCtx, q)
 	if err != nil {
+		if actions.ErrCommitVerificationFailed.Is(err) {
+			cli.PrintErrln(err.Error())
+			return ErrCherryPickVerificationFailed.New()
+		}
 		errorText := err.Error()
 		switch {
 		case strings.Contains("nothing to commit", errorText):
@@ -250,20 +261,27 @@ func cherryPickContinue(sqlCtx *sql.Context, queryist cli.Queryist) error {
 	query := "call dolt_cherry_pick('--continue')"
 	rows, err := cli.GetRowsForSql(queryist, sqlCtx, query)
 	if err != nil {
+		if actions.ErrCommitVerificationFailed.Is(err) {
+			cli.PrintErrln(err.Error())
+			return ErrCherryPickVerificationFailed.New()
+		}
 		return err
 	}
 
 	if len(rows) != 1 {
 		return fmt.Errorf("error: unexpected number of rows returned from dolt_cherry_pick: %d", len(rows))
 	}
-	if len(rows[0]) != 4 {
+
+	// No version of dolt_cherry_pick has ever returned less than 4 columns. We don't set an upper bound here to
+	// allow for servers to add more columns in the future without breaking compatibility with older clients.
+	if len(rows[0]) < 4 {
 		return fmt.Errorf("error: unexpected number of columns returned from dolt_cherry_pick: %d", len(rows[0]))
 	}
 
 	row := rows[0]
 
 	// We expect to get an error if there were problems, but we also could get any of the conflicts and
-	// vacation counts being greater than 0 if there were problems. If we got here without an error,
+	// violation counts being greater than 0 if there were problems. If we got here without an error,
 	// but we have conflicts or violations, we should report and stop.
 	dataConflicts, err := getInt64ColAsInt64(row[1])
 	if err != nil {

go/cmd/dolt/commands/merge.go

@@ -33,6 +33,7 @@ import (
 	"github.com/dolthub/dolt/go/libraries/doltcore/diff"
 	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
 	"github.com/dolthub/dolt/go/libraries/doltcore/env"
+	"github.com/dolthub/dolt/go/libraries/doltcore/env/actions"
 	"github.com/dolthub/dolt/go/libraries/doltcore/merge"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dprocedures"
 	"github.com/dolthub/dolt/go/libraries/utils/argparser"
@@ -165,6 +166,11 @@ func (cmd MergeCmd) Exec(ctx context.Context, commandStr string, args []string,
 		return 1
 	}
 
+	if msg := getMergeMessage(mergeResultRow); strings.HasPrefix(msg, actions.CommitVerificationFailedPrefix) {
+		cli.Println(msg)
+		return 1
+	}
+
 	if !apr.Contains(cli.AbortParam) {
 		//todo: refs with the `remotes/` prefix will fail to get a hash
 		headHash, headHashErr := getHashOf(queryist.Queryist, queryist.Context, "HEAD")
@@ -751,3 +757,17 @@ func everythingUpToDate(row sql.Row) (bool, error) {
 
 	return false, nil
 }
+
+// getMergeMessage extracts the message column from a merge result row.
+func getMergeMessage(row sql.Row) string {
+	if len(row) == 3 {
+		if msg, ok := row[2].(string); ok {
+			return msg
+		}
+	} else if len(row) == 4 {
+		if msg, ok := row[3].(string); ok {
+			return msg
+		}
+	}
+	return ""
+}

go/cmd/dolt/commands/rebase.go

@@ -28,6 +28,7 @@ import (
 	"github.com/dolthub/dolt/go/cmd/dolt/errhand"
 	"github.com/dolthub/dolt/go/libraries/doltcore/dconfig"
 	"github.com/dolthub/dolt/go/libraries/doltcore/env"
+	"github.com/dolthub/dolt/go/libraries/doltcore/env/actions"
 	"github.com/dolthub/dolt/go/libraries/doltcore/rebase"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dprocedures"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dsess"
@@ -429,7 +430,8 @@ func syncCliBranchToSqlSessionBranch(ctx *sql.Context, dEnv *env.DoltEnv) error
 }
 
 // isRebaseConflictError checks if the given error represents a rebase pause condition
-// (data conflicts) that should not abort the rebase but instead allow the user to resolve/continue.
+// (data conflicts or verification failure) that should not abort the rebase but instead
+// allow the user to resolve/continue.
 func isRebaseConflictError(err error) bool {
 	if err == nil {
 		return false
@@ -439,8 +441,16 @@ func isRebaseConflictError(err error) bool {
 	if dprocedures.ErrRebaseDataConflict.Is(err) {
 		return true
 	}
+	if dprocedures.ErrRebaseVerificationFailed.Is(err) {
+		return true
+	}
+	if actions.ErrCommitVerificationFailed.Is(err) {
+		return true
+	}
 
 	// For over-the-wire errors that lose their type, match against error message patterns
 	errMsg := err.Error()
-	return strings.HasPrefix(errMsg, dprocedures.RebaseDataConflictPrefix)
+	return strings.HasPrefix(errMsg, dprocedures.RebaseDataConflictPrefix) ||
+		strings.HasPrefix(errMsg, dprocedures.RebaseVerificationFailedPrefix) ||
+		strings.HasPrefix(errMsg, actions.CommitVerificationFailedPrefix)
 }

go/cmd/dolt/commands/remote_test.go

@@ -156,7 +156,7 @@ func TestRemoteAdd_StoresNormalizedGitUrl(t *testing.T) {
 	normalized, ok, err := env.NormalizeGitRemoteUrl(original)
 	assert.NoError(t, err)
 	assert.True(t, ok)
-	assert.Equal(t, "git+ssh://git@github.com/timsehn/dolt-in-git.git", normalized)
+	assert.Equal(t, "git+ssh://git@github.com/./timsehn/dolt-in-git.git", normalized)
 
 	urlToStore := original
 	if strings.HasPrefix(strings.ToLower(scheme), "git+") {

go/go.mod

@@ -64,7 +64,7 @@ require (
 	github.com/dolthub/dolt-mcp v0.3.4
 	github.com/dolthub/eventsapi_schema v0.0.0-20260205214132-a7a3c84c84a1
 	github.com/dolthub/flatbuffers/v23 v23.3.3-dh.2
-	github.com/dolthub/go-mysql-server v0.20.1-0.20260305220757-48a0f17d12e3
+	github.com/dolthub/go-mysql-server v0.20.1-0.20260306002943-3e8a45211974
 	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

@@ -212,8 +212,8 @@ github.com/dolthub/fslock v0.0.0-20251215194149-ef20baba2318 h1:n+vdH5G5Db+1qnDC
 github.com/dolthub/fslock v0.0.0-20251215194149-ef20baba2318/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.20260305220757-48a0f17d12e3 h1:vRxMCZVdCiH5CY46UX2xxVqerKLdXu99nz1M4dR2bLY=
-github.com/dolthub/go-mysql-server v0.20.1-0.20260305220757-48a0f17d12e3/go.mod h1:8zqJ7NgJ7GEISN7VkYEmrrW3DodmHHMCEjIH72BkoEU=
+github.com/dolthub/go-mysql-server v0.20.1-0.20260306002943-3e8a45211974 h1:f2v7C2iXTe/qHGPQLom7MrVe6zXwkl8eDIZ3CWDLIz4=
+github.com/dolthub/go-mysql-server v0.20.1-0.20260306002943-3e8a45211974/go.mod h1:8zqJ7NgJ7GEISN7VkYEmrrW3DodmHHMCEjIH72BkoEU=
 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/cherry_pick/cherry_pick.go

@@ -82,6 +82,14 @@ func CherryPick(ctx *sql.Context, commit string, options CherryPickOptions) (str
 		return "", nil, fmt.Errorf("failed to get roots for current session")
 	}
 
+	// Capture the working set BEFORE applying cherry-pick changes. If commit verification
+	// fails later, we need to set the merge state with preMergeWorking = original working
+	// root so that --abort properly restores the pre-cherry-pick state.
+	preApplyWs, wsErr := doltSession.WorkingSet(ctx, dbName)
+	if wsErr != nil {
+		return "", nil, wsErr
+	}
+
 	mergeResult, commitMsg, originalCommit, err := cherryPick(ctx, doltSession, roots, dbName, commit, options.EmptyCommitHandling)
 	if err != nil {
 		return "", mergeResult, err
@@ -131,6 +139,20 @@ func CherryPick(ctx *sql.Context, commit string, options CherryPickOptions) (str
 
 	pendingCommit, err := doltSession.NewPendingCommit(ctx, dbName, roots, *commitProps)
 	if err != nil {
+		// If verification failed, set merge state and return via the result (not as a Go error).
+		// Returning a Go error would roll back the transaction, undoing all working set changes.
+		// Returning nil error instead lets CommitTransaction persist the staged changes and merge
+		// state, so the user can fix the failing tests and --continue.
+		if actions.ErrCommitVerificationFailed.Is(err) {
+			newWs := preApplyWs.StartCherryPick(originalCommit, commit).
+				WithWorkingRoot(roots.Working).
+				WithStagedRoot(roots.Staged)
+			if wsErr := doltSession.SetWorkingSet(ctx, dbName, newWs); wsErr != nil {
+				return "", nil, wsErr
+			}
+			mergeResult.CommitVerificationErr = err
+			return "", mergeResult, nil
+		}
 		return "", nil, err
 	}
 	if pendingCommit == nil {
@@ -231,9 +253,10 @@ func AbortCherryPick(ctx *sql.Context, dbName string) error {
 	return doltSession.SetWorkingSet(ctx, dbName, newWs)
 }
 
-// ContinueCherryPick continues a cherry-pick merge that was paused due to conflicts.
-// It checks that conflicts have been resolved and creates the final commit with the
-// original commit's metadata.
+// ContinueCherryPick continues a cherry-pick merge that was paused due to conflicts or
+// commit verification failure. It checks that conflicts have been resolved and creates
+// the final commit with the original commit's metadata. Returns (hash, dataConflicts,
+// schemaConflicts, constraintViolations, verificationFailures, error).
 func ContinueCherryPick(ctx *sql.Context, dbName string) (string, int, int, int, error) {
 	doltSession := dsess.DSessFromSess(ctx.Session)
 
@@ -310,6 +333,9 @@ func ContinueCherryPick(ctx *sql.Context, dbName string) (string, int, int, int,
 
 	pendingCommit, err := doltSession.NewPendingCommit(ctx, dbName, roots, commitProps)
 	if err != nil {
+		if actions.ErrCommitVerificationFailed.Is(err) {
+			return "", 0, 0, 0, err
+		}
 		return "", 0, 0, 0, fmt.Errorf("error: failed to create pending commit: %w", err)
 	}
 	if pendingCommit == nil {

go/libraries/doltcore/dbfactory/git_remote.go

@@ -134,10 +134,11 @@ func (fact GitRemoteFactory) CreateDB(ctx context.Context, nbf *types.NomsBinFor
 	}
 
 	// Ensure the configured git remote exists and points to the underlying git remote URL.
-	if err := ensureGitRemoteURL(ctx, cacheRepo, remoteName, remoteURL.String()); err != nil {
+	gitURL := gitRemoteURLString(remoteURL)
+	if err := ensureGitRemoteURL(ctx, cacheRepo, remoteName, gitURL); err != nil {
 		return nil, nil, nil, err
 	}
-	if err := ensureRemoteHasBranches(ctx, cacheRepo, remoteName, remoteURL.String()); err != nil {
+	if err := ensureRemoteHasBranches(ctx, cacheRepo, remoteName, gitURL); err != nil {
 		return nil, nil, nil, err
 	}
 
@@ -186,6 +187,23 @@ func parseGitRemoteFactoryURL(urlObj *url.URL, params map[string]interface{}) (r
 	return &cp, ref, nil
 }
 
+// gitRemoteURLString converts a parsed remote URL back to a string suitable for
+// passing to git commands. If the URL has an ssh scheme and the path starts with
+// "/./", it was originally an SCP-style relative path (e.g. git@host:path.git).
+// We reconstruct SCP-style format so git treats the path as relative to the SSH
+// user's home directory.
+func gitRemoteURLString(u *url.URL) string {
+	if strings.ToLower(u.Scheme) == "ssh" && strings.HasPrefix(u.Path, "/./") {
+		// Reconstruct SCP-style: [user@]host:relativePath
+		host := u.Host
+		if u.User != nil {
+			host = u.User.String() + "@" + u.Host
+		}
+		return host + ":" + strings.TrimPrefix(u.Path, "/./")
+	}
+	return u.String()
+}
+
 func resolveGitRemoteRef(params map[string]interface{}) string {
 	// Prefer an explicit remote parameter (e.g. from `--ref`).
 	if params != nil {

go/libraries/doltcore/dbfactory/git_remote_test.go

@@ -18,6 +18,7 @@ import (
 	"context"
 	"crypto/sha256"
 	"encoding/hex"
+	"net/url"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -49,6 +50,43 @@ func shortTempDir(t *testing.T) string {
 	return dir
 }
 
+func TestGitRemoteURLString(t *testing.T) {
+	tests := []struct {
+		name     string
+		rawURL   string
+		expected string
+	}{
+		{
+			name:     "ssh relative path reconstructs SCP-style",
+			rawURL:   "ssh://git@myhost/./relative/repo.git",
+			expected: "git@myhost:relative/repo.git",
+		},
+		{
+			name:     "ssh absolute path unchanged",
+			rawURL:   "ssh://git@myhost/abs/repo.git",
+			expected: "ssh://git@myhost/abs/repo.git",
+		},
+		{
+			name:     "https unchanged",
+			rawURL:   "https://example.com/org/repo.git",
+			expected: "https://example.com/org/repo.git",
+		},
+		{
+			name:     "ssh no user relative path",
+			rawURL:   "ssh://myhost/./relative/repo.git",
+			expected: "myhost:relative/repo.git",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			u, err := url.Parse(tt.rawURL)
+			require.NoError(t, err)
+			got := gitRemoteURLString(u)
+			require.Equal(t, tt.expected, got)
+		})
+	}
+}
+
 func TestGitRemoteFactory_GitFile_RequiresGitCacheRootParam(t *testing.T) {
 	ctx := context.Background()
 	_, _, _, err := CreateDB(ctx, types.Format_Default, "git+file:///tmp/remote.git", map[string]interface{}{})

go/libraries/doltcore/env/actions/commit.go

@@ -22,12 +22,17 @@ import (
 
 	gms "github.com/dolthub/go-mysql-server"
 	"github.com/dolthub/go-mysql-server/sql"
+	goerrors "gopkg.in/src-d/go-errors.v1"
 
 	"github.com/dolthub/dolt/go/libraries/doltcore/diff"
 	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
 	"github.com/dolthub/dolt/go/store/datas"
 )
 
+const CommitVerificationFailedPrefix = "commit verification failed:"
+
+var ErrCommitVerificationFailed = goerrors.NewKind(CommitVerificationFailedPrefix + " %s")
+
 type CommitStagedProps struct {
 	Message          string
 	Date             time.Time
@@ -45,10 +50,10 @@ const (
 	DoltCommitVerificationGroups = "dolt_commit_verification_groups"
 )
 
-// GetCommitRunTestGroups returns the test groups to run for commit operations
+// getCommitRunTestGroups returns the test groups to run for commit operations
 // Returns empty slice if no tests should be run, ["*"] if all tests should be run,
 // or specific group names if only those groups should be run
-func GetCommitRunTestGroups() []string {
+func getCommitRunTestGroups() []string {
 	_, val, ok := sql.SystemVariables.GetGlobal(DoltCommitVerificationGroups)
 	if !ok {
 		return nil
@@ -147,7 +152,7 @@ func GetCommitStaged(
 	}
 
 	if !props.SkipVerification {
-		testGroups := GetCommitRunTestGroups()
+		testGroups := getCommitRunTestGroups()
 		if len(testGroups) > 0 {
 			err := runCommitVerification(ctx, testGroups)
 			if err != nil {
@@ -164,6 +169,9 @@ func GetCommitStaged(
 	return db.NewPendingCommit(ctx, roots, mergeParents, props.Amend, meta)
 }
 
+// runCommitVerification runs the commit verification tests for the given test groups.
+// If any tests fail, it returns ErrCommitVerificationFailed wrapping the failure details.
+// Callers can use errors.Is(err, ErrCommitVerificationFailed) to detect this case.
 func runCommitVerification(ctx *sql.Context, testGroups []string) error {
 	type sessionInterface interface {
 		sql.Session
@@ -216,7 +224,7 @@ func runTestsUsingDtablefunctions(ctx *sql.Context, engine *gms.Engine, testGrou
 	}
 
 	if len(allFailures) > 0 {
-		return fmt.Errorf("commit verification failed: %s", strings.Join(allFailures, ", "))
+		return ErrCommitVerificationFailed.New(strings.Join(allFailures, ", "))
 	}
 
 	return nil

go/libraries/doltcore/env/git_remote_url.go

@@ -74,7 +74,15 @@ func NormalizeGitRemoteUrl(urlArg string) (normalized string, ok bool, err error
 	// scp-like ssh: [user@]host:path/repo.git (no scheme, no ://)
 	if isScpLikeGitRemote(urlArg) {
 		host, p := splitScpLike(urlArg)
-		ssh := "git+ssh://" + host + "/" + strings.TrimPrefix(p, "/")
+		var pathPart string
+		if strings.HasPrefix(p, "/") {
+			// Absolute path: git@host:/abs/repo.git → /abs/repo.git
+			pathPart = p
+		} else {
+			// Relative path: git@host:path.git → /./path.git
+			pathPart = "/./" + p
+		}
+		ssh := "git+ssh://" + host + pathPart
 		u, err := url.Parse(ssh)
 		if err != nil {
 			return "", false, err