Create dolt_help system table

go/cmd/dolt/cli/help.go

@@ -166,21 +166,35 @@ func terminalSize() (width, height int) {
 func OptionsUsage(ap *argparser.ArgParser, indent string, lineLen int) string {
 	var lines []string
 
-	for _, kvTuple := range ap.ArgListHelp {
-		k, v := kvTuple[0], kvTuple[1]
-		lines = append(lines, "<"+k+">")
-		l, err := templateDocStringHelper(v, CliFormat)
-		if err != nil {
-			panic(err)
-		}
-		l = embolden(l)
-		descLines := toParagraphLines(l, lineLen)
+	for _, usage := range OptionsUsageList(ap) {
+		name, description := usage[0], usage[1]
+
+		lines = append(lines, name)
+
+		descLines := toParagraphLines(description, lineLen)
 		descLines = indentLines(descLines, "  ")
 		descLines = append(descLines, "")
 
 		lines = append(lines, descLines...)
 	}
 
+	lines = indentLines(lines, indent)
+	return strings.Join(lines, "\n")
+}
+
+// OptionsUsageList returns a pair of strings for each option/argument in |ap|, where the first string
+// is the name of the option/argument and the second string is the description of the option/argument.
+func OptionsUsageList(ap *argparser.ArgParser) [][2]string {
+	res := [][2]string{}
+
+	for _, help := range ap.ArgListHelp {
+		name, description := help[0], help[1]
+
+		nameFormatted := "<" + name + ">"
+
+		res = append(res, [2]string{nameFormatted, description})
+	}
+
 	for _, supOpt := range ap.Supported {
 		argHelpFmt := "--%[2]s"
 
@@ -192,22 +206,22 @@ func OptionsUsage(ap *argparser.ArgParser, indent string, lineLen int) string {
 			argHelpFmt = "--%[2]s=<%[3]s>"
 		}
 
-		lines = append(lines, fmt.Sprintf(argHelpFmt, supOpt.Abbrev, supOpt.Name, supOpt.ValDesc))
+		nameFormatted := fmt.Sprintf(argHelpFmt, supOpt.Abbrev, supOpt.Name, supOpt.ValDesc)
 
-		l, err := templateDocStringHelper(supOpt.Desc, CliFormat)
+		res = append(res, [2]string{nameFormatted, supOpt.Desc})
+	}
+
+	for i := range res {
+		descriptionFormatted, err := templateDocStringHelper(res[i][1], CliFormat)
 		if err != nil {
 			panic(err)
 		}
-		l = embolden(l)
-		descLines := toParagraphLines(l, lineLen)
-		descLines = indentLines(descLines, "  ")
-		descLines = append(descLines, "")
+		descriptionFormatted = embolden(descriptionFormatted)
 
-		lines = append(lines, descLines...)
+		res[i][1] = descriptionFormatted
 	}
 
-	lines = indentLines(lines, indent)
-	return strings.Join(lines, "\n")
+	return res
 }
 
 func ToIndentedParagraph(inStr, indent string, lineLen int) string {

go/cmd/dolt/dolt.go

@@ -60,6 +60,7 @@ import (
 	"github.com/dolthub/dolt/go/libraries/doltcore/env"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dfunctions"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dsess"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dtables"
 	"github.com/dolthub/dolt/go/libraries/events"
 	"github.com/dolthub/dolt/go/libraries/utils/argparser"
 	"github.com/dolthub/dolt/go/libraries/utils/config"
@@ -226,6 +227,8 @@ func init() {
 	if _, ok := os.LookupEnv(disableEventFlushEnvVar); ok {
 		eventFlushDisabled = true
 	}
+
+	dtables.DoltCommand = doltCommand
 }
 
 const pprofServerFlag = "--pprof-server"

go/libraries/doltcore/doltdb/system_table.go

@@ -217,6 +217,7 @@ var getGeneratedSystemTables = func() []string {
 		GetCommitAncestorsTableName(),
 		GetStatusTableName(),
 		GetRemotesTableName(),
+		GetHelpTableName(),
 	}
 }
 
@@ -380,6 +381,11 @@ var GetTagsTableName = func() string {
 	return TagsTableName
 }
 
+// GetHelpTableName returns the help table name
+var GetHelpTableName = func() string {
+	return HelpTableName
+}
+
 const (
 	// LogTableName is the log system table name
 	LogTableName = "dolt_log"
@@ -585,3 +591,7 @@ const (
 	// was originally defined. Mode settings, such as ANSI_QUOTES, are needed to correctly parse the fragment.
 	ProceduresTableSqlModeCol = "sql_mode"
 )
+
+const (
+	HelpTableName = "dolt_help"
+)

go/libraries/doltcore/sqle/database.go

@@ -714,6 +714,14 @@ func (db Database) getTableInsensitive(ctx *sql.Context, head *doltdb.Commit, ds
 			return nil, false, err
 		}
 		dt = NewSchemaTable(backingTable)
+	case doltdb.GetHelpTableName(), doltdb.HelpTableName:
+		isDoltgresSystemTable, err := resolve.IsDoltgresSystemTable(ctx, tname, root)
+		if err != nil {
+			return nil, false, err
+		}
+		if !resolve.UseSearchPath || isDoltgresSystemTable {
+			dt, found = dtables.NewHelpTable(ctx, db.Name(), lwrName), true
+		}
 	}
 
 	if found {

go/libraries/doltcore/sqle/dtables/help_table.go

@@ -0,0 +1,232 @@
+// Copyright 2025 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 dtables
+
+import (
+	"encoding/json"
+	"io"
+	"strings"
+
+	"github.com/dolthub/dolt/go/cmd/dolt/cli"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dprocedures"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/index"
+	"github.com/dolthub/go-mysql-server/sql"
+	sqlTypes "github.com/dolthub/go-mysql-server/sql/types"
+)
+
+type HelpTable struct {
+	dbName    string
+	tableName string
+}
+
+var HelpTableTypes = []string{
+	"system_table",
+	"procedure",
+	"function",
+	"variable",
+}
+
+// NewHelpTable creates a HelpTable
+func NewHelpTable(_ *sql.Context, dbName, tableName string) sql.Table {
+	return &HelpTable{dbName: dbName, tableName: tableName}
+}
+
+// Name is a sql.Table interface function which returns the name of the table.
+func (ht *HelpTable) Name() string {
+	return ht.tableName
+}
+
+// String is a sql.Table interface function which returns the name of the table.
+func (ht *HelpTable) String() string {
+	return ht.tableName
+}
+
+// Schema is a sql.Table interface function that gets the sql.Schema of the help system table.
+func (ht *HelpTable) Schema() sql.Schema {
+	return []*sql.Column{
+		{
+			Name:           "name",
+			Type:           sqlTypes.TinyText,
+			Source:         ht.tableName,
+			PrimaryKey:     true,
+			DatabaseSource: ht.dbName,
+		},
+		{
+			Name:           "type",
+			Type:           sqlTypes.MustCreateEnumType(HelpTableTypes, sql.Collation_Default),
+			Source:         ht.tableName,
+			PrimaryKey:     false,
+			DatabaseSource: ht.dbName,
+		},
+		{
+			Name:           "synopsis",
+			Type:           sqlTypes.LongText,
+			Source:         ht.tableName,
+			PrimaryKey:     false,
+			DatabaseSource: ht.dbName,
+		},
+		{
+			Name:           "short_description",
+			Type:           sqlTypes.LongText,
+			Source:         ht.tableName,
+			PrimaryKey:     false,
+			DatabaseSource: ht.dbName,
+		},
+		{
+			Name:           "long_description",
+			Type:           sqlTypes.LongText,
+			Source:         ht.tableName,
+			PrimaryKey:     false,
+			DatabaseSource: ht.dbName,
+		},
+		{
+			Name:           "arguments",
+			Type:           sqlTypes.JSON,
+			Source:         ht.tableName,
+			PrimaryKey:     false,
+			DatabaseSource: ht.dbName,
+		},
+	}
+}
+
+// Collation implements the sql.Table interface.
+func (ht *HelpTable) Collation() sql.CollationID {
+	return sql.Collation_Default
+}
+
+// Partitions is a sql.Table interface function that returns a partition
+// of the data. Currently the data is unpartitioned.
+func (ht *HelpTable) Partitions(*sql.Context) (sql.PartitionIter, error) {
+	return index.SinglePartitionIterFromNomsMap(nil), nil
+}
+
+// PartitionRows is a sql.Table interface function that gets a row iterator for a partition.
+func (ht *HelpTable) PartitionRows(_ *sql.Context, _ sql.Partition) (sql.RowIter, error) {
+	return NewHelpRowIter(), nil
+}
+
+type HelpRowIter []sql.Row
+
+func NewHelpRowIter() *HelpRowIter {
+	var nilIter HelpRowIter
+	return &nilIter
+}
+
+// DoltCommand is set in cmd/dolt/dolt.go to avoid circular dependency.
+var DoltCommand cli.SubCommandHandler
+
+func (itr *HelpRowIter) Next(_ *sql.Context) (sql.Row, error) {
+	if *itr == nil {
+		var err error
+		*itr, err = generateProcedureHelpRows(DoltCommand.Name(), DoltCommand.Subcommands)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	helpRows := *itr
+
+	if len(helpRows) == 0 {
+		return nil, io.EOF
+	}
+
+	row := helpRows[0]
+	*itr = helpRows[1:]
+
+	return row, nil
+}
+
+func (itr *HelpRowIter) Close(_ *sql.Context) error {
+	return nil
+}
+
+// generateProcedureHelpRows generates a sql row for each procedure that has an equivalent CLI command.
+func generateProcedureHelpRows(cmdStr string, subCommands []cli.Command) ([]sql.Row, error) {
+	rows := []sql.Row{}
+
+	for _, curr := range subCommands {
+		if hidCmd, ok := curr.(cli.HiddenCommand); ok && hidCmd.Hidden() {
+			continue
+		}
+
+		if subCmdHandler, ok := curr.(cli.SubCommandHandler); ok {
+			if subCmdHandler.Unspecified != nil {
+				newRows, err := generateProcedureHelpRows(cmdStr, []cli.Command{subCmdHandler.Unspecified})
+				if err != nil {
+					return nil, err
+				}
+				rows = append(rows, newRows...)
+			}
+			newRows, err := generateProcedureHelpRows(cmdStr+"_"+subCmdHandler.Name(), subCmdHandler.Subcommands)
+			if err != nil {
+				return nil, err
+			}
+			rows = append(rows, newRows...)
+		} else {
+			fullName := cmdStr + "_" + curr.Name()
+			procedureName := strings.ReplaceAll(fullName, "-", "_")
+
+			hasProcedure := false
+			for _, procedure := range dprocedures.DoltProcedures {
+				if procedure.Name == procedureName {
+					hasProcedure = true
+					break
+				}
+			}
+
+			docs := curr.Docs()
+
+			if hasProcedure && docs != nil {
+				argsMap := map[string]string{}
+				for _, usage := range cli.OptionsUsageList(docs.ArgParser) {
+					argsMap[usage[0]] = usage[1]
+				}
+
+				argsJson, err := json.Marshal(argsMap)
+				if err != nil {
+					return nil, err
+				}
+
+				synopsis, err := docs.GetSynopsis(cli.CliFormat)
+				if err != nil {
+					return nil, err
+				}
+
+				cliName := strings.ReplaceAll(fullName, "_", " ")
+				for i := range synopsis {
+					synopsis[i] = cliName + " " + synopsis[i]
+				}
+
+				shortDesc := docs.GetShortDesc()
+
+				longDesc, err := docs.GetLongDesc(cli.CliFormat)
+				if err != nil {
+					return nil, err
+				}
+
+				rows = append(rows, sql.NewRow(
+					procedureName,
+					"procedure",
+					strings.Join(synopsis, "\n"),
+					shortDesc,
+					longDesc,
+					argsJson,
+				))
+			}
+		}
+	}
+
+	return rows, nil
+}

go/libraries/doltcore/sqle/enginetest/dolt_queries.go

@@ -7565,6 +7565,7 @@ var DoltSystemVariables = []queries.ScriptTest{
 					{"dolt_constraint_violations"},
 					{"dolt_constraint_violations_test"},
 					{"dolt_diff_test"},
+					{"dolt_help"},
 					{"dolt_history_test"},
 					{"dolt_log"},
 					{"dolt_remote_branches"},

integration-tests/bats/ls.bats

@@ -60,7 +60,7 @@ teardown() {
 @test "ls: --system shows system tables" {
     run dolt ls --system
     [ "$status" -eq 0 ]
-    [ "${#lines[@]}" -eq 22 ]
+    [ "${#lines[@]}" -eq 23 ]
     [[ "$output" =~ "System tables:" ]] || false
     [[ "$output" =~ "dolt_status" ]] || false
     [[ "$output" =~ "dolt_commits" ]] || false
@@ -71,6 +71,7 @@ teardown() {
     [[ "$output" =~ "dolt_remotes" ]] || false
     [[ "$output" =~ "dolt_branches" ]] || false
     [[ "$output" =~ "dolt_remote_branches" ]] || false
+    [[ "$output" =~ "dolt_help" ]] || false
     [[ "$output" =~ "dolt_constraint_violations_table_one" ]] || false
     [[ "$output" =~ "dolt_history_table_one" ]] || false
     [[ "$output" =~ "dolt_conflicts_table_one" ]] || false