Merge pull request #8116 from dolthub/macneale4/empty-dolt-tables

Return empty dolt_procedures and dolt_schemas tables when we previously returned an error.

In addition, no longer allow user updates to these tables. For this reason, this is a breaking change.

go/cmd/dolt/commands/diff.go

@@ -385,14 +385,14 @@ func getTableNamesAtRef(queryist cli.Queryist, sqlCtx *sql.Context, ref string)
 		if err != nil {
 			return nil, fmt.Errorf("error interpolating query: %w", err)
 		}
-		_, err = GetRowsForSql(queryist, sqlCtx, interpolatedQuery)
-		if err == nil {
-			tableNames[sysTable] = true
-		} else if isTableNotFoundError(err) {
-			continue
-		} else {
+		result, err := GetRowsForSql(queryist, sqlCtx, interpolatedQuery)
+		if err != nil {
 			return nil, fmt.Errorf("error getting system table %s: %w", sysTable, err)
 		}
+
+		if len(result) > 0 {
+			tableNames[sysTable] = true
+		}
 	}
 
 	return tableNames, nil

go/libraries/doltcore/doltdb/system_table.go

@@ -236,9 +236,6 @@ const (
 const (
 	// SchemasTableName is the name of the dolt schema fragment table
 	SchemasTableName = "dolt_schemas"
-	// SchemasTablesIdCol is an incrementing integer that represents the insertion index.
-	// Deprecated: This column is no longer used and will be removed in a future release.
-	SchemasTablesIdCol = "id"
 	// SchemasTablesTypeCol is the name of the column that stores the type of a schema fragment  in the dolt_schemas table
 	SchemasTablesTypeCol = "type"
 	// SchemasTablesNameCol The name of the column that stores the name of a schema fragment in the dolt_schemas table

go/libraries/doltcore/sqle/database.go

@@ -499,6 +499,33 @@ func (db Database) getTableInsensitive(ctx *sql.Context, head *doltdb.Commit, ds
 		}
 	case doltdb.StatisticsTableName:
 		dt, found = dtables.NewStatisticsTable(ctx, db.Name(), db.ddb, asOf), true
+	case doltdb.ProceduresTableName:
+		found = true
+		backingTable, _, err := db.getTable(ctx, root, doltdb.ProceduresTableName)
+		if err != nil {
+			return nil, false, err
+		}
+		if backingTable == nil {
+			dt = NewEmptyProceduresTable()
+		} else {
+			writeTable := backingTable.(*WritableDoltTable)
+			dt = NewProceduresTable(writeTable)
+		}
+	case doltdb.SchemasTableName:
+		found = true
+		backingTable, _, err := db.getTable(ctx, root, doltdb.SchemasTableName)
+		if err != nil {
+			return nil, false, err
+		}
+		if backingTable == nil {
+			dt = NewEmptySchemaTable()
+		} else {
+			writeTable := backingTable.(*WritableDoltTable)
+			dt, err = NewSchemaTable(ctx, db, writeTable)
+			if err != nil {
+				return nil, false, err
+			}
+		}
 	}
 
 	if found {
@@ -1407,16 +1434,22 @@ func (db Database) GetViewDefinition(ctx *sql.Context, viewName string) (sql.Vie
 		}
 	}
 
-	tbl, ok, err := db.GetTableInsensitive(ctx, doltdb.SchemasTableName)
+	tbl, _, err := db.GetTableInsensitive(ctx, doltdb.SchemasTableName)
 	if err != nil {
 		return sql.ViewDefinition{}, false, err
 	}
+
+	wrapper, ok := tbl.(*SchemaTable)
 	if !ok {
+		return sql.ViewDefinition{}, false, fmt.Errorf("expected a SchemaTable, but found %T", tbl)
+	}
+
+	if wrapper.backingTable == nil {
 		dbState.SessionCache().CacheViews(key, nil, db.schemaName)
 		return sql.ViewDefinition{}, false, nil
 	}
 
-	views, viewDef, found, err := getViewDefinitionFromSchemaFragmentsOfView(ctx, tbl.(*WritableDoltTable), viewName)
+	views, viewDef, found, err := getViewDefinitionFromSchemaFragmentsOfView(ctx, wrapper.backingTable, viewName)
 	if err != nil {
 		return sql.ViewDefinition{}, false, err
 	}
@@ -1464,15 +1497,20 @@ func getViewDefinitionFromSchemaFragmentsOfView(ctx *sql.Context, tbl *WritableD
 
 // AllViews implements sql.ViewDatabase
 func (db Database) AllViews(ctx *sql.Context) ([]sql.ViewDefinition, error) {
-	tbl, ok, err := db.GetTableInsensitive(ctx, doltdb.SchemasTableName)
+	tbl, _, err := db.GetTableInsensitive(ctx, doltdb.SchemasTableName)
 	if err != nil {
 		return nil, err
 	}
+
+	wrapper, ok := tbl.(*SchemaTable)
 	if !ok {
+		return nil, fmt.Errorf("expected a SchemaTable, but found %T", tbl)
+	}
+	if wrapper.backingTable == nil {
 		return nil, nil
 	}
 
-	views, _, _, err := getViewDefinitionFromSchemaFragmentsOfView(ctx, tbl.(*WritableDoltTable), "")
+	views, _, _, err := getViewDefinitionFromSchemaFragmentsOfView(ctx, wrapper.backingTable, "")
 	if err != nil {
 		return nil, err
 	}
@@ -1524,15 +1562,21 @@ func (db Database) GetTriggers(ctx *sql.Context) ([]sql.TriggerDefinition, error
 		dbState.SessionCache().CacheTriggers(key, triggers, db.schemaName)
 	}()
 
-	tbl, ok, err := db.GetTableInsensitive(ctx, doltdb.SchemasTableName)
+	tbl, _, err := db.GetTableInsensitive(ctx, doltdb.SchemasTableName)
 	if err != nil {
 		return nil, err
 	}
+
+	wrapper, ok := tbl.(*SchemaTable)
 	if !ok {
+		return nil, fmt.Errorf("expected a SchemaTable, but found %T", tbl)
+	}
+
+	if wrapper.backingTable == nil {
 		return nil, nil
 	}
 
-	frags, err := getSchemaFragmentsOfType(ctx, tbl.(*WritableDoltTable), triggerFragment)
+	frags, err := getSchemaFragmentsOfType(ctx, wrapper.backingTable, triggerFragment)
 	if err != nil {
 		return nil, err
 	}
@@ -1571,15 +1615,20 @@ func (db Database) DropTrigger(ctx *sql.Context, name string) error {
 
 // GetEvent implements sql.EventDatabase.
 func (db Database) GetEvent(ctx *sql.Context, name string) (sql.EventDefinition, bool, error) {
-	tbl, ok, err := db.GetTableInsensitive(ctx, doltdb.SchemasTableName)
+	tbl, _, err := db.GetTableInsensitive(ctx, doltdb.SchemasTableName)
 	if err != nil {
 		return sql.EventDefinition{}, false, err
 	}
+
+	wrapper, ok := tbl.(*SchemaTable)
 	if !ok {
+		return sql.EventDefinition{}, false, fmt.Errorf("expected a SchemaTable, but found %T", tbl)
+	}
+	if wrapper.backingTable == nil {
 		return sql.EventDefinition{}, false, nil
 	}
 
-	frags, err := getSchemaFragmentsOfType(ctx, tbl.(*WritableDoltTable), eventFragment)
+	frags, err := getSchemaFragmentsOfType(ctx, wrapper.backingTable, eventFragment)
 	if err != nil {
 		return sql.EventDefinition{}, false, err
 	}
@@ -1598,16 +1647,21 @@ func (db Database) GetEvent(ctx *sql.Context, name string) (sql.EventDefinition,
 
 // GetEvents implements sql.EventDatabase.
 func (db Database) GetEvents(ctx *sql.Context) (events []sql.EventDefinition, token interface{}, err error) {
-	tbl, ok, err := db.GetTableInsensitive(ctx, doltdb.SchemasTableName)
+	tbl, _, err := db.GetTableInsensitive(ctx, doltdb.SchemasTableName)
 	if err != nil {
 		return nil, nil, err
 	}
+	wrapper, ok := tbl.(*SchemaTable)
 	if !ok {
+		return nil, nil, fmt.Errorf("expected a SchemaTable, but found %T", tbl)
+	}
+
+	if wrapper.backingTable == nil {
 		// If the dolt_schemas table doesn't exist, it's not an error, just no events
 		return nil, nil, nil
 	}
 
-	frags, err := getSchemaFragmentsOfType(ctx, tbl.(*WritableDoltTable), eventFragment)
+	frags, err := getSchemaFragmentsOfType(ctx, wrapper.backingTable, eventFragment)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -1844,15 +1898,20 @@ func (db Database) dropFragFromSchemasTable(ctx *sql.Context, fragType, name str
 		db.schemaName = schemaName
 	}
 
-	stbl, found, err := db.GetTableInsensitive(ctx, doltdb.SchemasTableName)
+	stbl, _, err := db.GetTableInsensitive(ctx, doltdb.SchemasTableName)
 	if err != nil {
 		return err
 	}
-	if !found {
+
+	swrapper, ok := stbl.(*SchemaTable)
+	if !ok {
+		return fmt.Errorf("expected a SchemaTable, but found %T", stbl)
+	}
+	if swrapper.backingTable == nil {
 		return missingErr
 	}
 
-	tbl := stbl.(*WritableDoltTable)
+	tbl := swrapper.backingTable
 	row, exists, err := fragFromSchemasTable(ctx, tbl, fragType, name)
 	if err != nil {
 		return err
@@ -1886,6 +1945,13 @@ func (db Database) dropTableIfEmpty(ctx *sql.Context, tableName string) error {
 		return nil
 	}
 
+	if wrapped, ok := stbl.(WritableDoltTableWrapper); ok {
+		stbl = wrapped.UnWrap()
+		if stbl == nil {
+			return nil
+		}
+	}
+
 	table, err := stbl.(*WritableDoltTable).DoltTable.DoltTable(ctx)
 	if err != nil {
 		return err