Add @ database revision delimiter for ORMs and drivers

.gitignore

@@ -26,6 +26,7 @@ CLAUDE.md
 .gitattributes
 
 .de/
+.cursor
 AGENTS.md
 .claude/
 .cursorrules

go/cmd/dolt/cli/prompt/resolver.go

@@ -0,0 +1,145 @@
+// Copyright 2026 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package prompt
+
+import (
+	"errors"
+	"strings"
+
+	"github.com/dolthub/go-mysql-server/sql"
+
+	"github.com/dolthub/dolt/go/cmd/dolt/cli"
+	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
+)
+
+// Parts contains shell prompt components to render the SQL shell prompt.
+type Parts struct {
+	BaseDatabase      string
+	ActiveRevision    string
+	RevisionDelimiter string
+	IsBranch          bool
+	Dirty             bool
+}
+
+// Resolver resolves prompt [prompt.Parts] for the active session.
+type Resolver interface {
+	Resolve(sqlCtx *sql.Context, queryist cli.Queryist) (parts Parts, resolved bool, err error)
+}
+
+// sqlDBActiveBranchResolver can resolve [prompt.Parts] using the Dolt SQL functions, and supports
+// [doltdb.DbRevisionDelimiter] and [doltdb.DbRevisionDelimiterAlias].
+type sqlDBActiveBranchResolver struct{}
+
+// chainedResolver can resolve [prompt.Parts] through the sequential execution [prompt.Resolver](s).
+type chainedResolver struct {
+	resolvers []Resolver
+}
+
+// NewPromptResolver constructs an up-to-date [prompt.Resolver].
+func NewPromptResolver() Resolver {
+	return chainedResolver{
+		resolvers: []Resolver{
+			sqlDBActiveBranchResolver{},
+		},
+	}
+}
+
+// Resolve resolves [prompt.Parts] through a chain of [prompt.Resolver](s) in sequential order. If a Resolver encounters
+// an error, it is returned immediately and no other Resolver executes.
+func (cr chainedResolver) Resolve(sqlCtx *sql.Context, queryist cli.Queryist) (parts Parts, resolved bool, err error) {
+	for _, resolver := range cr.resolvers {
+		parts, resolved, err := resolver.Resolve(sqlCtx, queryist)
+		if err != nil {
+			return Parts{}, false, err
+		}
+		if resolved {
+			return parts, true, nil
+		}
+	}
+	return Parts{}, false, nil
+}
+
+// Resolve resolves the base DB and revision through the SQL function `database()` and Dolt-specific `active_branch()`.
+func (sqlDBActiveBranchResolver) Resolve(sqlCtx *sql.Context, queryist cli.Queryist) (parts Parts, resolved bool, err error) {
+	dbRows, err := cli.GetRowsForSql(queryist, sqlCtx, "select database() as db")
+	if err != nil {
+		return parts, false, err
+	}
+	if len(dbRows) > 0 && len(dbRows[0]) > 0 {
+		dbName, err := cli.QueryValueAsString(dbRows[0][0])
+		if err != nil {
+			return parts, false, err
+		}
+		// Handles non-branch revisions (i.e., commit hash, tags, etc.).
+		parts.BaseDatabase, parts.ActiveRevision = doltdb.SplitRevisionDbName(dbName)
+
+		parts.RevisionDelimiter = doltdb.DbRevisionDelimiter
+		for _, delimiter := range doltdb.DBRevisionDelimiters {
+			if strings.Contains(dbName, delimiter) {
+				parts.RevisionDelimiter = delimiter
+				break
+			}
+		}
+	}
+
+	activeBranchRows, err := cli.GetRowsForSql(queryist, sqlCtx, "select active_branch() as branch")
+	if err != nil {
+		return parts, false, err
+	}
+
+	if len(activeBranchRows) > 0 && len(activeBranchRows[0]) > 0 {
+		parts.IsBranch = activeBranchRows[0][0] != nil
+		if parts.ActiveRevision == "" {
+			parts.ActiveRevision, err = cli.QueryValueAsString(activeBranchRows[0][0])
+			if err != nil {
+				return parts, false, err
+			}
+		}
+	}
+
+	parts.Dirty, err = resolveDirty(sqlCtx, queryist, parts)
+	if err != nil {
+		return parts, false, err
+	}
+
+	return parts, true, nil
+}
+
+// resolveDirty resolves the dirty state of the current branch and whether the revision type is a branch.
+func resolveDirty(sqlCtx *sql.Context, queryist cli.Queryist, parts Parts) (dirty bool, err error) {
+	if doltdb.IsValidCommitHash(parts.ActiveRevision) {
+		return false, nil
+	}
+
+	rows, err := cli.GetRowsForSql(queryist, sqlCtx, "select count(table_name) > 0 as dirty from dolt_status")
+	// [sql.ErrTableNotFound] detects when viewing a non-Dolt database (e.g., information_schema). Older servers may
+	// complain about [doltdb.ErrOperationNotSupportedInDetachedHead], but read-only revisions in newer versions this
+	// issue should be gone.
+	if errors.Is(err, doltdb.ErrOperationNotSupportedInDetachedHead) || sql.ErrTableNotFound.Is(err) {
+		return false, nil
+	} else if err != nil {
+		return false, err
+	}
+
+	if len(rows) == 0 || len(rows[0]) == 0 {
+		return false, nil
+	}
+	dirty, err = cli.QueryValueAsBool(rows[0][0])
+	if err != nil {
+		return false, err
+	}
+
+	return dirty, nil
+}

go/cmd/dolt/cli/query_helpers.go

