amend commit staged props to get identity configuration from dolt session

Author: elianddb

go/cmd/dolt/commands/engine/sqlengine.go

@@ -545,10 +545,33 @@ func doltSessionFactory(
 			return nil, err
 		}
 
+		// Initialize commit identity session variables from environment variables.
+		initCommitIdentitySessionVars(doltSession)
+
 		return doltSession, nil
 	}
 }
 
+// initCommitIdentitySessionVars initializes commit identity session variables from environment variables.
+// This allows clients to set DOLT_AUTHOR_NAME, DOLT_AUTHOR_EMAIL, etc. in their environment and have
+// those values automatically available in SQL sessions.
+func initCommitIdentitySessionVars(sess *dsess.DoltSession) {
+	envVarToSessionVar := map[string]string{
+		dconfig.EnvDoltAuthorName:     dsess.DoltAuthorName,
+		dconfig.EnvDoltAuthorEmail:    dsess.DoltAuthorEmail,
+		dconfig.EnvDoltAuthorDate:     dsess.DoltAuthorDate,
+		dconfig.EnvDoltCommitterName:  dsess.DoltCommitterName,
+		dconfig.EnvDoltCommitterEmail: dsess.DoltCommitterEmail,
+		dconfig.EnvDoltCommitterDate:  dsess.DoltCommitterDate,
+	}
+	for envVar, sessionVar := range envVarToSessionVar {
+		if val := os.Getenv(envVar); val != "" {
+			// Ignore errors since these are optional session variables.
+			_ = sess.SetSessionVariable(nil, sessionVar, val)
+		}
+	}
+}
+
 type ConfigOption func(*SqlEngineConfig)
 
 // NewSqlEngineForEnv returns a SqlEngine configured for the environment provided, with a single root user.

go/cmd/dolt/commands/schcmds/copy-tags.go

@@ -31,7 +31,6 @@ import (
 	"github.com/dolthub/dolt/go/libraries/doltcore/schema"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dsess"
 	"github.com/dolthub/dolt/go/libraries/utils/argparser"
-	"github.com/dolthub/dolt/go/libraries/utils/config"
 	"github.com/dolthub/dolt/go/store/datas"
 	"github.com/dolthub/dolt/go/store/types"
 )
