Removed root object presence from some locations

go/cmd/dolt/commands/assist.go

@@ -588,7 +588,7 @@ func getCreateTableStatements(ctx *sql.Context, sqlEngine *engine.SqlEngine, dEn
 		return "", err
 	}
 
-	tables, err := root.GetTableNames(ctx, doltdb.DefaultSchemaName)
+	tables, err := root.GetTableNames(ctx, doltdb.DefaultSchemaName, true)
 	for _, table := range tables {
 		_, iter, _, err := sqlEngine.Query(ctx, fmt.Sprintf("SHOW CREATE TABLE %s", sql.QuoteIdentifier(table)))
 		if err != nil {

go/cmd/dolt/commands/cvcmds/verify_constraints.go

@@ -79,7 +79,7 @@ func (cmd VerifyConstraintsCmd) Exec(ctx context.Context, commandStr string, arg
 	}
 	tableNames := apr.Args
 	if len(tableNames) == 0 {
-		tableNames, err = working.GetTableNames(ctx, doltdb.DefaultSchemaName)
+		tableNames, err = working.GetTableNames(ctx, doltdb.DefaultSchemaName, true)
 		if err != nil {
 			return commands.HandleVErrAndExitCode(errhand.BuildDError("Unable to read table names.").AddCause(err).Build(), nil)
 		}

go/cmd/dolt/commands/indexcmds/ls.go

@@ -72,7 +72,7 @@ func (cmd LsCmd) Exec(ctx context.Context, commandStr string, args []string, dEn
 
 	var tableNames []string
 	if apr.NArg() == 0 {
-		tableNames, err = working.GetTableNames(ctx, doltdb.DefaultSchemaName)
+		tableNames, err = working.GetTableNames(ctx, doltdb.DefaultSchemaName, true)
 		if err != nil {
 			return HandleErr(errhand.BuildDError("Unable to get tables.").AddCause(err).Build(), nil)
 		}

go/cmd/dolt/commands/read_tables.go

@@ -144,7 +144,7 @@ func (cmd ReadTablesCmd) Exec(ctx context.Context, commandStr string, args []str
 	}
 
 	if len(tblNames) == 0 {
-		tblNames, err = srcRoot.GetTableNames(ctx, doltdb.DefaultSchemaName)
+		tblNames, err = srcRoot.GetTableNames(ctx, doltdb.DefaultSchemaName, true)
 
 		if err != nil {
 			return BuildVerrAndExit("Unable to read tables.", err)

go/cmd/dolt/commands/schcmds/show.go

@@ -120,7 +120,7 @@ func printSchemas(ctx context.Context, apr *argparser.ArgParseResults, dEnv *env
 		// show usage and error out if there aren't any
 		if len(tables) == 0 {
 			var err error
-			tables, err = root.GetTableNames(ctx, doltdb.DefaultSchemaName)
+			tables, err = root.GetTableNames(ctx, doltdb.DefaultSchemaName, true)
 
 			if err != nil {
 				return errhand.BuildDError("unable to get table names.").AddCause(err).Build()

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

@@ -79,7 +79,7 @@ func (cmd TagsCmd) Exec(ctx context.Context, commandStr string, args []string, d
 
 	if len(tables) == 0 {
 		var err error
-		tables, err = root.GetTableNames(ctx, doltdb.DefaultSchemaName)
+		tables, err = root.GetTableNames(ctx, doltdb.DefaultSchemaName, true)
 
 		if err != nil {
 			return commands.HandleVErrAndExitCode(errhand.BuildDError("unable to get table names.").AddCause(err).Build(), usage)

go/libraries/doltcore/diff/diff_stat.go

@@ -71,6 +71,18 @@ func Stat(ctx context.Context, ch chan DiffStatProgress, from, to durable.Index,
 
 // StatForTableDelta pushes diff stat progress messages for the table delta given to the channel given
 func StatForTableDelta(ctx context.Context, ch chan DiffStatProgress, td TableDelta) error {
+	// Check for root objects first, as they're handled differently
+	if td.FromRootObject != nil && td.ToRootObject != nil {
+		ch <- DiffStatProgress{Changes: 1}
+		return nil
+	} else if td.FromRootObject == nil && td.ToRootObject != nil {
+		ch <- DiffStatProgress{Adds: 1}
+		return nil
+	} else if td.FromRootObject != nil && td.ToRootObject == nil {
+		ch <- DiffStatProgress{Removes: 1}
+		return nil
+	}
+
 	fromSch, toSch, err := td.GetSchemas(ctx)
 	if err != nil {
 		return errhand.BuildDError("cannot retrieve schema for table %s", td.ToName).AddCause(err).Build()

go/libraries/doltcore/doltdb/doltdb_test.go

@@ -295,7 +295,7 @@ func TestLDNoms(t *testing.T) {
 
 		assert.NoError(t, err)
 
-		names, err := root.GetTableNames(context.Background(), DefaultSchemaName)
+		names, err := root.GetTableNames(context.Background(), DefaultSchemaName, true)
 		assert.NoError(t, err)
 		if len(names) != 0 {
 			t.Fatal("There should be no tables in empty db")

go/libraries/doltcore/doltdb/root_val.go

@@ -88,7 +88,7 @@ type RootValue interface {
 	// GetTableSchemaHash returns the hash of the given table's schema.
 	GetTableSchemaHash(ctx context.Context, tName TableName) (hash.Hash, error)
 	// GetTableNames retrieves the lists of all tables and root objects for a RootValue.
-	GetTableNames(ctx context.Context, schemaName string) ([]string, error)
+	GetTableNames(ctx context.Context, schemaName string, includeRootObjects bool) ([]string, error)
 	// HasTable returns whether the root has a table with the given case-sensitive name. This will also return true if a
 	// root object matches the table name, as they occupy the same namespace.
 	HasTable(ctx context.Context, tName TableName) (bool, error)
@@ -624,7 +624,7 @@ func GetTableByColTag(ctx context.Context, root RootValue, tag uint64) (tbl *Tab
 }
 
 // GetTableNames retrieves the lists of all tables for a RootValue
-func (root *rootValue) GetTableNames(ctx context.Context, schemaName string) ([]string, error) {
+func (root *rootValue) GetTableNames(ctx context.Context, schemaName string, _ bool) ([]string, error) {
 	tableMap, err := root.getTableMap(ctx, schemaName)
 	if err != nil {
 		return nil, err
@@ -1271,7 +1271,7 @@ func UnionTableNames(ctx context.Context, roots ...RootValue) ([]TableName, erro
 		}
 
 		for _, schemaName := range schemaNames {
-			rootTblNames, err := root.GetTableNames(ctx, schemaName)
+			rootTblNames, err := root.GetTableNames(ctx, schemaName, true)
 			if err != nil {
 				return nil, err
 			}

go/libraries/doltcore/doltdb/system_table.go

@@ -99,7 +99,7 @@ func IsNonAlterableSystemTable(name TableName) bool {
 
 // GetNonSystemTableNames gets non-system table names
 func GetNonSystemTableNames(ctx context.Context, root RootValue) ([]string, error) {
-	tn, err := root.GetTableNames(ctx, DefaultSchemaName)
+	tn, err := root.GetTableNames(ctx, DefaultSchemaName, true)
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/env/actions/dolt_ci/workflow_manager.go

@@ -531,7 +531,7 @@ func (d *doltWorkflowManager) validateWorkflowTables(ctx *sql.Context) error {
 
 	root := roots.Working
 
-	tables, err := root.GetTableNames(ctx, doltdb.DefaultSchemaName)
+	tables, err := root.GetTableNames(ctx, doltdb.DefaultSchemaName, true)
 	if err != nil {
 		return err
 	}

go/libraries/doltcore/env/actions/reset.go

@@ -277,7 +277,7 @@ func CleanUntracked(ctx *sql.Context, roots doltdb.Roots, tables []string, dryru
 
 	var err error
 	if len(tables) == 0 {
-		tables, err = roots.Working.GetTableNames(ctx, doltdb.DefaultSchemaName)
+		tables, err = roots.Working.GetTableNames(ctx, doltdb.DefaultSchemaName, true)
 		if err != nil {
 			return doltdb.Roots{}, nil
 		}

go/libraries/doltcore/merge/action.go

@@ -184,7 +184,7 @@ func AbortMerge(ctx *sql.Context, workingSet *doltdb.WorkingSet, roots doltdb.Ro
 	}
 
 	preMergeWorkingRoot := workingSet.MergeState().PreMergeWorkingRoot()
-	preMergeWorkingTables, err := preMergeWorkingRoot.GetTableNames(ctx, doltdb.DefaultSchemaName)
+	preMergeWorkingTables, err := preMergeWorkingRoot.GetTableNames(ctx, doltdb.DefaultSchemaName, true)
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/merge/fulltext_rebuild.go

@@ -39,7 +39,7 @@ type rebuildableFulltextTable struct {
 // roots (ours and theirs), or had parents that were modified by both roots.
 func rebuildFullTextIndexes(ctx *sql.Context, mergedRoot, ourRoot, theirRoot doltdb.RootValue, visitedTables map[string]struct{}) (doltdb.RootValue, error) {
 	// Grab a list of all tables on the root
-	allTableNames, err := mergedRoot.GetTableNames(ctx, doltdb.DefaultSchemaName)
+	allTableNames, err := mergedRoot.GetTableNames(ctx, doltdb.DefaultSchemaName, false)
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/merge/stash.go

@@ -61,7 +61,7 @@ func (s *violationStash) Empty() bool {
 }
 
 func stashConflicts(ctx context.Context, root doltdb.RootValue) (doltdb.RootValue, *conflictStash, error) {
-	names, err := root.GetTableNames(ctx, doltdb.DefaultSchemaName)
+	names, err := root.GetTableNames(ctx, doltdb.DefaultSchemaName, true)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -92,7 +92,7 @@ func stashConflicts(ctx context.Context, root doltdb.RootValue) (doltdb.RootValu
 }
 
 func stashViolations(ctx context.Context, root doltdb.RootValue) (doltdb.RootValue, *violationStash, error) {
-	names, err := root.GetTableNames(ctx, doltdb.DefaultSchemaName)
+	names, err := root.GetTableNames(ctx, doltdb.DefaultSchemaName, true)
 	if err != nil {
 		return nil, nil, err
 	}

go/libraries/doltcore/migrate/transform.go

@@ -375,12 +375,12 @@ func migrateRoot(ctx context.Context, menv Environment, oldParent, oldRoot, newP
 
 // renames also get returned here
 func getRemovedTableNames(ctx context.Context, prev, curr doltdb.RootValue) ([]string, error) {
-	prevNames, err := prev.GetTableNames(ctx, doltdb.DefaultSchemaName)
+	prevNames, err := prev.GetTableNames(ctx, doltdb.DefaultSchemaName, true)
 	if err != nil {
 		return nil, err
 	}
 	tblNameSet := set.NewStrSet(prevNames)
-	currNames, err := curr.GetTableNames(ctx, doltdb.DefaultSchemaName)
+	currNames, err := curr.GetTableNames(ctx, doltdb.DefaultSchemaName, true)
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/migrate/validation.go

@@ -54,7 +54,7 @@ func validateBranchMapping(ctx context.Context, old, new *doltdb.DoltDB) error {
 }
 
 func validateRootValue(ctx context.Context, oldParent, old, new doltdb.RootValue) error {
-	names, err := old.GetTableNames(ctx, doltdb.DefaultSchemaName)
+	names, err := old.GetTableNames(ctx, doltdb.DefaultSchemaName, true)
 	if err != nil {
 		return err
 	}

go/libraries/doltcore/sqle/commit_hooks_test.go

@@ -107,7 +107,7 @@ func TestPushOnWriteHook(t *testing.T) {
 
 	assert.NoError(t, err)
 
-	names, err := root.GetTableNames(context.Background(), doltdb.DefaultSchemaName)
+	names, err := root.GetTableNames(context.Background(), doltdb.DefaultSchemaName, true)
 	assert.NoError(t, err)
 	if len(names) != 0 {
 		t.Fatal("There should be no tables in empty db")

go/libraries/doltcore/sqle/database.go

@@ -996,7 +996,7 @@ func (db Database) GetTableNamesAsOf(ctx *sql.Context, time interface{}) ([]stri
 
 	showSystemTables := showSystemTablesVar.(int8) == 1
 
-	tblNames, err := db.getAllTableNames(ctx, root, showSystemTables)
+	tblNames, err := db.getAllTableNames(ctx, root, showSystemTables, true)
 	if err != nil {
 		return nil, err
 	}
@@ -1146,7 +1146,7 @@ func (db Database) tableInsensitive(ctx *sql.Context, root doltdb.RootValue, tab
 		}
 	}
 
-	tableNames, err := db.getAllTableNames(ctx, root, false)
+	tableNames, err := db.getAllTableNames(ctx, root, false, false)
 	if err != nil {
 		return doltdb.TableName{}, nil, false, err
 	}
@@ -1209,7 +1209,11 @@ func (db Database) GetTableNames(ctx *sql.Context) ([]string, error) {
 	}
 
 	showSystemTables := showSystemTablesVar.(int8) == 1
-	tblNames, err := db.GetAllTableNames(ctx, showSystemTables)
+	root, err := db.GetRoot(ctx)
+	if err != nil {
+		return nil, err
+	}
+	tblNames, err := db.getAllTableNames(ctx, root, showSystemTables, false)
 	if err != nil {
 		return nil, err
 	}
@@ -1234,10 +1238,10 @@ func (db Database) GetAllTableNames(ctx *sql.Context, showSystemTables bool) ([]
 		return nil, err
 	}
 
-	return db.getAllTableNames(ctx, root, showSystemTables)
+	return db.getAllTableNames(ctx, root, showSystemTables, true)
 }
 
-func (db Database) getAllTableNames(ctx *sql.Context, root doltdb.RootValue, includeGeneratedSystemTables bool) ([]string, error) {
+func (db Database) getAllTableNames(ctx *sql.Context, root doltdb.RootValue, includeGeneratedSystemTables bool, includeRootObjects bool) ([]string, error) {
 	var err error
 	var result []string
 	// If we are in a schema-enabled session and the schema name is not set, we need to union all table names in all
@@ -1251,7 +1255,7 @@ func (db Database) getAllTableNames(ctx *sql.Context, root doltdb.RootValue, inc
 		//  tables first
 		result = doltdb.FlattenTableNames(names)
 	} else {
-		result, err = root.GetTableNames(ctx, db.schemaName)
+		result, err = root.GetTableNames(ctx, db.schemaName, includeRootObjects)
 		if err != nil {
 			return nil, err
 		}

go/libraries/doltcore/sqle/dprocedures/dolt_conflicts_resolve.go

@@ -319,7 +319,7 @@ func resolveNomsConflicts(ctx *sql.Context, opts editor.Options, tbl *doltdb.Tab
 }
 
 func validateConstraintViolations(ctx *sql.Context, before, after doltdb.RootValue, table doltdb.TableName) error {
-	tables, err := after.GetTableNames(ctx, table.Schema)
+	tables, err := after.GetTableNames(ctx, table.Schema, true)
 	if err != nil {
 		return err
 	}

go/libraries/doltcore/sqle/dprocedures/dolt_verify_constraints.go

@@ -176,7 +176,7 @@ func parseTablesToCheck(ctx *sql.Context, workingRoot doltdb.RootValue, apr *arg
 	// If no tables were explicitly specified, then check all tables
 	if tableSet.Size() == 0 {
 		// TODO: schema search path
-		names, err := workingRoot.GetTableNames(ctx, doltdb.DefaultSchemaName)
+		names, err := workingRoot.GetTableNames(ctx, doltdb.DefaultSchemaName, true)
 		if err != nil {
 			return nil, err
 		}

go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_stat.go

@@ -385,6 +385,11 @@ func getDiffStatNodeFromDelta(ctx *sql.Context, delta diff.TableDelta, fromRoot,
 			return diffStatNode{}, false, err
 		}
 		oldColLen = len(fromSch.GetAllCols().GetColumns())
+	} else {
+		_, fromTableExists, err = fromRoot.GetRootObject(ctx, tableName)
+		if err != nil {
+			return diffStatNode{}, false, err
+		}
 	}
 
 	toTable, _, toTableExists, err := doltdb.GetTableInsensitive(ctx, toRoot, tableName)
@@ -398,14 +403,19 @@ func getDiffStatNodeFromDelta(ctx *sql.Context, delta diff.TableDelta, fromRoot,
 			return diffStatNode{}, false, err
 		}
 		newColLen = len(toSch.GetAllCols().GetColumns())
+	} else {
+		_, toTableExists, err = toRoot.GetRootObject(ctx, tableName)
+		if err != nil {
+			return diffStatNode{}, false, err
+		}
 	}
 
 	if !fromTableExists && !toTableExists {
 		return diffStatNode{}, false, sql.ErrTableNotFound.New(tableName)
 	}
 
 	// no diff from tableDelta
-	if delta.FromTable == nil && delta.ToTable == nil {
+	if delta.FromTable == nil && delta.ToTable == nil && delta.FromRootObject == nil && delta.ToRootObject == nil {
 		return diffStatNode{}, false, nil
 	}
 

go/libraries/doltcore/sqle/resolve/resolve_tables.go

@@ -64,7 +64,7 @@ func TablesOnSearchPath(ctx *sql.Context, root doltdb.RootValue) ([]doltdb.Table
 
 	var tableNames []doltdb.TableName
 	for _, schemaName := range schemasToSearch {
-		names, err := root.GetTableNames(ctx, schemaName)
+		names, err := root.GetTableNames(ctx, schemaName, true)
 		if err != nil {
 			return nil, err
 		}
@@ -86,7 +86,7 @@ func TableNameWithSearchPath(
 	}
 
 	for _, schemaName := range schemasToSearch {
-		tablesInSchema, err := root.GetTableNames(ctx, schemaName)
+		tablesInSchema, err := root.GetTableNames(ctx, schemaName, true)
 		if err != nil {
 			return doltdb.TableName{}, false, err
 		}

go/libraries/doltcore/sqle/resolve/search_path.go

@@ -97,7 +97,7 @@ func IsDoltgresSystemTable(ctx *sql.Context, tableName doltdb.TableName, root do
 			return true, nil
 		}
 
-		tablesInSchema, err := root.GetTableNames(ctx, schemaName)
+		tablesInSchema, err := root.GetTableNames(ctx, schemaName, true)
 		if err != nil {
 			return false, err
 		}

go/libraries/doltcore/sqle/resolve/system_tables.go

@@ -48,7 +48,7 @@ func GetGeneratedSystemTables(ctx context.Context, root doltdb.RootValue) ([]dol
 	}
 
 	for _, schema := range schemas {
-		tableNames, err := root.GetTableNames(ctx, schema.Name)
+		tableNames, err := root.GetTableNames(ctx, schema.Name, false)
 		if err != nil {
 			return nil, err
 		}

go/libraries/doltcore/sqle/user_space_database.go

@@ -74,7 +74,7 @@ func (db *UserSpaceDatabase) GetTableInsensitive(ctx *sql.Context, tableName str
 }
 
 func (db *UserSpaceDatabase) GetTableNames(ctx *sql.Context) ([]string, error) {
-	tableNames, err := db.RootValue.GetTableNames(ctx, doltdb.DefaultSchemaName)
+	tableNames, err := db.RootValue.GetTableNames(ctx, doltdb.DefaultSchemaName, true)
 	if err != nil {
 		return nil, err
 	}