@@ -16,30 +16,11 @@ package cli
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/dolthub/go-mysql-server/sql"
 )
 
-// GetInt8ColAsBool returns the value of an int8 column as a bool
-// This is necessary because Queryist may return an int8 column as a bool (when using SQLEngine)
-// or as a string (when using ConnectionQueryist).
-func GetInt8ColAsBool(col interface{}) (bool, error) {
-	switch v := col.(type) {
-	case int8:
-		return v != 0, nil
-	case string:
-		if v == "ON" || v == "1" {
-			return true, nil
-		} else if v == "OFF" || v == "0" {
-			return false, nil
-		} else {
-			return false, fmt.Errorf("unexpected value for boolean var: %v", v)
-		}
-	default:
-		return false, fmt.Errorf("unexpected type %T, was expecting int8", v)
-	}
-}
-
 // SetSystemVar sets the @@dolt_show_system_tables variable if necessary, and returns a function
 // resetting the variable for after the commands completion, if necessary.
 func SetSystemVar(queryist Queryist, sqlCtx *sql.Context, newVal bool) (func() error, error) {
@@ -52,7 +33,7 @@ func SetSystemVar(queryist Queryist, sqlCtx *sql.Context, newVal bool) (func() e
 	if err != nil {
 		return nil, err
 	}
-	prevVal, err := GetInt8ColAsBool(row[0][1])
+	prevVal, err := QueryValueAsBool(row[0][1])
 	if err != nil {
 		return nil, err
 	}
@@ -83,3 +64,69 @@ func GetRowsForSql(queryist Queryist, sqlCtx *sql.Context, query string) ([]sql.
 
 	return rows, nil
 }
+
+// QueryValueAsString converts a single value from a query result to a string. Use this when reading string-like
+// columns from Queryist results, since the type can differ in-process [engine.SQLEngine] versus over the wire
+// [sqlserver.ConnectionQueryist].
+func QueryValueAsString(value any) (str string, err error) {
+	if value == nil {
+		return "", nil
+	}
+
+	switch v := value.(type) {
+	case string:
+		return v, nil
+	case []byte:
+		return string(v), nil
+	case fmt.Stringer:
+		return v.String(), nil
+	default:
+		return "", fmt.Errorf("unexpected type %T, expected string-like column value", value)
+	}
+}
+
+// QueryValueAsBool interprets a query result cell as a bool. Strings are normalized and matched as "true"/"1"/"ON"
+// (true) or the opposite for false; matching is case-insensitive. [Queryist] may return a tinyint column as a bool
+// when utilizing the [engine.SQLEngine] or as string when using [sqlserver.ConnectionQueryist].
+func QueryValueAsBool(col interface{}) (bool, error) {
+	switch v := col.(type) {
+	case bool:
+		return v, nil
+	case byte:
+		return v == 1, nil
+	case int:
+		return v == 1, nil
+	case int8:
+		return v == 1, nil
+	case string:
+		s := strings.TrimSpace(v)
+		switch {
+		case s == "1" || strings.EqualFold(s, "true") || strings.EqualFold(s, "ON"):
+			return true, nil
+		case s == "0" || strings.EqualFold(s, "false") || strings.EqualFold(s, "OFF"):
+			return false, nil
+		default:
+			return false, fmt.Errorf("unexpected value for string for bool: %v", v)
+		}
+	default:
+		return false, fmt.Errorf("unexpected type %T, was expecting bool, int, or string", v)
+	}
+}
+
+// WithQueryWarningsLocked runs queries with a preserved warning buffer. Internal shell queries run on the same SQL
+// session as user queries. Without warning locks, these housekeeping queries can clear or overwrite warnings that users
+// expect.
+func WithQueryWarningsLocked(sqlCtx *sql.Context, queryist Queryist, fn func() error) error {
+	_, _, _, err := queryist.Query(sqlCtx, "set lock_warnings = 1")
+	if err != nil {
+		return err
+	}
+
+	runErr := fn()
+
+	_, _, _, err = queryist.Query(sqlCtx, "set lock_warnings = 0")
+	if err != nil {
+		return err
+	}
+	return runErr
+}

go/cmd/dolt/commands/cnfcmds/cat.go

@@ -305,7 +305,7 @@ func getMergeStatus(queryist cli.Queryist, sqlCtx *sql.Context) (mergeStatus, er
 	}
 
 	row := rows[0]
-	ms.isMerging, err = commands.GetTinyIntColAsBool(row[0])
+	ms.isMerging, err = cli.QueryValueAsBool(row[0])
 	if err != nil {
 		return ms, fmt.Errorf("error: failed to parse is_merging: %w", err)
 	}

go/cmd/dolt/commands/diff.go

@@ -859,11 +859,11 @@ func getDiffSummariesBetweenRefs(queryist cli.Queryist, sqlCtx *sql.Context, fro
 		summary.FromTableName.Name = row[0].(string)
 		summary.ToTableName.Name = row[1].(string)
 		summary.DiffType = row[2].(string)
-		summary.DataChange, err = GetTinyIntColAsBool(row[3])
+		summary.DataChange, err = cli.QueryValueAsBool(row[3])
 		if err != nil {
 			return nil, fmt.Errorf("error: unable to parse data change value '%s': %w", row[3], err)
 		}
-		summary.SchemaChange, err = GetTinyIntColAsBool(row[4])
+		summary.SchemaChange, err = cli.QueryValueAsBool(row[4])
 		if err != nil {
 			return nil, fmt.Errorf("error: unable to parse schema change value '%s': %w", row[4], err)
 		}