From 429bd63be4dd17248981db1675e67a9218126fd2 Mon Sep 17 00:00:00 2001 From: Taylor Bantle Date: Wed, 2 Oct 2024 14:31:08 -0700 Subject: [PATCH 1/6] Fix dolt_diff function for tables in other schemas in doltgres --- .../doltcore/sqle/dolt_diff_table_function.go | 28 +++++++++---------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/go/libraries/doltcore/sqle/dolt_diff_table_function.go b/go/libraries/doltcore/sqle/dolt_diff_table_function.go index 219c326de7..4b1f953d18 100644 --- a/go/libraries/doltcore/sqle/dolt_diff_table_function.go +++ b/go/libraries/doltcore/sqle/dolt_diff_table_function.go @@ -486,20 +486,6 @@ func (dtf *DiffTableFunction) cacheTableDelta(ctx *sql.Context, fromCommitVal, t return diff.TableDelta{}, err } - fromTableName, fromTable, fromTableExists, err := resolve.Table(ctx, fromRefDetails.root, tableName) - if err != nil { - return diff.TableDelta{}, err - } - - toTableName, toTable, toTableExists, err := resolve.Table(ctx, toRefDetails.root, tableName) - if err != nil { - return diff.TableDelta{}, err - } - - if !fromTableExists && !toTableExists { - return diff.TableDelta{}, sql.ErrTableNotFound.New(tableName) - } - // TODO: it would be nice to limit this to just the table under consideration, not all tables with a diff deltas, err := diff.GetTableDeltas(ctx, fromRefDetails.root, toRefDetails.root) if err != nil { @@ -514,6 +500,20 @@ func (dtf *DiffTableFunction) cacheTableDelta(ctx *sql.Context, fromCommitVal, t // We only get a delta if there's a diff. When there isn't one, construct a delta here with table and schema info // TODO: schema name if delta.FromTable == nil && delta.ToTable == nil { + fromTableName, fromTable, fromTableExists, err := resolve.Table(ctx, fromRefDetails.root, tableName) + if err != nil { + return diff.TableDelta{}, err + } + + toTableName, toTable, toTableExists, err := resolve.Table(ctx, toRefDetails.root, tableName) + if err != nil { + return diff.TableDelta{}, err + } + + if !fromTableExists && !toTableExists { + return diff.TableDelta{}, sql.ErrTableNotFound.New(tableName) + } + delta.FromName = fromTableName delta.ToName = toTableName delta.FromTable = fromTable From 905c0372e9f8d234e9a0dd400dff3c60c39fff81 Mon Sep 17 00:00:00 2001 From: Taylor Bantle Date: Wed, 2 Oct 2024 15:14:30 -0700 Subject: [PATCH 2/6] Return schema.table for table_name columns in dolt diff functions and tables for doltgres --- .../sqle/dolt_diff_stat_table_function.go | 12 ++++++------ .../sqle/dolt_diff_summary_table_function.go | 10 +++++----- .../sqle/dolt_patch_table_function.go | 19 ++++++++++++++----- .../sqle/dolt_schema_diff_table_function.go | 8 ++++---- .../sqle/dtables/unscoped_diff_table.go | 4 ++-- 5 files changed, 31 insertions(+), 22 deletions(-) diff --git a/go/libraries/doltcore/sqle/dolt_diff_stat_table_function.go b/go/libraries/doltcore/sqle/dolt_diff_stat_table_function.go index 8897837aa3..7cddbfa2ad 100644 --- a/go/libraries/doltcore/sqle/dolt_diff_stat_table_function.go +++ b/go/libraries/doltcore/sqle/dolt_diff_stat_table_function.go @@ -318,7 +318,7 @@ func (ds *DiffStatTableFunction) RowIter(ctx *sql.Context, row sql.Row) (sql.Row if errors.Is(err, diff.ErrPrimaryKeySetChanged) { ctx.Warn(dtables.PrimaryKeyChangeWarningCode, fmt.Sprintf("stat for table %s cannot be determined. Primary key set changed.", tblName)) // Report an empty diff for tables that have primary key set changes - diffStats = append(diffStats, diffStatNode{tblName: tblName.Name}) + diffStats = append(diffStats, diffStatNode{tblName: tblName}) continue } return nil, err @@ -415,7 +415,7 @@ func getDiffStatNodeFromDelta(ctx *sql.Context, delta diff.TableDelta, fromRoot, return diffStatNode{}, false, err } - return diffStatNode{tableName.Name, diffStat, oldColLen, newColLen, keyless}, hasDiff, nil + return diffStatNode{tableName, diffStat, oldColLen, newColLen, keyless}, hasDiff, nil } // getDiffStat returns diff.DiffStatProgress object and whether there is a data diff or not. @@ -491,7 +491,7 @@ func (d *diffStatTableFunctionRowIter) incrementIndexes() { } type diffStatNode struct { - tblName string + tblName doltdb.TableName diffStat diff.DiffStatProgress oldColLen int newColLen int @@ -525,11 +525,11 @@ func (d *diffStatTableFunctionRowIter) Close(context *sql.Context) error { // getRowFromDiffStat takes diff.DiffStatProgress and calculates the row_modified, cell_added, cell_deleted. // If the number of cell change from old to new cell count does not equal to cell_added and/or cell_deleted, there // must be schema changes that affects cell_added and cell_deleted value addition to the row count * col length number. -func getRowFromDiffStat(tblName string, dsp diff.DiffStatProgress, newColLen, oldColLen int, keyless bool) sql.Row { +func getRowFromDiffStat(tblName doltdb.TableName, dsp diff.DiffStatProgress, newColLen, oldColLen int, keyless bool) sql.Row { // if table is keyless table, match current CLI command result if keyless { return sql.Row{ - tblName, // table_name + tblName.String(), // table_name nil, // rows_unmodified int64(dsp.Adds), // rows_added int64(dsp.Removes), // rows_deleted @@ -548,7 +548,7 @@ func getRowFromDiffStat(tblName string, dsp diff.DiffStatProgress, newColLen, ol rowsUnmodified := dsp.OldRowSize - dsp.Changes - dsp.Removes return sql.Row{ - tblName, // table_name + tblName.String(), // table_name int64(rowsUnmodified), // rows_unmodified int64(dsp.Adds), // rows_added int64(dsp.Removes), // rows_deleted diff --git a/go/libraries/doltcore/sqle/dolt_diff_summary_table_function.go b/go/libraries/doltcore/sqle/dolt_diff_summary_table_function.go index 974620c981..2edd641e4a 100644 --- a/go/libraries/doltcore/sqle/dolt_diff_summary_table_function.go +++ b/go/libraries/doltcore/sqle/dolt_diff_summary_table_function.go @@ -427,10 +427,10 @@ func (d *diffSummaryTableFunctionRowIter) Close(context *sql.Context) error { func getRowFromSummary(ds *diff.TableDeltaSummary) sql.Row { return sql.Row{ - ds.FromTableName.Name, // from_table_name - ds.ToTableName.Name, // to_table_name - ds.DiffType, // diff_type - ds.DataChange, // data_change - ds.SchemaChange, // schema_change + ds.FromTableName.String(), // from_table_name + ds.ToTableName.String(), // to_table_name + ds.DiffType, // diff_type + ds.DataChange, // data_change + ds.SchemaChange, // schema_change } } diff --git a/go/libraries/doltcore/sqle/dolt_patch_table_function.go b/go/libraries/doltcore/sqle/dolt_patch_table_function.go index cd6b712b76..d82e6bb519 100644 --- a/go/libraries/doltcore/sqle/dolt_patch_table_function.go +++ b/go/libraries/doltcore/sqle/dolt_patch_table_function.go @@ -29,6 +29,7 @@ import ( "golang.org/x/exp/slices" "github.com/dolthub/dolt/go/libraries/doltcore/diff" + "github.com/dolthub/dolt/go/libraries/doltcore/doltdb" "github.com/dolthub/dolt/go/libraries/doltcore/env" "github.com/dolthub/dolt/go/libraries/doltcore/schema" "github.com/dolthub/dolt/go/libraries/doltcore/sqle/dsess" @@ -475,7 +476,7 @@ func (p *PatchTableFunction) evaluateArguments() (interface{}, interface{}, inte } type patchNode struct { - tblName string + tblName doltdb.TableName schemaPatchStmts []string dataPatchStmts []string } @@ -500,7 +501,7 @@ func getPatchNodes(ctx *sql.Context, dbData env.DbData, tableDeltas []diff.Table } alterDBCollStmt := sqlfmt.AlterDatabaseCollateStmt(dbName, fromColl, toColl) patches = append(patches, &patchNode{ - tblName: td.FromName.Name, + tblName: td.FromName, schemaPatchStmts: []string{alterDBCollStmt}, dataPatchStmts: []string{}, }) @@ -529,7 +530,7 @@ func getPatchNodes(ctx *sql.Context, dbData env.DbData, tableDeltas []diff.Table } } - patches = append(patches, &patchNode{tblName: tblName.Name, schemaPatchStmts: schemaStmts, dataPatchStmts: dataStmts}) + patches = append(patches, &patchNode{tblName: tblName, schemaPatchStmts: schemaStmts, dataPatchStmts: dataStmts}) } return patches, nil @@ -739,7 +740,12 @@ func (itr *patchTableFunctionRowIter) Next(ctx *sql.Context) (sql.Row, error) { return nil, err } else { itr.statementIdx++ - r := sql.Row{itr.statementIdx, itr.fromRef, itr.toRef, itr.currentPatch.tblName} + r := sql.Row{ + itr.statementIdx, // statement_order + itr.fromRef, // from_commit_hash + itr.toRef, // to_commit_hash + itr.currentPatch.tblName.String(), // table_name + } return r.Append(row), nil } } @@ -789,7 +795,10 @@ func (p *patchStatementsRowIter) Next(ctx *sql.Context) (sql.Row, error) { diffType = diffTypeData } - return sql.Row{diffType, stmt}, nil + return sql.Row{ + diffType, // diff_type + stmt, // statement + }, nil } func (p *patchStatementsRowIter) Close(_ *sql.Context) error { diff --git a/go/libraries/doltcore/sqle/dolt_schema_diff_table_function.go b/go/libraries/doltcore/sqle/dolt_schema_diff_table_function.go index 71d85b3043..914f36733a 100644 --- a/go/libraries/doltcore/sqle/dolt_schema_diff_table_function.go +++ b/go/libraries/doltcore/sqle/dolt_schema_diff_table_function.go @@ -334,10 +334,10 @@ func (ds *SchemaDiffTableFunction) RowIter(ctx *sql.Context, row sql.Row) (sql.R } row := sql.Row{ - fromName.Name, // 0 - toName.Name, // 1 - fromCreate, // 2 - toCreate, // 3 + fromName.String(), // from_table_name + toName.String(), // to_table_name + fromCreate, // from_create_statement + toCreate, // to_create_statement } dataRows = append(dataRows, row) } diff --git a/go/libraries/doltcore/sqle/dtables/unscoped_diff_table.go b/go/libraries/doltcore/sqle/dtables/unscoped_diff_table.go index 920019913c..06ea3235ab 100644 --- a/go/libraries/doltcore/sqle/dtables/unscoped_diff_table.go +++ b/go/libraries/doltcore/sqle/dtables/unscoped_diff_table.go @@ -240,7 +240,7 @@ func (d *doltDiffWorkingSetRowItr) Next(ctx *sql.Context) (sql.Row, error) { sqlRow := sql.NewRow( changeSet, - change.TableName.Name, + change.TableName.String(), nil, // committer nil, // email nil, // date @@ -361,7 +361,7 @@ func (itr *doltDiffCommitHistoryRowItr) Next(ctx *sql.Context) (sql.Row, error) return sql.NewRow( h.String(), - tableChange.TableName.Name, + tableChange.TableName.String(), meta.Name, meta.Email, meta.Time(), From 755fc0ee9a7431dffb55d80823a4affedc841a1c Mon Sep 17 00:00:00 2001 From: Taylor Bantle Date: Wed, 2 Oct 2024 15:47:32 -0700 Subject: [PATCH 3/6] Return schema.table for table_name columns in dolt status table for doltgres --- go/libraries/doltcore/diff/table_deltas.go | 4 +-- go/libraries/doltcore/doltdb/workingset.go | 29 ++++++++++--------- go/libraries/doltcore/env/actions/commit.go | 2 +- .../dprocedures/dolt_conflicts_resolve.go | 14 ++++----- .../doltcore/sqle/dprocedures/dolt_merge.go | 3 +- .../sqle/dtables/merge_status_table.go | 5 ++-- .../sqle/dtables/schema_conflicts_table.go | 5 ++-- .../doltcore/sqle/dtables/status_table.go | 10 +++---- .../dtables/table_of_tables_in_conflict.go | 3 +- 9 files changed, 37 insertions(+), 38 deletions(-) diff --git a/go/libraries/doltcore/diff/table_deltas.go b/go/libraries/doltcore/diff/table_deltas.go index f082d1c9b7..172a8c029d 100644 --- a/go/libraries/doltcore/diff/table_deltas.go +++ b/go/libraries/doltcore/diff/table_deltas.go @@ -446,9 +446,9 @@ func (td TableDelta) HasChanges() (bool, error) { // CurName returns the most recent name of the table. func (td TableDelta) CurName() string { if td.ToName.Name != "" { - return td.ToName.Name + return td.ToName.String() } - return td.FromName.Name + return td.FromName.String() } func (td TableDelta) HasFKChanges() bool { diff --git a/go/libraries/doltcore/doltdb/workingset.go b/go/libraries/doltcore/doltdb/workingset.go index fd365878ea..28c9955d84 100755 --- a/go/libraries/doltcore/doltdb/workingset.go +++ b/go/libraries/doltcore/doltdb/workingset.go @@ -126,8 +126,8 @@ type MergeState struct { // the spec string that was used to specify |commit| commitSpecStr string preMergeWorking RootValue - unmergableTables []string // TODO: need schema name here - mergedTables []string // TODO: need schema name here + unmergableTables []TableName + mergedTables []TableName // isCherryPick is set to true when the in-progress merge is a cherry-pick. This is needed so that // commit knows to NOT create a commit with multiple parents when creating a commit for a cherry-pick. isCherryPick bool @@ -181,17 +181,17 @@ func (m MergeState) PreMergeWorkingRoot() RootValue { return m.preMergeWorking } -type SchemaConflictFn func(table string, conflict SchemaConflict) error +type SchemaConflictFn func(table TableName, conflict SchemaConflict) error func (m MergeState) HasSchemaConflicts() bool { return len(m.unmergableTables) > 0 } -func (m MergeState) TablesWithSchemaConflicts() []string { +func (m MergeState) TablesWithSchemaConflicts() []TableName { return m.unmergableTables } -func (m MergeState) MergedTables() []string { +func (m MergeState) MergedTables() []TableName { return m.mergedTables } @@ -224,7 +224,7 @@ func (m MergeState) IterSchemaConflicts(ctx context.Context, ddb *DoltDB, cb Sch for _, name := range m.unmergableTables { var sc SchemaConflict var hasToTable bool - if sc.toTbl, hasToTable, err = to.GetTable(ctx, TableName{Name: name}); err != nil { + if sc.toTbl, hasToTable, err = to.GetTable(ctx, name); err != nil { return err } if hasToTable { @@ -235,7 +235,7 @@ func (m MergeState) IterSchemaConflicts(ctx context.Context, ddb *DoltDB, cb Sch var hasFromTable bool // todo: handle schema conflicts for renamed tables - if sc.fromTbl, hasFromTable, err = from.GetTable(ctx, TableName{Name: name}); err != nil { + if sc.fromTbl, hasFromTable, err = from.GetTable(ctx, name); err != nil { return err } if hasFromTable { @@ -244,10 +244,10 @@ func (m MergeState) IterSchemaConflicts(ctx context.Context, ddb *DoltDB, cb Sch } } - sc.ToFks, _ = toFKs.KeysForTable(TableName{Name: name}) + sc.ToFks, _ = toFKs.KeysForTable(name) sc.ToParentSchemas = toSchemas - sc.FromFks, _ = fromFKs.KeysForTable(TableName{Name: name}) + sc.FromFks, _ = fromFKs.KeysForTable(name) sc.FromParentSchemas = fromSchemas if err = cb(name, sc); err != nil { @@ -296,12 +296,12 @@ func (ws WorkingSet) WithRebaseState(rebaseState *RebaseState) *WorkingSet { return &ws } -func (ws WorkingSet) WithUnmergableTables(tables []string) *WorkingSet { +func (ws WorkingSet) WithUnmergableTables(tables []TableName) *WorkingSet { ws.mergeState.unmergableTables = tables return &ws } -func (ws WorkingSet) WithMergedTables(tables []string) *WorkingSet { +func (ws WorkingSet) WithMergedTables(tables []TableName) *WorkingSet { ws.mergeState.mergedTables = tables return &ws } @@ -502,11 +502,14 @@ func newWorkingSet(ctx context.Context, name string, vrw types.ValueReadWriter, return nil, err } + // TODO: Schema name + unmergableTableNames := ToTableNames(unmergableTables, DefaultSchemaName) + mergeState = &MergeState{ commit: commit, commitSpecStr: commitSpec, preMergeWorking: preMergeWorkingRoot, - unmergableTables: unmergableTables, + unmergableTables: unmergableTableNames, isCherryPick: isCherryPick, } } @@ -618,7 +621,7 @@ func (ws *WorkingSet) writeValues(ctx context.Context, db *DoltDB, meta *datas.W return nil, err } - mergeState, err = datas.NewMergeState(ctx, db.vrw, preMergeWorking, dCommit, ws.mergeState.commitSpecStr, ws.mergeState.unmergableTables, ws.mergeState.isCherryPick) + mergeState, err = datas.NewMergeState(ctx, db.vrw, preMergeWorking, dCommit, ws.mergeState.commitSpecStr, FlattenTableNames(ws.mergeState.unmergableTables), ws.mergeState.isCherryPick) if err != nil { return nil, err } diff --git a/go/libraries/doltcore/env/actions/commit.go b/go/libraries/doltcore/env/actions/commit.go index 9e33b6a4fe..0bebcf21f5 100644 --- a/go/libraries/doltcore/env/actions/commit.go +++ b/go/libraries/doltcore/env/actions/commit.go @@ -95,7 +95,7 @@ func GetCommitStaged( if ws.MergeActive() { schConflicts := ws.MergeState().TablesWithSchemaConflicts() if len(schConflicts) > 0 { - return nil, NewTblSchemaConflictError(doltdb.ToTableNames(schConflicts, doltdb.DefaultSchemaName)) + return nil, NewTblSchemaConflictError(schConflicts) } } } diff --git a/go/libraries/doltcore/sqle/dprocedures/dolt_conflicts_resolve.go b/go/libraries/doltcore/sqle/dprocedures/dolt_conflicts_resolve.go index 23b2303837..6f0c7ff1c9 100644 --- a/go/libraries/doltcore/sqle/dprocedures/dolt_conflicts_resolve.go +++ b/go/libraries/doltcore/sqle/dprocedures/dolt_conflicts_resolve.go @@ -362,9 +362,9 @@ func ResolveSchemaConflicts(ctx *sql.Context, ddb *doltdb.DoltDB, ws *doltdb.Wor // TODO: schema names tblSet := set.NewStrSet(tables) - updates := make(map[string]*doltdb.Table) - err := ws.MergeState().IterSchemaConflicts(ctx, ddb, func(table string, conflict doltdb.SchemaConflict) error { - if !tblSet.Contains(table) { + updates := make(map[doltdb.TableName]*doltdb.Table) + err := ws.MergeState().IterSchemaConflicts(ctx, ddb, func(table doltdb.TableName, conflict doltdb.SchemaConflict) error { + if !tblSet.Contains(table.Name) { return nil } ours, theirs := conflict.GetConflictingTables() @@ -379,19 +379,19 @@ func ResolveSchemaConflicts(ctx *sql.Context, ddb *doltdb.DoltDB, ws *doltdb.Wor return nil, err } - var merged []string + var merged []doltdb.TableName root := ws.WorkingRoot() for name, tbl := range updates { - if root, err = root.PutTable(ctx, doltdb.TableName{Name: name}, tbl); err != nil { + if root, err = root.PutTable(ctx, name, tbl); err != nil { return nil, err } merged = append(merged, name) } // clear resolved schema conflicts - var unmerged []string + var unmerged []doltdb.TableName for _, tbl := range ws.MergeState().TablesWithSchemaConflicts() { - if tblSet.Contains(tbl) { + if tblSet.Contains(tbl.Name) { continue } unmerged = append(unmerged, tbl) diff --git a/go/libraries/doltcore/sqle/dprocedures/dolt_merge.go b/go/libraries/doltcore/sqle/dprocedures/dolt_merge.go index 863e47753a..d950141cd8 100644 --- a/go/libraries/doltcore/sqle/dprocedures/dolt_merge.go +++ b/go/libraries/doltcore/sqle/dprocedures/dolt_merge.go @@ -533,8 +533,7 @@ func mergeRootToWorking( if !squash || merged.HasSchemaConflicts() { ws = ws.StartMerge(cm2, cm2Spec) tt := merge.SchemaConflictTableNames(merged.SchemaConflicts) - // TODO: schema names - ws = ws.WithUnmergableTables(doltdb.FlattenTableNames(tt)) + ws = ws.WithUnmergableTables(tt) } ws = ws.WithWorkingRoot(working) diff --git a/go/libraries/doltcore/sqle/dtables/merge_status_table.go b/go/libraries/doltcore/sqle/dtables/merge_status_table.go index 7ac092fb83..b1c087d2b9 100644 --- a/go/libraries/doltcore/sqle/dtables/merge_status_table.go +++ b/go/libraries/doltcore/sqle/dtables/merge_status_table.go @@ -96,15 +96,14 @@ func newMergeStatusItr(ctx context.Context, ws *doltdb.WorkingSet) (*MergeStatus return nil, err } - var schConflicts []string + var schConflicts []doltdb.TableName if ws.MergeActive() { schConflicts = ws.MergeState().TablesWithSchemaConflicts() } unmergedTblNames := doltdb.NewTableNameSet(inConflict) unmergedTblNames.Add(tblsWithViolations...) - // TODO: schema name - unmergedTblNames.Add(doltdb.ToTableNames(schConflicts, doltdb.DefaultSchemaName)...) + unmergedTblNames.Add(schConflicts...) var sourceCommitSpecStr *string var sourceCommitHash *string diff --git a/go/libraries/doltcore/sqle/dtables/schema_conflicts_table.go b/go/libraries/doltcore/sqle/dtables/schema_conflicts_table.go index 10bad9b472..fb801c1372 100644 --- a/go/libraries/doltcore/sqle/dtables/schema_conflicts_table.go +++ b/go/libraries/doltcore/sqle/dtables/schema_conflicts_table.go @@ -118,9 +118,8 @@ func (dt *SchemaConflictsTable) PartitionRows(ctx *sql.Context, part sql.Partiti } var conflicts []schemaConflict - err = p.state.IterSchemaConflicts(ctx, p.ddb, func(table string, cnf doltdb.SchemaConflict) error { - // TODO: schema name - c, err := newSchemaConflict(ctx, doltdb.TableName{Name: table}, baseRoot, cnf) + err = p.state.IterSchemaConflicts(ctx, p.ddb, func(table doltdb.TableName, cnf doltdb.SchemaConflict) error { + c, err := newSchemaConflict(ctx, table, baseRoot, cnf) if err != nil { return err } diff --git a/go/libraries/doltcore/sqle/dtables/status_table.go b/go/libraries/doltcore/sqle/dtables/status_table.go index 398a719b68..135485ddbb 100644 --- a/go/libraries/doltcore/sqle/dtables/status_table.go +++ b/go/libraries/doltcore/sqle/dtables/status_table.go @@ -136,7 +136,7 @@ func newStatusItr(ctx *sql.Context, st *StatusTable) (*StatusItr, error) { for _, tbl := range cvTables { rows = append(rows, statusTableRow{ - tableName: tbl.Name, + tableName: tbl.String(), status: "constraint violation", }) } @@ -145,7 +145,7 @@ func newStatusItr(ctx *sql.Context, st *StatusTable) (*StatusItr, error) { ms := st.workingSet.MergeState() for _, tbl := range ms.TablesWithSchemaConflicts() { rows = append(rows, statusTableRow{ - tableName: tbl, + tableName: tbl.String(), isStaged: false, status: "schema conflict", }) @@ -153,7 +153,7 @@ func newStatusItr(ctx *sql.Context, st *StatusTable) (*StatusItr, error) { for _, tbl := range ms.MergedTables() { rows = append(rows, statusTableRow{ - tableName: tbl, + tableName: tbl.String(), isStaged: true, status: mergedStatus, }) @@ -166,7 +166,7 @@ func newStatusItr(ctx *sql.Context, st *StatusTable) (*StatusItr, error) { } for _, tbl := range cnfTables { rows = append(rows, statusTableRow{ - tableName: tbl.Name, + tableName: tbl.String(), status: mergeConflictStatus, }) } @@ -231,7 +231,7 @@ func schemaStatusString(sd diff.DatabaseSchemaDelta) string { func tableName(td diff.TableDelta) string { if td.IsRename() { - return fmt.Sprintf("%s -> %s", td.FromName, td.ToName) + return fmt.Sprintf("%s -> %s", td.FromName.String(), td.ToName.String()) } else { return td.CurName() } diff --git a/go/libraries/doltcore/sqle/dtables/table_of_tables_in_conflict.go b/go/libraries/doltcore/sqle/dtables/table_of_tables_in_conflict.go index 7489ca277a..69167bc1e5 100644 --- a/go/libraries/doltcore/sqle/dtables/table_of_tables_in_conflict.go +++ b/go/libraries/doltcore/sqle/dtables/table_of_tables_in_conflict.go @@ -129,8 +129,7 @@ func (dt *TableOfTablesInConflict) Partitions(ctx *sql.Context) (sql.PartitionIt if ws.MergeActive() { schConflicts := ws.MergeState().TablesWithSchemaConflicts() - // TODO: schema name - tblNames = append(tblNames, doltdb.ToTableNames(schConflicts, doltdb.DefaultSchemaName)...) + tblNames = append(tblNames, schConflicts...) } var partitions []*tableInConflict From 2362514859271722bb6348814373d219f267de48 Mon Sep 17 00:00:00 2001 From: Taylor Bantle Date: Wed, 2 Oct 2024 16:12:21 -0700 Subject: [PATCH 4/6] Return schema.table for table_name column in dolt column diff table for doltgres --- go/libraries/doltcore/sqle/dtables/column_diff_table.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/go/libraries/doltcore/sqle/dtables/column_diff_table.go b/go/libraries/doltcore/sqle/dtables/column_diff_table.go index 27b4417cdf..b66ea36f35 100644 --- a/go/libraries/doltcore/sqle/dtables/column_diff_table.go +++ b/go/libraries/doltcore/sqle/dtables/column_diff_table.go @@ -257,7 +257,7 @@ func (d *doltColDiffWorkingSetRowItr) Next(ctx *sql.Context) (sql.Row, error) { sqlRow := sql.NewRow( d.changeSet, - d.tableName.Name, + d.tableName.String(), d.colNames[d.colIndex], nil, // committer nil, // email @@ -364,7 +364,7 @@ func (itr *doltColDiffCommitHistoryRowItr) Next(ctx *sql.Context) (sql.Row, erro return sql.NewRow( h.String(), - tableChange.tableName.Name, + tableChange.tableName.String(), col, meta.Name, meta.Email, From d803b92517a94f16687764c59d02adc23976ce22 Mon Sep 17 00:00:00 2001 From: Taylor Bantle Date: Thu, 3 Oct 2024 11:53:59 -0700 Subject: [PATCH 5/6] PR feedback --- go/libraries/doltcore/doltdb/workingset.go | 2 +- .../dprocedures/dolt_conflicts_resolve.go | 32 +++++++++++++------ 2 files changed, 23 insertions(+), 11 deletions(-) diff --git a/go/libraries/doltcore/doltdb/workingset.go b/go/libraries/doltcore/doltdb/workingset.go index 28c9955d84..a7134ccdc0 100755 --- a/go/libraries/doltcore/doltdb/workingset.go +++ b/go/libraries/doltcore/doltdb/workingset.go @@ -502,7 +502,6 @@ func newWorkingSet(ctx context.Context, name string, vrw types.ValueReadWriter, return nil, err } - // TODO: Schema name unmergableTableNames := ToTableNames(unmergableTables, DefaultSchemaName) mergeState = &MergeState{ @@ -621,6 +620,7 @@ func (ws *WorkingSet) writeValues(ctx context.Context, db *DoltDB, meta *datas.W return nil, err } + // TODO: Serialize the full TableName mergeState, err = datas.NewMergeState(ctx, db.vrw, preMergeWorking, dCommit, ws.mergeState.commitSpecStr, FlattenTableNames(ws.mergeState.unmergableTables), ws.mergeState.isCherryPick) if err != nil { return nil, err diff --git a/go/libraries/doltcore/sqle/dprocedures/dolt_conflicts_resolve.go b/go/libraries/doltcore/sqle/dprocedures/dolt_conflicts_resolve.go index 6f0c7ff1c9..72bb17a17d 100644 --- a/go/libraries/doltcore/sqle/dprocedures/dolt_conflicts_resolve.go +++ b/go/libraries/doltcore/sqle/dprocedures/dolt_conflicts_resolve.go @@ -26,13 +26,14 @@ import ( "github.com/dolthub/dolt/go/libraries/doltcore/conflict" "github.com/dolthub/dolt/go/libraries/doltcore/doltdb" "github.com/dolthub/dolt/go/libraries/doltcore/doltdb/durable" + "github.com/dolthub/dolt/go/libraries/doltcore/env/actions" "github.com/dolthub/dolt/go/libraries/doltcore/merge" "github.com/dolthub/dolt/go/libraries/doltcore/row" "github.com/dolthub/dolt/go/libraries/doltcore/schema" "github.com/dolthub/dolt/go/libraries/doltcore/sqle/dsess" + "github.com/dolthub/dolt/go/libraries/doltcore/sqle/resolve" "github.com/dolthub/dolt/go/libraries/doltcore/table" "github.com/dolthub/dolt/go/libraries/doltcore/table/editor" - "github.com/dolthub/dolt/go/libraries/utils/set" "github.com/dolthub/dolt/go/store/hash" "github.com/dolthub/dolt/go/store/prolly" "github.com/dolthub/dolt/go/store/prolly/tree" @@ -339,7 +340,7 @@ func clearTableAndUpdateRoot(ctx *sql.Context, root doltdb.RootValue, tbl *doltd return newRoot, nil } -func ResolveSchemaConflicts(ctx *sql.Context, ddb *doltdb.DoltDB, ws *doltdb.WorkingSet, resolveOurs bool, tables []string) (*doltdb.WorkingSet, error) { +func ResolveSchemaConflicts(ctx *sql.Context, ddb *doltdb.DoltDB, ws *doltdb.WorkingSet, resolveOurs bool, tblNames []doltdb.TableName) (*doltdb.WorkingSet, error) { if !ws.MergeActive() { return ws, nil // no schema conflicts } @@ -360,11 +361,10 @@ func ResolveSchemaConflicts(ctx *sql.Context, ddb *doltdb.DoltDB, ws *doltdb.Wor "To track resolution of this limitation, follow https://github.com/dolthub/dolt/issues/6616") } - // TODO: schema names - tblSet := set.NewStrSet(tables) + tblSet := doltdb.NewTableNameSet(tblNames) updates := make(map[doltdb.TableName]*doltdb.Table) err := ws.MergeState().IterSchemaConflicts(ctx, ddb, func(table doltdb.TableName, conflict doltdb.SchemaConflict) error { - if !tblSet.Contains(table.Name) { + if !tblSet.Contains(table) { return nil } ours, theirs := conflict.GetConflictingTables() @@ -391,7 +391,7 @@ func ResolveSchemaConflicts(ctx *sql.Context, ddb *doltdb.DoltDB, ws *doltdb.Wor // clear resolved schema conflicts var unmerged []doltdb.TableName for _, tbl := range ws.MergeState().TablesWithSchemaConflicts() { - if tblSet.Contains(tbl.Name) { + if tblSet.Contains(tbl) { continue } unmerged = append(unmerged, tbl) @@ -501,16 +501,28 @@ func DoDoltConflictsResolve(ctx *sql.Context, args []string) (int, error) { // get all tables in conflict strTableNames := apr.Args + var tableNames []doltdb.TableName + if len(strTableNames) == 1 && strTableNames[0] == "." { - // TODO: schema names - all, err := ws.WorkingRoot().GetTableNames(ctx, doltdb.DefaultSchemaName) + all := actions.GetAllTableNames(ctx, ws.WorkingRoot()) if err != nil { return 1, nil } - strTableNames = all + tableNames = all + } else { + for _, tblName := range strTableNames { + tn, _, ok, err := resolve.Table(ctx, ws.WorkingRoot(), tblName) + if err != nil { + return 1, nil + } + if !ok { + return 1, doltdb.ErrTableNotFound + } + tableNames = append(tableNames, tn) + } } - ws, err = ResolveSchemaConflicts(ctx, ddb, ws, ours, strTableNames) + ws, err = ResolveSchemaConflicts(ctx, ddb, ws, ours, tableNames) if err != nil { return 1, err } From 4587cad37f628c5d9112b0be35be620ea0dbb508 Mon Sep 17 00:00:00 2001 From: Taylor Bantle Date: Thu, 3 Oct 2024 12:09:40 -0700 Subject: [PATCH 6/6] Fix --- .../doltcore/sqle/dprocedures/dolt_conflicts_resolve.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/go/libraries/doltcore/sqle/dprocedures/dolt_conflicts_resolve.go b/go/libraries/doltcore/sqle/dprocedures/dolt_conflicts_resolve.go index 72bb17a17d..dc8e28f83b 100644 --- a/go/libraries/doltcore/sqle/dprocedures/dolt_conflicts_resolve.go +++ b/go/libraries/doltcore/sqle/dprocedures/dolt_conflicts_resolve.go @@ -527,7 +527,7 @@ func DoDoltConflictsResolve(ctx *sql.Context, args []string) (int, error) { return 1, err } - err = ResolveDataConflicts(ctx, dSess, ws.WorkingRoot(), dbName, ours, doltdb.ToTableNames(strTableNames, doltdb.DefaultSchemaName)) + err = ResolveDataConflicts(ctx, dSess, ws.WorkingRoot(), dbName, ours, tableNames) if err != nil { return 1, err }