Merge pull request #6866 from dolthub/nicktobey/multidb

Store source database info in tables and columns.

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

@@ -181,7 +181,7 @@ func printConflicts(queryist cli.Queryist, sqlCtx *sql.Context, tblNames []strin
 			return fmt.Errorf("error: failed to get union schema for table '%s': %w", tblName, err)
 		}
 
-		sqlTargetSch, err := sqlutil.FromDoltSchema(tblName, targetSch)
+		sqlTargetSch, err := sqlutil.FromDoltSchema(sqlCtx.GetCurrentDatabase(), tblName, targetSch)
 		if err != nil {
 			return fmt.Errorf("error: failed to convert dolt schema to sql schema for table '%s': %w", tblName, err)
 		}

go/cmd/dolt/commands/diff.go

@@ -1190,14 +1190,14 @@ func diffRows(
 
 	var toSch, fromSch sql.Schema
 	if fromTableInfo != nil {
-		pkSch, err := sqlutil.FromDoltSchema(fromTableInfo.Name, fromTableInfo.Sch)
+		pkSch, err := sqlutil.FromDoltSchema(sqlCtx.GetCurrentDatabase(), fromTableInfo.Name, fromTableInfo.Sch)
 		if err != nil {
 			return errhand.VerboseErrorFromError(err)
 		}
 		fromSch = pkSch.Schema
 	}
 	if toTableInfo != nil {
-		pkSch, err := sqlutil.FromDoltSchema(toTableInfo.Name, toTableInfo.Sch)
+		pkSch, err := sqlutil.FromDoltSchema(sqlCtx.GetCurrentDatabase(), toTableInfo.Name, toTableInfo.Sch)
 		if err != nil {
 			return errhand.VerboseErrorFromError(err)
 		}

go/cmd/dolt/commands/indexcmds/cat.go

@@ -174,7 +174,7 @@ func (cmd CatCmd) prettyPrintResults(ctx context.Context, doltSch schema.Schema,
 }
 
 func getTableWriter(format resultFormat, sch schema.Schema) (wr table.SqlRowWriter, err error) {
-	s, err := sqlutil.FromDoltSchema("", sch)
+	s, err := sqlutil.FromDoltSchema("", "", sch)
 	if err != nil {
 		return nil, err
 	}

go/cmd/dolt/commands/tblcmds/import.go

@@ -615,7 +615,7 @@ func moveRows(
 	parsedRowChan chan sql.Row,
 	badRowCb badRowFn,
 ) error {
-	rdSqlSch, err := sqlutil.FromDoltSchema(options.destTableName, rd.GetSchema())
+	rdSqlSch, err := sqlutil.FromDoltSchema("", options.destTableName, rd.GetSchema())
 	if err != nil {
 		return err
 	}

go/go.mod

@@ -59,7 +59,7 @@ require (
 	github.com/cespare/xxhash v1.1.0
 	github.com/creasty/defaults v1.6.0
 	github.com/dolthub/flatbuffers/v23 v23.3.3-dh.2
-	github.com/dolthub/go-mysql-server v0.17.1-0.20231020200001-724edc96776e
+	github.com/dolthub/go-mysql-server v0.17.1-0.20231024163156-64b6f6b4e8a6
 	github.com/dolthub/swiss v0.1.0
 	github.com/goccy/go-json v0.10.2
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510

go/go.sum

@@ -181,8 +181,8 @@ github.com/dolthub/fslock v0.0.3 h1:iLMpUIvJKMKm92+N1fmHVdxJP5NdyDK5bK7z7Ba2s2U=
 github.com/dolthub/fslock v0.0.3/go.mod h1:QWql+P17oAAMLnL4HGB5tiovtDuAjdDTPbuqx7bYfa0=
 github.com/dolthub/go-icu-regex v0.0.0-20230524105445-af7e7991c97e h1:kPsT4a47cw1+y/N5SSCkma7FhAPw7KeGmD6c9PBZW9Y=
 github.com/dolthub/go-icu-regex v0.0.0-20230524105445-af7e7991c97e/go.mod h1:KPUcpx070QOfJK1gNe0zx4pA5sicIK1GMikIGLKC168=
-github.com/dolthub/go-mysql-server v0.17.1-0.20231020200001-724edc96776e h1:zjoXqtVX54fatUOwVhuIq+mjEFqDSSK3vdFCwo9Qh3M=
-github.com/dolthub/go-mysql-server v0.17.1-0.20231020200001-724edc96776e/go.mod h1:VUOsmnEkmp8TgBt0uIp6vuvtm20kRBS5DEbi8Khn9Xo=
+github.com/dolthub/go-mysql-server v0.17.1-0.20231024163156-64b6f6b4e8a6 h1:tDG1mrVFdHVY8Mr8gU8AjKE4NucWd/qxvBBm94nTMi4=
+github.com/dolthub/go-mysql-server v0.17.1-0.20231024163156-64b6f6b4e8a6/go.mod h1:VUOsmnEkmp8TgBt0uIp6vuvtm20kRBS5DEbi8Khn9Xo=
 github.com/dolthub/ishell v0.0.0-20221214210346-d7db0b066488 h1:0HHu0GWJH0N6a6keStrHhUAK5/o9LVfkh44pvsV4514=
 github.com/dolthub/ishell v0.0.0-20221214210346-d7db0b066488/go.mod h1:ehexgi1mPxRTk0Mok/pADALuHbvATulTh6gzr7NzZto=
 github.com/dolthub/jsonpath v0.0.2-0.20230525180605-8dc13778fd72 h1:NfWmngMi1CYUWU4Ix8wM+USEhjc+mhPlT9JUR/anvbQ=

go/libraries/doltcore/merge/fulltext_rebuild.go

@@ -26,7 +26,6 @@ import (
 	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb/durable"
 	"github.com/dolthub/dolt/go/libraries/doltcore/schema"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/index"
-	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/sqlutil"
 )
 
 // rebuildFullTextIndexes scans the entire root and rebuilds all of the pseudo-index tables. This is not the most
@@ -163,7 +162,7 @@ func rebuildFullTextIndexes(ctx *sql.Context, root *doltdb.RootValue) (*doltdb.R
 			ftEditor.StatementBegin(ctx)
 			defer ftEditor.StatementComplete(ctx)
 
-			rowIter, err := createRowIterForTable(ctx, tblName, tbl, sch)
+			rowIter, err := createRowIterForTable(ctx, tbl, sch)
 			if err != nil {
 				return err
 			}
@@ -209,12 +208,7 @@ func rebuildFullTextIndexes(ctx *sql.Context, root *doltdb.RootValue) (*doltdb.R
 	return root, nil
 }
 
-func createRowIterForTable(ctx *sql.Context, name string, t *doltdb.Table, sch schema.Schema) (sql.RowIter, error) {
-	sqlSch, err := sqlutil.FromDoltSchema(name, sch)
-	if err != nil {
-		return nil, err
-	}
-
+func createRowIterForTable(ctx *sql.Context, t *doltdb.Table, sch schema.Schema) (sql.RowIter, error) {
 	rowData, err := t.GetRowData(ctx)
 	if err != nil {
 		return nil, err
@@ -230,5 +224,5 @@ func createRowIterForTable(ctx *sql.Context, name string, t *doltdb.Table, sch s
 		return nil, err
 	}
 
-	return index.NewProllyRowIter(sch, sqlSch.Schema, rows, iter, nil)
+	return index.NewProllyRowIter(sch, rows, iter, nil)
 }

go/libraries/doltcore/merge/fulltext_table.go

@@ -54,7 +54,7 @@ func createFulltextTable(ctx *sql.Context, name string, root *doltdb.RootValue)
 	if err != nil {
 		return nil, err
 	}
-	sqlSch, err := sqlutil.FromDoltSchema(name, sch)
+	sqlSch, err := sqlutil.FromDoltSchema("", name, sch)
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/merge/merge_prolly_rows.go

@@ -1189,7 +1189,7 @@ func (m *secondaryMerger) finalize(ctx context.Context) (durable.IndexSet, durab
 // name of the table in |tableName|.
 func resolveExpression(ctx *sql.Context, expression string, sch schema.Schema, tableName string) (sql.Expression, error) {
 	query := fmt.Sprintf("SELECT %s from %s.%s", expression, "mydb", tableName)
-	sqlSch, err := sqlutil.FromDoltSchema(tableName, sch)
+	sqlSch, err := sqlutil.FromDoltSchema("", tableName, sch)
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/mvdata/engine_table_writer.go

@@ -100,12 +100,12 @@ func NewSqlEngineTableWriter(ctx context.Context, dEnv *env.DoltEnv, createTable
 	}
 	sqlCtx.SetCurrentDatabase(dbName)
 
-	doltCreateTableSchema, err := sqlutil.FromDoltSchema(options.TableToWriteTo, createTableSchema)
+	doltCreateTableSchema, err := sqlutil.FromDoltSchema("", options.TableToWriteTo, createTableSchema)
 	if err != nil {
 		return nil, err
 	}
 
-	doltRowOperationSchema, err := sqlutil.FromDoltSchema(options.TableToWriteTo, rowOperationSchema)
+	doltRowOperationSchema, err := sqlutil.FromDoltSchema("", options.TableToWriteTo, rowOperationSchema)
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/sqle/common_test.go

@@ -131,7 +131,7 @@ func equalSchemas(t *testing.T, expectedSch schema.Schema, sch schema.Schema) {
 
 // Returns the dolt schema given as a sql.Schema, or panics.
 func mustSqlSchema(sch schema.Schema) sql.Schema {
-	sqlSchema, err := sqlutil.FromDoltSchema("", sch)
+	sqlSchema, err := sqlutil.FromDoltSchema("", "", sch)
 	if err != nil {
 		panic(err)
 	}

go/libraries/doltcore/sqle/database.go

@@ -375,7 +375,7 @@ func (db Database) getTableInsensitive(ctx *sql.Context, head *doltdb.Commit, ds
 			}
 		}
 
-		dt, found = dtables.NewLogTable(ctx, db.ddb, head), true
+		dt, found = dtables.NewLogTable(ctx, db.RevisionQualifiedName(), db.ddb, head), true
 	case doltdb.DiffTableName:
 		if head == nil {
 			var err error
@@ -409,9 +409,9 @@ func (db Database) getTableInsensitive(ctx *sql.Context, head *doltdb.Commit, ds
 	case doltdb.RemotesTableName:
 		dt, found = dtables.NewRemotesTable(ctx, db.ddb), true
 	case doltdb.CommitsTableName:
-		dt, found = dtables.NewCommitsTable(ctx, db.ddb), true
+		dt, found = dtables.NewCommitsTable(ctx, db.RevisionQualifiedName(), db.ddb), true
 	case doltdb.CommitAncestorsTableName:
-		dt, found = dtables.NewCommitAncestorsTable(ctx, db.ddb), true
+		dt, found = dtables.NewCommitAncestorsTable(ctx, db.RevisionQualifiedName(), db.ddb), true
 	case doltdb.StatusTableName:
 		sess := dsess.DSessFromSess(ctx.Session)
 		adapter := dsess.NewSessionStateAdapter(

go/libraries/doltcore/sqle/dolt_diff_table_function.go

@@ -458,7 +458,7 @@ func (dtf *DiffTableFunction) generateSchema(ctx *sql.Context, fromCommitVal, to
 	//       This allows column projections to work correctly with table functions, but we will need to add a
 	//       unique id (e.g. hash generated from method arguments) when we add support for aliasing and joining
 	//       table functions in order for the analyzer to determine which table function result a column comes from.
-	sqlSchema, err := sqlutil.FromDoltSchema("", diffTableSch)
+	sqlSchema, err := sqlutil.FromDoltSchema("", "", diffTableSch)
 	if err != nil {
 		return err
 	}

go/libraries/doltcore/sqle/dolt_patch_table_function.go

@@ -215,7 +215,7 @@ func (p *PatchTableFunction) IndexedAccess(lookup sql.IndexLookup) sql.IndexedTa
 
 func (p *PatchTableFunction) GetIndexes(ctx *sql.Context) ([]sql.Index, error) {
 	return []sql.Index{
-		index.MockIndex(diffTypeColumnName, p.Name(), types.StringKind, false),
+		index.MockIndex(p.database.Name(), p.Name(), diffTypeColumnName, types.StringKind, false),
 	}, nil
 }
 
@@ -527,7 +527,7 @@ func getSchemaSqlPatch(ctx *sql.Context, toRoot *doltdb.RootValue, td diff.Table
 	if td.IsDrop() {
 		ddlStatements = append(ddlStatements, sqlfmt.DropTableStmt(td.FromName))
 	} else if td.IsAdd() {
-		toPkSch, err := sqlutil.FromDoltSchema(td.ToName, td.ToSch)
+		toPkSch, err := sqlutil.FromDoltSchema("", td.ToName, td.ToSch)
 		if err != nil {
 			return nil, err
 		}
@@ -572,7 +572,7 @@ func getUserTableDataSqlPatch(ctx *sql.Context, dbData env.DbData, td diff.Table
 		return nil, err
 	}
 
-	targetPkSch, err := sqlutil.FromDoltSchema(td.ToName, td.ToSch)
+	targetPkSch, err := sqlutil.FromDoltSchema("", td.ToName, td.ToSch)
 	if err != nil {
 		return nil, err
 	}
@@ -721,7 +721,7 @@ func getDiffQuery(ctx *sql.Context, dbData env.DbData, td diff.TableDelta, fromR
 	if err != nil {
 		return nil, nil, nil, err
 	}
-	diffPKSch, err := sqlutil.FromDoltSchema("", diffTableSchema)
+	diffPKSch, err := sqlutil.FromDoltSchema("", "", diffTableSchema)
 	if err != nil {
 		return nil, nil, nil, err
 	}

go/libraries/doltcore/sqle/dtables/commit_ancestors_table.go

@@ -30,7 +30,8 @@ const commitAncestorsDefaultRowCount = 100
 // CommitAncestorsTable is a sql.Table that implements a system table which
 // shows (commit, parent_commit) relationships for all commits in the repo.
 type CommitAncestorsTable struct {
-	ddb *doltdb.DoltDB
+	dbName string
+	ddb    *doltdb.DoltDB
 }
 
 var _ sql.Table = (*CommitAncestorsTable)(nil)
@@ -38,8 +39,8 @@ var _ sql.IndexAddressable = (*CommitAncestorsTable)(nil)
 var _ sql.StatisticsTable = (*CommitAncestorsTable)(nil)
 
 // NewCommitAncestorsTable creates a CommitAncestorsTable
-func NewCommitAncestorsTable(_ *sql.Context, ddb *doltdb.DoltDB) sql.Table {
-	return &CommitAncestorsTable{ddb: ddb}
+func NewCommitAncestorsTable(_ *sql.Context, dbName string, ddb *doltdb.DoltDB) sql.Table {
+	return &CommitAncestorsTable{dbName: dbName, ddb: ddb}
 }
 
 func (dt *CommitAncestorsTable) DataLength(ctx *sql.Context) (uint64, error) {
@@ -100,7 +101,7 @@ func (dt *CommitAncestorsTable) PartitionRows(ctx *sql.Context, p sql.Partition)
 
 // GetIndexes implements sql.IndexAddressable
 func (dt *CommitAncestorsTable) GetIndexes(ctx *sql.Context) ([]sql.Index, error) {
-	return index.DoltCommitIndexes(dt.Name(), dt.ddb, true)
+	return index.DoltCommitIndexes(dt.dbName, dt.Name(), dt.ddb, true)
 }
 
 // IndexedAccess implements sql.IndexAddressable

go/libraries/doltcore/sqle/dtables/commit_diff_table.go

@@ -76,7 +76,7 @@ func NewCommitDiffTable(ctx *sql.Context, tblName string, ddb *doltdb.DoltDB, ro
 		return nil, err
 	}
 
-	sqlSch, err := sqlutil.FromDoltSchema(diffTblName, diffTableSchema)
+	sqlSch, err := sqlutil.FromDoltSchema("", diffTblName, diffTableSchema)
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/sqle/dtables/commits_table.go

@@ -41,8 +41,8 @@ var _ sql.IndexAddressable = (*CommitsTable)(nil)
 var _ sql.StatisticsTable = (*CommitsTable)(nil)
 
 // NewCommitsTable creates a CommitsTable
-func NewCommitsTable(_ *sql.Context, ddb *doltdb.DoltDB) sql.Table {
-	return &CommitsTable{ddb: ddb}
+func NewCommitsTable(_ *sql.Context, dbName string, ddb *doltdb.DoltDB) sql.Table {
+	return &CommitsTable{dbName: dbName, ddb: ddb}
 }
 
 func (dt *CommitsTable) DataLength(ctx *sql.Context) (uint64, error) {
@@ -102,7 +102,7 @@ func (dt *CommitsTable) PartitionRows(ctx *sql.Context, p sql.Partition) (sql.Ro
 
 // GetIndexes implements sql.IndexAddressable
 func (dt *CommitsTable) GetIndexes(ctx *sql.Context) ([]sql.Index, error) {
-	return index.DoltCommitIndexes(dt.Name(), dt.ddb, true)
+	return index.DoltCommitIndexes(dt.dbName, dt.Name(), dt.ddb, true)
 }
 
 // IndexedAccess implements sql.IndexAddressable

go/libraries/doltcore/sqle/dtables/conflicts_tables.go

@@ -54,7 +54,7 @@ func newNomsConflictsTable(ctx *sql.Context, tbl *doltdb.Table, tblName string,
 	}
 	confSch := rd.GetSchema()
 
-	sqlSch, err := sqlutil.FromDoltSchema(doltdb.DoltConfTablePrefix+tblName, confSch)
+	sqlSch, err := sqlutil.FromDoltSchema("", doltdb.DoltConfTablePrefix+tblName, confSch)
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/sqle/dtables/conflicts_tables_prolly.go

@@ -51,7 +51,7 @@ func newProllyConflictsTable(ctx *sql.Context, tbl *doltdb.Table, sourceUpdatabl
 	if err != nil {
 		return nil, err
 	}
-	sqlSch, err := sqlutil.FromDoltSchema(doltdb.DoltConfTablePrefix+tblName, confSch)
+	sqlSch, err := sqlutil.FromDoltSchema("", doltdb.DoltConfTablePrefix+tblName, confSch)
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/sqle/dtables/constraint_violations.go

@@ -46,7 +46,7 @@ func newNomsCVTable(ctx *sql.Context, tblName string, root *doltdb.RootValue, rs
 	if err != nil {
 		return nil, err
 	}
-	sqlSch, err := sqlutil.FromDoltSchema(doltdb.DoltConstViolTablePrefix+tblName, cvSch)
+	sqlSch, err := sqlutil.FromDoltSchema("", doltdb.DoltConstViolTablePrefix+tblName, cvSch)
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/sqle/dtables/constraint_violations_prolly.go

@@ -43,7 +43,7 @@ func newProllyCVTable(ctx *sql.Context, tblName string, root *doltdb.RootValue,
 	if err != nil {
 		return nil, err
 	}
-	sqlSch, err := sqlutil.FromDoltSchema(doltdb.DoltConstViolTablePrefix+tblName, cvSch)
+	sqlSch, err := sqlutil.FromDoltSchema("", doltdb.DoltConstViolTablePrefix+tblName, cvSch)
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/sqle/dtables/diff_table.go

@@ -107,7 +107,7 @@ func NewDiffTable(ctx *sql.Context, tblName string, ddb *doltdb.DoltDB, root *do
 		return nil, err
 	}
 
-	sqlSch, err := sqlutil.FromDoltSchema(diffTblName, diffTableSchema)
+	sqlSch, err := sqlutil.FromDoltSchema("", diffTblName, diffTableSchema)
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/sqle/dtables/docs_table.go

@@ -33,8 +33,8 @@ var DoltDocsSqlSchema sql.PrimaryKeySchema
 var OldDoltDocsSqlSchema sql.PrimaryKeySchema
 
 func init() {
-	DoltDocsSqlSchema, _ = sqlutil.FromDoltSchema(doltdb.DocTableName, doltdb.DocsSchema)
-	OldDoltDocsSqlSchema, _ = sqlutil.FromDoltSchema(doltdb.DocTableName, doltdb.OldDocsSchema)
+	DoltDocsSqlSchema, _ = sqlutil.FromDoltSchema("", doltdb.DocTableName, doltdb.DocsSchema)
+	OldDoltDocsSqlSchema, _ = sqlutil.FromDoltSchema("", doltdb.DocTableName, doltdb.OldDocsSchema)
 }
 
 var _ sql.Table = (*DocsTable)(nil)

go/libraries/doltcore/sqle/dtables/log_table.go

@@ -33,6 +33,7 @@ const logsDefaultRowCount = 100
 
 // LogTable is a sql.Table implementation that implements a system table which shows the dolt commit log
 type LogTable struct {
+	dbName            string
 	ddb               *doltdb.DoltDB
 	head              *doltdb.Commit
 	headHash          hash.Hash
@@ -44,8 +45,8 @@ var _ sql.StatisticsTable = (*LogTable)(nil)
 var _ sql.IndexAddressable = (*LogTable)(nil)
 
 // NewLogTable creates a LogTable
-func NewLogTable(_ *sql.Context, ddb *doltdb.DoltDB, head *doltdb.Commit) sql.Table {
-	return &LogTable{ddb: ddb, head: head}
+func NewLogTable(_ *sql.Context, dbName string, ddb *doltdb.DoltDB, head *doltdb.Commit) sql.Table {
+	return &LogTable{dbName: dbName, ddb: ddb, head: head}
 }
 
 // DataLength implements sql.StatisticsTable
@@ -116,7 +117,7 @@ func (dt *LogTable) PartitionRows(ctx *sql.Context, p sql.Partition) (sql.RowIte
 }
 
 func (dt *LogTable) GetIndexes(ctx *sql.Context) ([]sql.Index, error) {
-	return index.DoltCommitIndexes(dt.Name(), dt.ddb, true)
+	return index.DoltCommitIndexes(dt.dbName, dt.Name(), dt.ddb, true)
 }
 
 // IndexedAccess implements sql.IndexAddressable

go/libraries/doltcore/sqle/dtables/schema_conflicts_table.go

@@ -193,7 +193,7 @@ func newSchemaConflict(ctx context.Context, table string, baseRoot *doltdb.RootV
 }
 
 func getCreateTableStatement(table string, sch schema.Schema, fks []doltdb.ForeignKey, parents map[string]schema.Schema) (string, error) {
-	pkSch, err := sqlutil.FromDoltSchema(table, sch)
+	pkSch, err := sqlutil.FromDoltSchema("", table, sch)
 	if err != nil {
 		return "", err
 	}

go/libraries/doltcore/sqle/dtables/unscoped_diff_table.go

@@ -141,7 +141,7 @@ func (dt *UnscopedDiffTable) PartitionRows(ctx *sql.Context, partition sql.Parti
 
 // GetIndexes implements sql.IndexAddressable
 func (dt *UnscopedDiffTable) GetIndexes(ctx *sql.Context) ([]sql.Index, error) {
-	return index.DoltCommitIndexes(dt.Name(), dt.ddb, true)
+	return index.DoltCommitIndexes(dt.dbName, dt.Name(), dt.ddb, true)
 }
 
 // IndexedAccess implements sql.IndexAddressable

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

@@ -3130,6 +3130,29 @@ var DoltBranchScripts = []queries.ScriptTest{
 			},
 		},
 	},
+	{
+		Name: "Join same table at two commits",
+		SetUpScript: []string{
+			"create table t (i int);",
+			"insert into t values (1);",
+			"call dolt_add('t');",
+			"call dolt_commit('-m', 'add t');",
+			"call dolt_branch('b1');",
+			"insert into t values (2);",
+			"call dolt_add('t');",
+			"call dolt_commit('-m', 'insert into t');",
+		},
+		Assertions: []queries.ScriptTestAssertion{
+			{
+				Query:    "select * from `mydb/b1`.t join t",
+				Expected: []sql.Row{{1, 1}, {1, 2}},
+			},
+			{
+				Query:    "select * from `mydb/b1`.t join `mydb/main`.t",
+				Expected: []sql.Row{{1, 1}, {1, 2}},
+			},
+		},
+	},
 }
 
 var DoltReset = []queries.ScriptTest{

go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go

@@ -965,7 +965,7 @@ inner join t on to_pk = t.pk;`,
 				Query: `
 SELECT to_pk, from_c1, to_c1, from_c1, to_c1, diff_type, diff_type
 from dolt_diff(@Commit1, @Commit2, 't') inner join dolt_diff(@Commit1, @Commit3, 't');`,
-				ExpectedErr: sql.ErrDuplicateAliasOrTable,
+				ExpectedErr: sql.ErrAmbiguousColumnName,
 			},
 			{
 				Query: `

go/libraries/doltcore/sqle/index/dolt_index.go

@@ -202,11 +202,11 @@ func DoltToFromCommitIndex(tbl string) sql.Index {
 
 // MockIndex returns a sql.Index that is not backed by an actual datastore. It's useful for system tables and
 // system table functions provide indexes but produce their rows at execution time based on the provided `IndexLookup`
-func MockIndex(columnName, tableName string, columnType types.NomsKind, unique bool) (index *doltIndex) {
+func MockIndex(dbName, tableName, columnName string, columnType types.NomsKind, unique bool) (index *doltIndex) {
 	return &doltIndex{
 		id:      columnName,
 		tblName: tableName,
-		dbName:  "",
+		dbName:  dbName,
 		columns: []schema.Column{
 			schema.NewColumn(columnName, 0, columnType, false),
 		},
@@ -221,13 +221,13 @@ func MockIndex(columnName, tableName string, columnType types.NomsKind, unique b
 	}
 }
 
-func DoltCommitIndexes(tab string, db *doltdb.DoltDB, unique bool) (indexes []sql.Index, err error) {
+func DoltCommitIndexes(dbName, tab string, db *doltdb.DoltDB, unique bool) (indexes []sql.Index, err error) {
 	if !types.IsFormat_DOLT(db.Format()) {
 		return nil, nil
 	}
 
 	return []sql.Index{
-		NewCommitIndex(MockIndex(CommitHashIndexId, tab, types.StringKind, unique)),
+		NewCommitIndex(MockIndex(dbName, tab, CommitHashIndexId, types.StringKind, unique)),
 	}, nil
 }
 
@@ -321,7 +321,7 @@ func DoltHistoryIndexesFromTable(ctx context.Context, db, tbl string, t *doltdb.
 		unorderedIndexes[i] = di
 	}
 
-	cmIdx, err := DoltCommitIndexes(tbl, ddb, false)
+	cmIdx, err := DoltCommitIndexes(db, tbl, ddb, false)
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/sqle/index/dolt_index_test.go

@@ -1065,7 +1065,7 @@ func TestDoltIndexBetween(t *testing.T) {
 			indexLookup, err := sqlIndex.Build(ctx)
 			require.NoError(t, err)
 
-			pkSch, err := sqlutil.FromDoltSchema("fake_table", idx.Schema())
+			pkSch, err := sqlutil.FromDoltSchema("", "fake_table", idx.Schema())
 			require.NoError(t, err)
 
 			dt, ok, err := root.GetTable(ctx, idx.Table())
@@ -1320,7 +1320,7 @@ func testDoltIndex(t *testing.T, ctx *sql.Context, root *doltdb.RootValue, keys
 	require.NoError(t, err)
 	require.True(t, ok)
 
-	pkSch, err := sqlutil.FromDoltSchema("fake_table", idx.Schema())
+	pkSch, err := sqlutil.FromDoltSchema("", "fake_table", idx.Schema())
 	require.NoError(t, err)
 
 	indexIter, err := index.RowIterForIndexLookup(ctx, NoCacheTableable{dt}, indexLookup, pkSch, nil)

go/libraries/doltcore/sqle/index/prolly_row_iter.go

@@ -27,7 +27,6 @@ type prollyRowIter struct {
 	iter prolly.MapIter
 	ns   tree.NodeStore
 
-	sqlSch  sql.Schema
 	keyDesc val.TupleDesc
 	valDesc val.TupleDesc
 
@@ -40,7 +39,7 @@ type prollyRowIter struct {
 
 var _ sql.RowIter = prollyRowIter{}
 
-func NewProllyRowIter(sch schema.Schema, sqlSch sql.Schema, rows prolly.Map, iter prolly.MapIter, projections []uint64) (sql.RowIter, error) {
+func NewProllyRowIter(sch schema.Schema, rows prolly.Map, iter prolly.MapIter, projections []uint64) (sql.RowIter, error) {
 	if projections == nil {
 		projections = sch.GetAllCols().Tags
 	}
@@ -61,7 +60,6 @@ func NewProllyRowIter(sch schema.Schema, sqlSch sql.Schema, rows prolly.Map, ite
 
 	return prollyRowIter{
 		iter:    iter,
-		sqlSch:  sqlSch,
 		keyDesc: kd,
 		valDesc: vd,
 		keyProj: keyProj,

go/libraries/doltcore/sqle/procedures_table.go

@@ -45,7 +45,7 @@ const (
 
 // The fixed SQL schema for the `dolt_procedures` table.
 func ProceduresTableSqlSchema() sql.PrimaryKeySchema {
-	sqlSchema, err := sqlutil.FromDoltSchema(doltdb.ProceduresTableName, ProceduresTableSchema())
+	sqlSchema, err := sqlutil.FromDoltSchema("", doltdb.ProceduresTableName, ProceduresTableSchema())
 	if err != nil {
 		panic(err) // should never happen
 	}

go/libraries/doltcore/sqle/rows.go

@@ -68,7 +68,7 @@ type doltTableRowIter struct {
 }
 
 // Returns a new row iterator for the table given
-func newRowIterator(ctx context.Context, tbl *doltdb.Table, sqlSch sql.Schema, projCols []uint64, partition doltTablePartition) (sql.RowIter, error) {
+func newRowIterator(ctx context.Context, tbl *doltdb.Table, projCols []uint64, partition doltTablePartition) (sql.RowIter, error) {
 	sch, err := tbl.GetSchema(ctx)
 
 	if err != nil {
@@ -76,7 +76,7 @@ func newRowIterator(ctx context.Context, tbl *doltdb.Table, sqlSch sql.Schema, p
 	}
 
 	if types.IsFormat_DOLT(tbl.Format()) {
-		return ProllyRowIterFromPartition(ctx, sch, sqlSch, projCols, partition)
+		return ProllyRowIterFromPartition(ctx, sch, projCols, partition)
 	}
 
 	mapIter, err := iterForPartition(ctx, partition)
@@ -180,7 +180,6 @@ func (itr *doltTableRowIter) Close(*sql.Context) error {
 func ProllyRowIterFromPartition(
 	ctx context.Context,
 	sch schema.Schema,
-	sqlSch sql.Schema,
 	projections []uint64,
 	partition doltTablePartition,
 ) (sql.RowIter, error) {
@@ -198,7 +197,7 @@ func ProllyRowIterFromPartition(
 		return nil, err
 	}
 
-	return index.NewProllyRowIter(sch, sqlSch, rows, iter, projections)
+	return index.NewProllyRowIter(sch, rows, iter, projections)
 }
 
 // SqlTableToRowIter returns a |sql.RowIter| for a full table scan for the given |table|. If
@@ -223,9 +222,8 @@ func SqlTableToRowIter(ctx *sql.Context, table *DoltTable, columns []uint64) (sq
 		end:     NoUpperBound,
 		rowData: data,
 	}
-	sqlSch := table.sqlSch.Schema
 
-	return newRowIterator(ctx, t, sqlSch, columns, p)
+	return newRowIterator(ctx, t, columns, p)
 }
 
 // DoltTablePartitionToRowIter returns a sql.RowIter for a partition of the clustered index of |table|.
@@ -234,7 +232,7 @@ func DoltTablePartitionToRowIter(ctx *sql.Context, name string, table *doltdb.Ta
 	if err != nil {
 		return nil, nil, err
 	}
-	pkSch, err := sqlutil.FromDoltSchema(name, sch)
+	pkSch, err := sqlutil.FromDoltSchema("", name, sch)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -257,7 +255,7 @@ func DoltTablePartitionToRowIter(ctx *sql.Context, name string, table *doltdb.Ta
 		if err != nil {
 			return nil, nil, err
 		}
-		rowIter, err := index.NewProllyRowIter(sch, pkSch.Schema, idx, iter, nil)
+		rowIter, err := index.NewProllyRowIter(sch, idx, iter, nil)
 		if err != nil {
 			return nil, nil, err
 		}

go/libraries/doltcore/sqle/sqlutil/convert.go

@@ -26,7 +26,10 @@ import (
 	"github.com/dolthub/dolt/go/store/types"
 )
 
-func FromDoltSchema(tableName string, sch schema.Schema) (sql.PrimaryKeySchema, error) {
+// TODO: Many callers only care about field names and types, not the table or db names.
+// Those callers may be passing in "" for these values, or may be passing in incorrect values
+// that are currently unused.
+func FromDoltSchema(dbName, tableName string, sch schema.Schema) (sql.PrimaryKeySchema, error) {
 	cols := make(sql.Schema, sch.GetAllCols().Size())
 
 	var i int
@@ -43,15 +46,16 @@ func FromDoltSchema(tableName string, sch schema.Schema) (sql.PrimaryKeySchema,
 		}
 
 		cols[i] = &sql.Column{
-			Name:          col.Name,
-			Type:          sqlType,
-			Default:       deflt,
-			Nullable:      col.IsNullable(),
-			Source:        tableName,
-			PrimaryKey:    col.IsPartOfPK,
-			AutoIncrement: col.AutoIncrement,
-			Comment:       col.Comment,
-			Extra:         extra,
+			Name:           col.Name,
+			Type:           sqlType,
+			Default:        deflt,
+			Nullable:       col.IsNullable(),
+			DatabaseSource: dbName,
+			Source:         tableName,
+			PrimaryKey:     col.IsPartOfPK,
+			AutoIncrement:  col.AutoIncrement,
+			Comment:        col.Comment,
+			Extra:          extra,
 		}
 		i++
 		return false, nil

go/libraries/doltcore/sqle/tables.go

@@ -103,7 +103,7 @@ func NewDoltTable(name string, sch schema.Schema, tbl *doltdb.Table, db dsess.Sq
 		return
 	})
 
-	sqlSch, err := sqlutil.FromDoltSchema(name, sch)
+	sqlSch, err := sqlutil.FromDoltSchema(db.Name(), name, sch)
 	if err != nil {
 		return nil, err
 	}
@@ -145,7 +145,7 @@ func (t *DoltTable) LockedToRoot(ctx *sql.Context, root *doltdb.RootValue) (sql.
 		return
 	})
 
-	sqlSch, err := sqlutil.FromDoltSchema(t.tableName, sch)
+	sqlSch, err := sqlutil.FromDoltSchema("", t.tableName, sch)
 	if err != nil {
 		return nil, err
 	}
@@ -363,7 +363,7 @@ func (t *DoltTable) sqlSchema() sql.PrimaryKeySchema {
 	}
 
 	// TODO: fix panics
-	sqlSch, err := sqlutil.FromDoltSchema(t.tableName, t.sch)
+	sqlSch, err := sqlutil.FromDoltSchema(t.db.RevisionQualifiedName(), t.tableName, t.sch)
 	if err != nil {
 		panic(err)
 	}
@@ -422,15 +422,15 @@ func (t *DoltTable) PartitionRows(ctx *sql.Context, partition sql.Partition) (sq
 		return nil, err
 	}
 
-	return partitionRows(ctx, table, t.sqlSch.Schema, t.projectedCols, partition)
+	return partitionRows(ctx, table, t.projectedCols, partition)
 }
 
-func partitionRows(ctx *sql.Context, t *doltdb.Table, sqlSch sql.Schema, projCols []uint64, partition sql.Partition) (sql.RowIter, error) {
+func partitionRows(ctx *sql.Context, t *doltdb.Table, projCols []uint64, partition sql.Partition) (sql.RowIter, error) {
 	switch typedPartition := partition.(type) {
 	case doltTablePartition:
-		return newRowIterator(ctx, t, sqlSch, projCols, typedPartition)
+		return newRowIterator(ctx, t, projCols, typedPartition)
 	case index.SinglePartition:
-		return newRowIterator(ctx, t, sqlSch, projCols, doltTablePartition{rowData: typedPartition.RowData, end: NoUpperBound})
+		return newRowIterator(ctx, t, projCols, doltTablePartition{rowData: typedPartition.RowData, end: NoUpperBound})
 	}
 
 	return nil, errors.New("unsupported partition type")
@@ -2134,7 +2134,7 @@ func (t *AlterableDoltTable) getFirstAutoIncrementValue(
 
 	// Note that we aren't calling the public PartitionRows, because it always gets the table data from the session
 	// root, which hasn't been updated yet
-	rowIter, err := partitionRows(ctx, table, t.sqlSch.Schema, t.projectedCols, index.SinglePartition{RowData: rowData})
+	rowIter, err := partitionRows(ctx, table, t.projectedCols, index.SinglePartition{RowData: rowData})
 	if err != nil {
 		return 0, err
 	}

go/libraries/doltcore/sqle/temp_table.go

@@ -254,7 +254,7 @@ func (t *TempTable) PartitionRows(ctx *sql.Context, partition sql.Partition) (sq
 	if !t.lookup.IsEmpty() {
 		return index.RowIterForIndexLookup(ctx, t, t.lookup, t.pkSch, nil)
 	} else {
-		return partitionRows(ctx, t.table, t.sqlSchema().Schema, nil, partition)
+		return partitionRows(ctx, t.table, nil, partition)
 	}
 }
 

go/libraries/doltcore/sqle/writer/noms_write_session.go

@@ -109,7 +109,7 @@ func (s *nomsWriteSession) GetTableWriter(ctx *sql.Context, table, db string, se
 	if err != nil {
 		return nil, err
 	}
-	sqlSch, err := sqlutil.FromDoltSchema(table, sch)
+	sqlSch, err := sqlutil.FromDoltSchema("", table, sch)
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/sqle/writer/prolly_table_writer.go

@@ -284,7 +284,7 @@ func (w *prollyTableWriter) IndexedAccess(i sql.IndexLookup) sql.IndexedTable {
 
 // Reset puts the writer into a fresh state, updating the schema and index writers according to the newly given table.
 func (w *prollyTableWriter) Reset(ctx context.Context, sess *prollyWriteSession, tbl *doltdb.Table, sch schema.Schema) error {
-	sqlSch, err := sqlutil.FromDoltSchema(w.tableName, sch)
+	sqlSch, err := sqlutil.FromDoltSchema("", w.tableName, sch)
 	if err != nil {
 		return err
 	}

go/libraries/doltcore/sqle/writer/prolly_write_session.go

@@ -60,7 +60,7 @@ func (s *prollyWriteSession) GetTableWriter(ctx *sql.Context, table, db string,
 	if err != nil {
 		return nil, err
 	}
-	pkSch, err := sqlutil.FromDoltSchema(table, sch)
+	pkSch, err := sqlutil.FromDoltSchema("", table, sch)
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/table/table_iterator.go

@@ -22,7 +22,6 @@ import (
 	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb/durable"
 	"github.com/dolthub/dolt/go/libraries/doltcore/schema"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/index"
-	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/sqlutil"
 	"github.com/dolthub/dolt/go/store/types"
 )
 
@@ -72,11 +71,7 @@ func NewTableIterator(ctx context.Context, sch schema.Schema, idx durable.Index,
 		if err != nil {
 			return nil, err
 		}
-		s, err := sqlutil.FromDoltSchema("", sch)
-		if err != nil {
-			return nil, err
-		}
-		rowItr, err = index.NewProllyRowIter(sch, s.Schema, m, itr, nil)
+		rowItr, err = index.NewProllyRowIter(sch, m, itr, nil)
 		if err != nil {
 			return nil, err
 		}

go/libraries/doltcore/table/typed/json/reader_test.go

@@ -78,7 +78,7 @@ func TestReader(t *testing.T) {
 	sch, err := schema.SchemaFromCols(colColl)
 	require.NoError(t, err)
 
-	sqlSch, err := sqlutil.FromDoltSchema("", sch)
+	sqlSch, err := sqlutil.FromDoltSchema("", "", sch)
 	require.NoError(t, err)
 
 	vrw := types.NewMemoryValueStore()

go/libraries/doltcore/table/typed/parquet/writer.go

@@ -71,7 +71,7 @@ func NewParquetRowWriter(outSch sql.Schema, w io.WriteCloser) (*ParquetRowWriter
 // NewParquetRowWriterForFile creates a new ParquetRowWriter instance for the specified schema and
 // writing to the specified file name.
 func NewParquetRowWriterForFile(outSch schema.Schema, destName string) (*ParquetRowWriter, error) {
-	primaryKeySchema, err := sqlutil.FromDoltSchema("", outSch)
+	primaryKeySchema, err := sqlutil.FromDoltSchema("", "", outSch)
 	if err != nil {
 		return nil, err
 	}