From 55d4130692a2af087f4256504b4e7dc742b4b479 Mon Sep 17 00:00:00 2001 From: Tan Yong Zhi Date: Mon, 5 Sep 2022 10:59:54 +0800 Subject: [PATCH 1/7] Add dolt diff --skinny flag --- go/cmd/dolt/commands/diff.go | 110 ++++++++++++++++++++++++++++++----- 1 file changed, 94 insertions(+), 16 deletions(-) diff --git a/go/cmd/dolt/commands/diff.go b/go/cmd/dolt/commands/diff.go index 17d7482aa9..e07e93238e 100644 --- a/go/cmd/dolt/commands/diff.go +++ b/go/cmd/dolt/commands/diff.go @@ -60,6 +60,7 @@ const ( limitParam = "limit" SQLFlag = "sql" CachedFlag = "cached" + SkinnyFlag = "skinny" ) var diffDocs = cli.CommandDocumentationContent{ @@ -96,6 +97,7 @@ type diffArgs struct { tableSet *set.StrSet limit int where string + skinny bool } type DiffCmd struct{} @@ -129,6 +131,7 @@ func (cmd DiffCmd) ArgParser() *argparser.ArgParser { ap.SupportsString(whereParam, "", "column", "filters columns based on values in the diff. See {{.EmphasisLeft}}dolt diff --help{{.EmphasisRight}} for details.") ap.SupportsInt(limitParam, "", "record_count", "limits to the first N diffs.") ap.SupportsFlag(CachedFlag, "c", "Show only the unstaged data changes.") + ap.SupportsFlag(SkinnyFlag, "sk", "Shows only the primary key and the rows that changed") return ap } @@ -184,6 +187,8 @@ func parseDiffArgs(ctx context.Context, dEnv *env.DoltEnv, apr *argparser.ArgPar dArgs.diffParts = Summary } + dArgs.skinny = apr.Contains(SkinnyFlag) + f := apr.GetValueOrDefault(FormatFlag, "tabular") switch strings.ToLower(f) { case "tabular": @@ -613,9 +618,42 @@ func diffRows( defer rowIter.Close(sqlCtx) - err = writeDiffResults(sqlCtx, sch, unionSch, rowIter, rowWriter) - if err != nil { - return errhand.BuildDError("Error running diff query:\n%s", query).AddCause(err).Build() + if dArgs.skinny { + oldRows, newRows, modifiedColNames, err := getDiffRows(sqlCtx, sch, rowIter, unionSch, dArgs.skinny) + if err != nil { + return errhand.BuildDError("Error running diff query:\n%s", query).AddCause(err).Build() + } + + // instantiate a new schema that only contains the columns with changes + var filteredUnionSch sql.Schema + for _, s := range unionSch { + for colName := range modifiedColNames { + if strings.Contains(s.Name, colName) { + filteredUnionSch = append(filteredUnionSch, s) + } + } + } + + // instantiate a new RowWriter with the new schema that only contains the columns with changes + rowWriter, err = dw.RowWriter(ctx, td, filteredUnionSch) + if err != nil { + return errhand.VerboseErrorFromError(err) + } + + writeFilteredResults(sqlCtx, oldRows, newRows, rowWriter) + if err != nil { + return errhand.BuildDError("Error running diff query:\n%s", query).AddCause(err).Build() + } + } else { + oldRows, newRows, _, err := getDiffRows(sqlCtx, sch, rowIter, unionSch, dArgs.skinny) + if err != nil { + return errhand.BuildDError("Error running diff query:\n%s", query).AddCause(err).Build() + } + + writeFilteredResults(sqlCtx, oldRows, newRows, rowWriter) + if err != nil { + return errhand.BuildDError("Error running diff query:\n%s", query).AddCause(err).Build() + } } return nil @@ -651,31 +689,69 @@ func getColumnNamesString(fromSch, toSch schema.Schema) string { return strings.Join(cols, ",") } -func writeDiffResults( - ctx *sql.Context, +func getDiffRows( + sqlCtx *sql.Context, diffQuerySch sql.Schema, - targetSch sql.Schema, - iter sql.RowIter, - writer diff.SqlRowDiffWriter, -) error { - ds, err := newDiffSplitter(diffQuerySch, targetSch) + rowIter sql.RowIter, + unionSch sql.Schema, + filterChangedCols bool, +) ([]rowDiff, []rowDiff, map[string]bool, error) { + oldRows, newRows := []rowDiff{}, []rowDiff{} + modifiedColNames := make(map[string]bool) + + ds, err := newDiffSplitter(diffQuerySch, unionSch) if err != nil { - return err + return oldRows, newRows, modifiedColNames, err } for { - r, err := iter.Next(ctx) + r, err := rowIter.Next(sqlCtx) if err == io.EOF { - return writer.Close(ctx) - } else if err != nil { - return err + break } oldRow, newRow, err := ds.splitDiffResultRow(r) if err != nil { - return err + return oldRows, newRows, modifiedColNames, err } + if filterChangedCols { + var filteredOldRow, filteredNewRow rowDiff + for i, changeType := range oldRow.colDiffs { + if changeType != diff.None || unionSch[i].PrimaryKey { + modifiedColNames[unionSch[i].Name] = true + + filteredOldRow.row = append(filteredOldRow.row, oldRow.row[i]) + filteredOldRow.colDiffs = append(filteredOldRow.colDiffs, oldRow.colDiffs[i]) + filteredOldRow.rowDiff = oldRow.rowDiff + + filteredNewRow.row = append(filteredNewRow.row, newRow.row[i]) + filteredNewRow.colDiffs = append(filteredNewRow.colDiffs, newRow.colDiffs[i]) + filteredNewRow.rowDiff = newRow.rowDiff + } + } + + oldRows = append(oldRows, filteredOldRow) + newRows = append(newRows, filteredNewRow) + } else { + oldRows = append(oldRows, oldRow) + newRows = append(newRows, newRow) + } + } + + return oldRows, newRows, modifiedColNames, nil +} + +func writeFilteredResults( + ctx *sql.Context, + oldRows []rowDiff, + newRows []rowDiff, + writer diff.SqlRowDiffWriter, +) error { + for i := range oldRows { + oldRow := oldRows[i] + newRow := newRows[i] + if oldRow.row != nil { err := writer.WriteRow(ctx, oldRow.row, oldRow.rowDiff, oldRow.colDiffs) if err != nil { @@ -690,4 +766,6 @@ func writeDiffResults( } } } + + return writer.Close(ctx) } From f8ff89b47156368d4d68cb8a1b12d09ab3ad79c9 Mon Sep 17 00:00:00 2001 From: Tan Yong Zhi Date: Mon, 5 Sep 2022 14:33:37 +0800 Subject: [PATCH 2/7] Add test --- integration-tests/bats/diff.bats | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/integration-tests/bats/diff.bats b/integration-tests/bats/diff.bats index 8b90a0b88d..9b6ba153b6 100644 --- a/integration-tests/bats/diff.bats +++ b/integration-tests/bats/diff.bats @@ -720,6 +720,24 @@ SQL [[ "$output" = 'UPDATE `t` SET `val1`=30,`val3`=4 WHERE `pk`=1;' ]] || false } +@test "diff: skinny flag only shows row changed" { + dolt sql -q "create table t(pk int primary key, val1 int, val2 int)" + dolt add . + dolt sql -q "INSERT INTO t VALUES (1, 1, 1)" + dolt commit -am "cm1" + + dolt sql -q "UPDATE t SET val1=2 where pk=1" + dolt commit -am "cm2" + + dolt sql -q "UPDATE t SET val1=3 where pk=1" + dolt commit -am "cm3" + + run dolt diff --skinny HEAD~1 + [ $status -eq 0 ] + [[ ! "$output" =~ 'val2' ]] || false + [[ "$output" =~ 'val1' ]] || false +} + @test "diff: keyless sql diffs" { dolt sql -q "create table t(pk int, val int)" From 74edb799faeb5b19d79a5c15f8f6c477b6dd403c Mon Sep 17 00:00:00 2001 From: Tan Yong Zhi Date: Fri, 9 Sep 2022 21:21:44 +0800 Subject: [PATCH 3/7] Address reviewer comments --- go/cmd/dolt/commands/diff.go | 114 ++++++++++++++++++++--------------- 1 file changed, 64 insertions(+), 50 deletions(-) diff --git a/go/cmd/dolt/commands/diff.go b/go/cmd/dolt/commands/diff.go index e07e93238e..c051e5c07d 100644 --- a/go/cmd/dolt/commands/diff.go +++ b/go/cmd/dolt/commands/diff.go @@ -131,7 +131,7 @@ func (cmd DiffCmd) ArgParser() *argparser.ArgParser { ap.SupportsString(whereParam, "", "column", "filters columns based on values in the diff. See {{.EmphasisLeft}}dolt diff --help{{.EmphasisRight}} for details.") ap.SupportsInt(limitParam, "", "record_count", "limits to the first N diffs.") ap.SupportsFlag(CachedFlag, "c", "Show only the unstaged data changes.") - ap.SupportsFlag(SkinnyFlag, "sk", "Shows only the primary key and the rows that changed") + ap.SupportsFlag(SkinnyFlag, "sk", "Shows only primary key columns and any columns with data changes.") return ap } @@ -558,6 +558,7 @@ func diffRows( if err != nil { return errhand.VerboseErrorFromError(err) } + defer rowWriter.Close(ctx) // can't diff if !diffable { @@ -619,7 +620,7 @@ func diffRows( defer rowIter.Close(sqlCtx) if dArgs.skinny { - oldRows, newRows, modifiedColNames, err := getDiffRows(sqlCtx, sch, rowIter, unionSch, dArgs.skinny) + modifiedColNames, err := getModifiedCols(sqlCtx, rowIter, unionSch, sch) if err != nil { return errhand.BuildDError("Error running diff query:\n%s", query).AddCause(err).Build() } @@ -639,21 +640,22 @@ func diffRows( if err != nil { return errhand.VerboseErrorFromError(err) } + defer rowWriter.Close(ctx) - writeFilteredResults(sqlCtx, oldRows, newRows, rowWriter) - if err != nil { - return errhand.BuildDError("Error running diff query:\n%s", query).AddCause(err).Build() - } - } else { - oldRows, newRows, _, err := getDiffRows(sqlCtx, sch, rowIter, unionSch, dArgs.skinny) - if err != nil { + // reset the row iterator + rowIter.Close(sqlCtx) + _, rowIter, err = se.Query(sqlCtx, query) + if sql.ErrSyntaxError.Is(err) { + return errhand.BuildDError("Failed to parse diff query. Invalid where clause?\nDiff query: %s", query).AddCause(err).Build() + } else if err != nil { return errhand.BuildDError("Error running diff query:\n%s", query).AddCause(err).Build() } + defer rowIter.Close(sqlCtx) + } - writeFilteredResults(sqlCtx, oldRows, newRows, rowWriter) - if err != nil { - return errhand.BuildDError("Error running diff query:\n%s", query).AddCause(err).Build() - } + err = writeDiffResults(sqlCtx, sch, unionSch, rowIter, rowWriter, dArgs.skinny) + if err != nil { + return errhand.BuildDError("Error running diff query:\n%s", query).AddCause(err).Build() } return nil @@ -689,38 +691,36 @@ func getColumnNamesString(fromSch, toSch schema.Schema) string { return strings.Join(cols, ",") } -func getDiffRows( - sqlCtx *sql.Context, +func writeDiffResults( + ctx *sql.Context, diffQuerySch sql.Schema, - rowIter sql.RowIter, - unionSch sql.Schema, + targetSch sql.Schema, + iter sql.RowIter, + writer diff.SqlRowDiffWriter, filterChangedCols bool, -) ([]rowDiff, []rowDiff, map[string]bool, error) { - oldRows, newRows := []rowDiff{}, []rowDiff{} - modifiedColNames := make(map[string]bool) - - ds, err := newDiffSplitter(diffQuerySch, unionSch) +) error { + ds, err := newDiffSplitter(diffQuerySch, targetSch) if err != nil { - return oldRows, newRows, modifiedColNames, err + return err } for { - r, err := rowIter.Next(sqlCtx) + r, err := iter.Next(ctx) if err == io.EOF { - break + return nil + } else if err != nil { + return err } oldRow, newRow, err := ds.splitDiffResultRow(r) if err != nil { - return oldRows, newRows, modifiedColNames, err + return err } if filterChangedCols { var filteredOldRow, filteredNewRow rowDiff for i, changeType := range oldRow.colDiffs { - if changeType != diff.None || unionSch[i].PrimaryKey { - modifiedColNames[unionSch[i].Name] = true - + if changeType != diff.None || targetSch[i].PrimaryKey { filteredOldRow.row = append(filteredOldRow.row, oldRow.row[i]) filteredOldRow.colDiffs = append(filteredOldRow.colDiffs, oldRow.colDiffs[i]) filteredOldRow.rowDiff = oldRow.rowDiff @@ -731,26 +731,9 @@ func getDiffRows( } } - oldRows = append(oldRows, filteredOldRow) - newRows = append(newRows, filteredNewRow) - } else { - oldRows = append(oldRows, oldRow) - newRows = append(newRows, newRow) + oldRow = filteredOldRow + newRow = filteredNewRow } - } - - return oldRows, newRows, modifiedColNames, nil -} - -func writeFilteredResults( - ctx *sql.Context, - oldRows []rowDiff, - newRows []rowDiff, - writer diff.SqlRowDiffWriter, -) error { - for i := range oldRows { - oldRow := oldRows[i] - newRow := newRows[i] if oldRow.row != nil { err := writer.WriteRow(ctx, oldRow.row, oldRow.rowDiff, oldRow.colDiffs) @@ -766,6 +749,37 @@ func writeFilteredResults( } } } - - return writer.Close(ctx) +} + +func getModifiedCols( + ctx *sql.Context, + iter sql.RowIter, + unionSch sql.Schema, + diffQuerySch sql.Schema, +) (map[string]bool, error) { + modifiedColNames := make(map[string]bool) + for { + r, err := iter.Next(ctx) + if err == io.EOF { + break + } + + ds, err := newDiffSplitter(diffQuerySch, unionSch) + if err != nil { + return modifiedColNames, err + } + + oldRow, _, err := ds.splitDiffResultRow(r) + if err != nil { + return modifiedColNames, err + } + + for i, changeType := range oldRow.colDiffs { + if changeType != diff.None || unionSch[i].PrimaryKey { + modifiedColNames[unionSch[i].Name] = true + } + } + } + + return modifiedColNames, nil } From 5ab5f499fcd85af0f2546decfb5d4c26c8f8bd99 Mon Sep 17 00:00:00 2001 From: Tan Yong Zhi Date: Sat, 10 Sep 2022 20:26:42 +0800 Subject: [PATCH 4/7] Address reviewer comments --- go/cmd/dolt/commands/diff.go | 49 +++++++++++------ integration-tests/bats/diff.bats | 91 ++++++++++++++++++++++++++++++-- 2 files changed, 121 insertions(+), 19 deletions(-) diff --git a/go/cmd/dolt/commands/diff.go b/go/cmd/dolt/commands/diff.go index c051e5c07d..6c9864acd2 100644 --- a/go/cmd/dolt/commands/diff.go +++ b/go/cmd/dolt/commands/diff.go @@ -558,7 +558,6 @@ func diffRows( if err != nil { return errhand.VerboseErrorFromError(err) } - defer rowWriter.Close(ctx) // can't diff if !diffable { @@ -618,9 +617,11 @@ func diffRows( } defer rowIter.Close(sqlCtx) + defer rowWriter.Close(ctx) + var modifiedColNames map[string]bool if dArgs.skinny { - modifiedColNames, err := getModifiedCols(sqlCtx, rowIter, unionSch, sch) + modifiedColNames, err = getModifiedCols(sqlCtx, rowIter, unionSch, sch) if err != nil { return errhand.BuildDError("Error running diff query:\n%s", query).AddCause(err).Build() } @@ -629,7 +630,7 @@ func diffRows( var filteredUnionSch sql.Schema for _, s := range unionSch { for colName := range modifiedColNames { - if strings.Contains(s.Name, colName) { + if s.Name == colName { filteredUnionSch = append(filteredUnionSch, s) } } @@ -643,17 +644,20 @@ func diffRows( defer rowWriter.Close(ctx) // reset the row iterator - rowIter.Close(sqlCtx) + err = rowIter.Close(sqlCtx) + if err != nil { + return errhand.BuildDError("Error closing row iterator:\n%s", query).AddCause(err).Build() + } _, rowIter, err = se.Query(sqlCtx, query) + defer rowIter.Close(sqlCtx) if sql.ErrSyntaxError.Is(err) { return errhand.BuildDError("Failed to parse diff query. Invalid where clause?\nDiff query: %s", query).AddCause(err).Build() } else if err != nil { return errhand.BuildDError("Error running diff query:\n%s", query).AddCause(err).Build() } - defer rowIter.Close(sqlCtx) } - err = writeDiffResults(sqlCtx, sch, unionSch, rowIter, rowWriter, dArgs.skinny) + err = writeDiffResults(sqlCtx, sch, unionSch, rowIter, rowWriter, modifiedColNames, dArgs.skinny) if err != nil { return errhand.BuildDError("Error running diff query:\n%s", query).AddCause(err).Build() } @@ -697,6 +701,7 @@ func writeDiffResults( targetSch sql.Schema, iter sql.RowIter, writer diff.SqlRowDiffWriter, + modifiedColNames map[string]bool, filterChangedCols bool, ) error { ds, err := newDiffSplitter(diffQuerySch, targetSch) @@ -719,15 +724,19 @@ func writeDiffResults( if filterChangedCols { var filteredOldRow, filteredNewRow rowDiff - for i, changeType := range oldRow.colDiffs { - if changeType != diff.None || targetSch[i].PrimaryKey { - filteredOldRow.row = append(filteredOldRow.row, oldRow.row[i]) - filteredOldRow.colDiffs = append(filteredOldRow.colDiffs, oldRow.colDiffs[i]) - filteredOldRow.rowDiff = oldRow.rowDiff + for i, changeType := range newRow.colDiffs { + if (changeType == diff.Added|diff.Removed) || modifiedColNames[targetSch[i].Name] { + if i < len(oldRow.row) { + filteredOldRow.row = append(filteredOldRow.row, oldRow.row[i]) + filteredOldRow.colDiffs = append(filteredOldRow.colDiffs, oldRow.colDiffs[i]) + filteredOldRow.rowDiff = oldRow.rowDiff + } - filteredNewRow.row = append(filteredNewRow.row, newRow.row[i]) - filteredNewRow.colDiffs = append(filteredNewRow.colDiffs, newRow.colDiffs[i]) - filteredNewRow.rowDiff = newRow.rowDiff + if i < len(newRow.row) { + filteredNewRow.row = append(filteredNewRow.row, newRow.row[i]) + filteredNewRow.colDiffs = append(filteredNewRow.colDiffs, newRow.colDiffs[i]) + filteredNewRow.rowDiff = newRow.rowDiff + } } } @@ -751,6 +760,10 @@ func writeDiffResults( } } +// getModifiedCols returns a set of the names of columns that are modified, as well as the name of the primary key for a particular row iterator and schema. +// In the case where rows are added or removed, all columns will be included +// unionSch refers to a joint schema between the schema before and after any schema changes pertaining to the diff, +// while diffQuerySch refers to the schema returned by the "dolt_diff" sql query. func getModifiedCols( ctx *sql.Context, iter sql.RowIter, @@ -769,11 +782,17 @@ func getModifiedCols( return modifiedColNames, err } - oldRow, _, err := ds.splitDiffResultRow(r) + oldRow, newRow, err := ds.splitDiffResultRow(r) if err != nil { return modifiedColNames, err } + for i, changeType := range newRow.colDiffs { + if changeType != diff.None || unionSch[i].PrimaryKey { + modifiedColNames[unionSch[i].Name] = true + } + } + for i, changeType := range oldRow.colDiffs { if changeType != diff.None || unionSch[i].PrimaryKey { modifiedColNames[unionSch[i].Name] = true diff --git a/integration-tests/bats/diff.bats b/integration-tests/bats/diff.bats index 9b6ba153b6..e8a4235ea5 100644 --- a/integration-tests/bats/diff.bats +++ b/integration-tests/bats/diff.bats @@ -720,16 +720,22 @@ SQL [[ "$output" = 'UPDATE `t` SET `val1`=30,`val3`=4 WHERE `pk`=1;' ]] || false } -@test "diff: skinny flag only shows row changed" { - dolt sql -q "create table t(pk int primary key, val1 int, val2 int)" +@test "diff: skinny flag only shows row changed without schema changes" { + dolt sql -q "CREATE TABLE t(pk int primary key, val1 int, val2 int)" dolt add . dolt sql -q "INSERT INTO t VALUES (1, 1, 1)" dolt commit -am "cm1" - dolt sql -q "UPDATE t SET val1=2 where pk=1" + run dolt diff --skinny --data HEAD~1 + [ $status -eq 0 ] + [[ "$output" =~ 'pk' ]] || false + [[ "$output" =~ 'val1' ]] || false + [[ "$output" =~ 'val2' ]] || false + + dolt sql -q "UPDATE t SET val1=2 WHERE pk=1" dolt commit -am "cm2" - dolt sql -q "UPDATE t SET val1=3 where pk=1" + dolt sql -q "UPDATE t SET val1=3 WHERE pk=1" dolt commit -am "cm3" run dolt diff --skinny HEAD~1 @@ -738,6 +744,83 @@ SQL [[ "$output" =~ 'val1' ]] || false } +@test "diff: skinny flag only shows row changed when both schema (column added) and data is changed (row updated)" { + dolt sql -q "create table t(pk int primary key, val1 int, val2 int)" + dolt add . + dolt sql -q "INSERT INTO t VALUES (1, 1, 1)" + dolt sql -q "INSERT INTO t VALUES (2, 2, 2)" + dolt commit -am "cm1" + + run dolt diff --skinny --data HEAD~1 + [ $status -eq 0 ] + [[ "$output" =~ 'pk' ]] || false + [[ "$output" =~ 'val1' ]] || false + [[ "$output" =~ 'val2' ]] || false + + dolt sql -q "UPDATE t SET val1=3 WHERE pk=1" + dolt sql -q "ALTER TABLE t ADD val3 int " + dolt sql -q "UPDATE t SET val3=4 WHERE pk=1" + dolt commit -am "cm2" + + run dolt diff --skinny --data HEAD~1 + [ $status -eq 0 ] + [[ "$output" =~ 'pk' ]] || false + [[ "$output" =~ 'val1' ]] || false + [[ "$output" =~ 'val3' ]] || false + [[ ! "$output" =~ 'val2' ]] || false +} + +@test "diff: skinny flag only shows row changed when both schema (column dropped) and data is changed (row updated)" { + dolt sql -q "create table t(pk int primary key, val1 int, s varchar(255))" + dolt add . + dolt sql -q "INSERT INTO t VALUES (1, 1, 'bla')" + dolt sql -q "INSERT INTO t VALUES (2, 2, 'bla2')" + dolt commit -am "cm1" + + run dolt diff --skinny --data HEAD~1 + [ $status -eq 0 ] + [[ "$output" =~ 'pk' ]] || false + [[ "$output" =~ 'val1' ]] || false + [[ "$output" =~ 's' ]] || false + + dolt sql -q "ALTER TABLE t DROP COLUMN s" + dolt sql -q "UPDATE t SET val1=3 WHERE pk=1" + dolt sql -q "UPDATE t SET val1=4 WHERE pk=2" + dolt commit -am "cm2" + + test=$(dolt diff --skinny --data HEAD~1) + echo $test + run dolt diff --skinny --data HEAD~1 + [ $status -eq 0 ] + [[ "$output" =~ 'pk' ]] || false + [[ "$output" =~ 'val1' ]] || false + [[ "$output" =~ 's' ]] || false + [[ ! "$output" =~ 'val3' ]] || false +} + +@test "diff: skinny flag only shows row changed when data is changed (row deleted)" { + dolt sql -q "create table t(pk int primary key, val1 int, val2 int)" + dolt add . + dolt sql -q "INSERT INTO t VALUES (1, 1, 1)" + dolt sql -q "INSERT INTO t VALUES (2, 2, 2)" + dolt commit -am "cm1" + + run dolt diff --skinny --data HEAD~1 + [ $status -eq 0 ] + [[ "$output" =~ 'pk' ]] || false + [[ "$output" =~ 'val1' ]] || false + [[ "$output" =~ 'val2' ]] || false + + dolt sql -q "DELETE FROM t WHERE pk=1" + dolt commit -am "cm2" + + run dolt diff --skinny --data HEAD~1 + [ $status -eq 0 ] + [[ "$output" =~ 'pk' ]] || false + [[ "$output" =~ 'val1' ]] || false + [[ "$output" =~ 'val2' ]] || false +} + @test "diff: keyless sql diffs" { dolt sql -q "create table t(pk int, val int)" From 4a54e85393700bff75445d090dae5bda41334f4f Mon Sep 17 00:00:00 2001 From: Jason Fulghum Date: Mon, 12 Sep 2022 10:27:32 -0700 Subject: [PATCH 5/7] Removing test output code --- integration-tests/bats/diff.bats | 2 -- 1 file changed, 2 deletions(-) diff --git a/integration-tests/bats/diff.bats b/integration-tests/bats/diff.bats index e8a4235ea5..ae6c31ad5b 100644 --- a/integration-tests/bats/diff.bats +++ b/integration-tests/bats/diff.bats @@ -788,8 +788,6 @@ SQL dolt sql -q "UPDATE t SET val1=4 WHERE pk=2" dolt commit -am "cm2" - test=$(dolt diff --skinny --data HEAD~1) - echo $test run dolt diff --skinny --data HEAD~1 [ $status -eq 0 ] [[ "$output" =~ 'pk' ]] || false From 5127e024356aa1c21781544bb750cf52551dd65f Mon Sep 17 00:00:00 2001 From: Jason Fulghum Date: Mon, 12 Sep 2022 10:27:46 -0700 Subject: [PATCH 6/7] Removing unnecessary test --- integration-tests/bats/diff.bats | 1 - 1 file changed, 1 deletion(-) diff --git a/integration-tests/bats/diff.bats b/integration-tests/bats/diff.bats index ae6c31ad5b..c0f028a1fb 100644 --- a/integration-tests/bats/diff.bats +++ b/integration-tests/bats/diff.bats @@ -793,7 +793,6 @@ SQL [[ "$output" =~ 'pk' ]] || false [[ "$output" =~ 'val1' ]] || false [[ "$output" =~ 's' ]] || false - [[ ! "$output" =~ 'val3' ]] || false } @test "diff: skinny flag only shows row changed when data is changed (row deleted)" { From 41c042406c9e8decefb7d171a748fd7b182f108a Mon Sep 17 00:00:00 2001 From: Jason Fulghum Date: Mon, 12 Sep 2022 10:28:08 -0700 Subject: [PATCH 7/7] Adding another assertion for the pk field --- integration-tests/bats/diff.bats | 1 + 1 file changed, 1 insertion(+) diff --git a/integration-tests/bats/diff.bats b/integration-tests/bats/diff.bats index c0f028a1fb..739beb2894 100644 --- a/integration-tests/bats/diff.bats +++ b/integration-tests/bats/diff.bats @@ -741,6 +741,7 @@ SQL run dolt diff --skinny HEAD~1 [ $status -eq 0 ] [[ ! "$output" =~ 'val2' ]] || false + [[ "$output" =~ 'pk' ]] || false [[ "$output" =~ 'val1' ]] || false }