@@ -276,18 +275,13 @@ func doltCommitUpdatedTags(ctx *sql.Context, tableResolver doltdb.TableResolver,
 	workingSet = workingSet.WithWorkingRoot(workingRoot)
 	workingSet = workingSet.WithStagedRoot(workingRoot)
 
-	email, err := dEnv.Config.GetString(config.UserEmailKey)
-	if err != nil {
-		return err
-	}
-
-	name, err := dEnv.Config.GetString(config.UserNameKey)
+	doltDB := dEnv.DoltDB(ctx)
+	dSess := dsess.DSessFromSess(ctx.Session)
+	commitStagedProps, err := dSess.NewCommitStagedPropsFromSession(ctx, "Syncing column tags from "+fromBranchName+" branch")
 	if err != nil {
 		return err
 	}
 
-	doltDB := dEnv.DoltDB(ctx)
-	commitStagedProps := actions.NewCommitStagedProps(name, email, datas.AuthorDate(), "Syncing column tags from "+fromBranchName+" branch")
 	pendingCommit, err := actions.GetCommitStaged(ctx, tableResolver, roots, workingSet, nil, doltDB, commitStagedProps)
 	if err != nil {
 		return err
@@ -303,8 +297,8 @@ func doltCommitUpdatedTags(ctx *sql.Context, tableResolver doltdb.TableResolver,
 	}
 
 	_, err = doltDB.CommitWithWorkingSet(ctx, headRef, workingSet.Ref(), pendingCommit, workingSet, prevHash, &datas.WorkingSetMeta{
-		Name:  name,
-		Email: email,
+		Name:  commitStagedProps.Name,
+		Email: commitStagedProps.Email,
 	}, nil)
 	return err
 }

go/cmd/dolt/commands/utils.go

@@ -760,7 +760,7 @@ func getCommitInfoWithOptions(queryist cli.Queryist, sqlCtx *sql.Context, ref st
 	if !ok {
 		return nil, fmt.Errorf("unexpected type for committer email: %T", row[2])
 	}
-	committerTs, err := getTimestampColAsUint64(row[3])
+	committerDate, err := getTimestampColAsUint64(row[3])
 	if err != nil {
 		return nil, fmt.Errorf("error parsing committer timestamp '%v': %w", row[3], err)
 	}
@@ -797,7 +797,7 @@ func getCommitInfoWithOptions(queryist cli.Queryist, sqlCtx *sql.Context, ref st
 	// Older Dolt versions store author metadata in the committer columns so we offer this default.
 	authorName := committerName
 	authorEmail := committerEmail
-	authorTs := committerTs
+	authorDate := committerDate
 	if supportsAuthorColumns {
 		authorName, ok = row[8+authorColumnsOffset].(string)
 		if !ok {
@@ -807,19 +807,20 @@ func getCommitInfoWithOptions(queryist cli.Queryist, sqlCtx *sql.Context, ref st
 		if !ok {
 			return nil, fmt.Errorf("unexpected type for author email: %T", row[9+authorColumnsOffset])
 		}
-		authorTs, err = getTimestampColAsUint64(row[10+authorColumnsOffset])
+		authorDate, err = getTimestampColAsUint64(row[10+authorColumnsOffset])
 		if err != nil {
 			return nil, fmt.Errorf("error parsing author timestamp '%v': %w", row[10+authorColumnsOffset], err)
 		}
 	}
 
+	i64AuthorDate := int64(authorDate)
 	commitMeta := &datas.CommitMeta{
 		Name:           authorName,
 		Email:          authorEmail,
 		Description:    message,
 		Signature:      signature,
-		Timestamp:      &committerTs,
-		UserTimestamp:  int64(authorTs),
+		Timestamp:      &committerDate,
+		UserTimestamp:  &i64AuthorDate,
 		CommitterName:  committerName,
 		CommitterEmail: committerEmail,
 	}

go/libraries/doltcore/cherry_pick/cherry_pick.go

@@ -151,14 +151,26 @@ func CherryPick(ctx *sql.Context, commit string, options CherryPickOptions) (str
 }
 
 // CreateCommitStagedPropsFromCherryPickOptions converts the specified cherry-pick |options| into a CommitStagedProps
-// instance that can be used to create a pending commit.
+// instance that can be used to create a pending commit. The author identity comes from the original commit being
+// cherry-picked (to preserve authorship), while the committer identity comes from session/env/config.
 func CreateCommitStagedPropsFromCherryPickOptions(ctx *sql.Context, options CherryPickOptions, originalCommit *doltdb.Commit) (*actions.CommitStagedProps, error) {
 	originalMeta, err := originalCommit.GetCommitMeta(ctx)
 	if err != nil {
 		return nil, err
 	}
 
-	commitProps := actions.NewCommitStagedProps(originalMeta.Name, originalMeta.Email, originalMeta.Time(), "")
+	// Get committer identity from session/env/config.
+	doltSession := dsess.DSessFromSess(ctx.Session)
+	commitProps, err := doltSession.NewCommitStagedPropsFromSession(ctx, "")
+	if err != nil {
+		return nil, err
+	}
+
+	// Override author with original commit's author (cherry-pick preserves authorship).
+	commitProps.Name = originalMeta.Name
+	commitProps.Email = originalMeta.Email
+	authorDate := originalMeta.Time()
+	commitProps.Date = &authorDate
 
 	if options.CommitMessage != "" {
 		commitProps.Message = options.CommitMessage

go/libraries/doltcore/dtestutils/testcommands/multienv.go

@@ -35,7 +35,6 @@ import (
 	"github.com/dolthub/dolt/go/libraries/doltcore/table"
 	"github.com/dolthub/dolt/go/libraries/utils/config"
 	"github.com/dolthub/dolt/go/libraries/utils/filesys"
-	"github.com/dolthub/dolt/go/store/datas"
 	"github.com/dolthub/dolt/go/store/types"
 )
 
@@ -258,12 +257,11 @@ func (mr *MultiRepoTestSetup) CommitWithWorkingSet(dbName string) *doltdb.Commit
 		mergeParentCommits = []*doltdb.Commit{ws.MergeState().Commit()}
 	}
 
-	t := datas.CommitterDate()
 	roots, err := dEnv.Roots(ctx)
 	if err != nil {
 		panic("couldn't get roots: " + err.Error())
 	}
-	commitStagedProps := actions.NewCommitStagedProps(name, email, t, "auto commit")
+	commitStagedProps := actions.NewCommitStagedProps(name, email, nil, "auto commit")
 	commitStagedProps.AllowEmpty = true
 	pendingCommit, err := actions.GetCommitStaged(ctx, doltdb.SimpleTableResolver{}, roots, ws, mergeParentCommits, dEnv.DbData(ctx).Ddb, commitStagedProps)
 	if err != nil {

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

@@ -24,9 +24,10 @@ import (
 	"github.com/dolthub/dolt/go/store/datas"
 )
 
+// CommitStagedProps contains the parameters for a staged commit operation.
 type CommitStagedProps struct {
 	Message    string
-	Date       time.Time
+	Date       *time.Time
 	AllowEmpty bool
 	SkipEmpty  bool
 	Amend      bool
@@ -40,25 +41,16 @@ type CommitStagedProps struct {
 }
 
 // NewCommitStagedProps creates a new CommitStagedProps with the given author information. Committer fields are
-// automatically populated from environment variables (DOLT_COMMITTER_NAME, DOLT_COMMITTER_EMAIL, DOLT_COMMITTER_DATE)
-// if set, otherwise they default to the author values.
-func NewCommitStagedProps(name, email string, date time.Time, message string) CommitStagedProps {
-	committerName := datas.CommitterName
-	if committerName == "" {
-		committerName = name
-	}
-	committerEmail := datas.CommitterEmail
-	if committerEmail == "" {
-		committerEmail = email
-	}
-
+// automatically populated with the author information. The committer date is left empty to indicate it should be
+// written before serialization.
+func NewCommitStagedProps(name, email string, date *time.Time, message string) CommitStagedProps {
 	return CommitStagedProps{
 		Message:        message,
 		Date:           date,
 		Name:           name,
 		Email:          email,
-		CommitterName:  committerName,
-		CommitterEmail: committerEmail,
+		CommitterName:  name,
+		CommitterEmail: email,
 		// CommitterDate if defined overrides time.Now or env var set by CommitterDate(). Caller is responsible for
 		// setting this field explicitly atm.
 	}

go/libraries/doltcore/env/actions/commitwalk/commitwalk.go

@@ -87,7 +87,7 @@ func (q *q) Less(i, j int) bool {
 	}
 
 	if cI.height == cJ.height {
-		return cI.meta.UserTimestamp > cJ.meta.UserTimestamp
+		return *cI.meta.UserTimestamp > *cJ.meta.UserTimestamp
 	}
 	return false
 }

go/libraries/doltcore/sqle/database_provider.go

@@ -609,11 +609,10 @@ func (p *DoltDatabaseProvider) CreateCollatedDatabase(ctx *sql.Context, name str
 			return fmt.Errorf("unable to get roots for database %s", name)
 		}
 
-		t := ctx.QueryTime()
-		userName := ctx.Client().User
-		userEmail := fmt.Sprintf("%s@%s", ctx.Client().User, ctx.Client().Address)
-
-		commitStagedProps := actions.NewCommitStagedProps(userName, userEmail, t, "CREATE DATABASE")
+		commitStagedProps, err := sess.NewCommitStagedPropsFromSession(ctx, "CREATE DATABASE")
+		if err != nil {
+			return err
+		}
 		pendingCommit, err := sess.NewPendingCommit(ctx, name, roots, commitStagedProps)
 		if err != nil {
 			return err

go/libraries/doltcore/sqle/dprocedures/dolt_commit.go

@@ -29,7 +29,6 @@ import (
 	"github.com/dolthub/dolt/go/libraries/doltcore/env/actions"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dsess"
 	"github.com/dolthub/dolt/go/libraries/utils/gpg"
-	"github.com/dolthub/dolt/go/store/datas"
 )
 
 // doltCommit is the stored procedure version for the CLI command `dolt commit`.
@@ -111,19 +110,6 @@ func doDoltCommit(ctx *sql.Context, args []string) (string, bool, error) {
 		}
 	}
 
-	var name, email string
-	if authorStr, ok := apr.GetValue(cli.AuthorParam); ok {
-		name, email, err = cli.ParseAuthor(authorStr)
-		if err != nil {
-			return "", false, err
-		}
-	} else {
-		// In SQL mode, use the current SQL user as the commit author, instead of the `dolt config` configured values.
-		// We won't have an email address for the SQL user though, so instead use the MySQL user@address notation.
-		name = ctx.Client().User
-		email = fmt.Sprintf("%s@%s", ctx.Client().User, ctx.Client().Address)
-	}
-
 	amend := apr.Contains(cli.AmendFlag)
 
 	msg, msgOk := apr.GetValue(cli.MessageArg)
@@ -143,23 +129,31 @@ func doDoltCommit(ctx *sql.Context, args []string) (string, bool, error) {
 		}
 	}
 
-	t := ctx.QueryTime()
-	commitStagedProps := actions.NewCommitStagedProps(name, email, t, msg)
+	commitStagedProps, err := dSess.NewCommitStagedPropsFromSession(ctx, msg)
+	if err != nil {
+		return "", false, err
+	}
 	commitStagedProps.AllowEmpty = apr.Contains(cli.AllowEmptyFlag)
 	commitStagedProps.SkipEmpty = apr.Contains(cli.SkipEmptyFlag)
 	commitStagedProps.Amend = amend
 
+	// Override author if --author flag is provided.
+	if authorStr, ok := apr.GetValue(cli.AuthorParam); ok {
+		name, email, err := cli.ParseAuthor(authorStr)
+		if err != nil {
+			return "", false, err
+		}
+		commitStagedProps.Name = name
+		commitStagedProps.Email = email
+	}
+
+	// Override author date if --date flag is provided.
 	if commitTimeStr, ok := apr.GetValue(cli.DateParam); ok {
-		var err error
-		t, err = dconfig.ParseDate(commitTimeStr)
-		commitStagedProps.Date = t
-		commitStagedProps.CommitterDate = &t
+		t, err := dconfig.ParseDate(commitTimeStr)
 		if err != nil {
 			return "", false, err
 		}
-	} else if datas.CustomAuthorDate {
-		t = datas.AuthorDate()
-		commitStagedProps.Date = t
+		commitStagedProps.Date = &t
 	}
 
 	if apr.Contains(cli.ForceFlag) {

go/libraries/doltcore/sqle/dprocedures/dolt_merge.go

@@ -443,7 +443,14 @@ func executeNoFFMerge(
 		return ws.WithStagedRoot(roots.Staged), nil, nil
 	}
 
-	committerStagedProps := actions.NewCommitStagedProps(spec.Name, spec.Email, spec.Date, msg)
+	committerStagedProps, err := dSess.NewCommitStagedPropsFromSession(ctx, msg)
+	if err != nil {
+		return nil, nil, err
+	}
+	// Override author from spec (already resolved via --author flag or session/env/config fallback).
+	committerStagedProps.Name = spec.Name
+	committerStagedProps.Email = spec.Email
+	committerStagedProps.Date = &spec.Date
 	committerStagedProps.Force = spec.Force
 	pendingCommit, err := dSess.NewPendingCommit(ctx, dbName, roots, committerStagedProps)
 	if err != nil {
@@ -515,18 +522,16 @@ func createMergeSpec(ctx *sql.Context, sess *dsess.DoltSession, dbName string, a
 }
 
 func getNameAndEmail(ctx *sql.Context, apr *argparser.ArgParseResults) (string, string, error) {
-	var err error
-	var name, email string
 	if authorStr, ok := apr.GetValue(cli.AuthorParam); ok {
-		name, email, err = cli.ParseAuthor(authorStr)
-		if err != nil {
-			return "", "", err
-		}
-	} else {
-		name = ctx.Client().User
-		email = fmt.Sprintf("%s@%s", ctx.Client().User, ctx.Client().Address)
+		return cli.ParseAuthor(authorStr)
+	}
+	// Fall back to session/env/config values.
+	dSess := dsess.DSessFromSess(ctx.Session)
+	props, err := dSess.NewCommitStagedPropsFromSession(ctx, "")
+	if err != nil {
+		return "", "", err
 	}
-	return name, email, nil
+	return props.Name, props.Email, nil
 }
 
 func mergeRootToWorking(