mirror/dolt
1
0
Fork 0
mirror of https://github.com/dolthub/dolt.git synced 2026-04-20 19:31:56 -05:00
Code Issues Packages Projects Releases 156 Wiki Activity

Rename dolt_diff_summary table function to dolt_diff_stat

Browse Source
This commit is contained in:
Taylor Bantle
2023-02-22 13:46:41 -08:00
parent be862d796c
commit 6b87f9885c
6 changed files with 198 additions and 198 deletions
Download Patch File Download Diff File Expand all files Collapse all files
go/libraries/doltcore/diff/diff_stat.go
+12 -12
View File
@@ -200,20 +200,20 @@ func statWithReporter(ctx context.Context, ch chan DiffStatProgress, from, to ty
}
func reportPkChanges(ctx context.Context, vMapping val.OrdinalMapping, fromD, toD val.TupleDesc, change tree.Diff, ch chan<- DiffStatProgress) error {
var sum DiffStatProgress
var stat DiffStatProgress
switch change.Type {
case tree.AddedDiff:
sum.Adds++
stat.Adds++
case tree.RemovedDiff:
sum.Removes++
stat.Removes++
case tree.ModifiedDiff:
sum.CellChanges = prollyCountCellDiff(vMapping, fromD, toD, val.Tuple(change.From), val.Tuple(change.To))
sum.Changes++
stat.CellChanges = prollyCountCellDiff(vMapping, fromD, toD, val.Tuple(change.From), val.Tuple(change.To))
stat.Changes++
default:
return errors.New("unknown change type")
}
select {
case ch <- sum:
case ch <- stat:
return nil
case <-ctx.Done():
return ctx.Err()
@@ -221,28 +221,28 @@ func reportPkChanges(ctx context.Context, vMapping val.OrdinalMapping, fromD, to
}
func reportKeylessChanges(ctx context.Context, vMapping val.OrdinalMapping, fromD, toD val.TupleDesc, change tree.Diff, ch chan<- DiffStatProgress) error {
var sum DiffStatProgress
var stat DiffStatProgress
var n, n2 uint64
switch change.Type {
case tree.AddedDiff:
n, _ = toD.GetUint64(0, val.Tuple(change.To))
sum.Adds += n
stat.Adds += n
case tree.RemovedDiff:
n, _ = fromD.GetUint64(0, val.Tuple(change.From))
sum.Removes += n
stat.Removes += n
case tree.ModifiedDiff:
n, _ = fromD.GetUint64(0, val.Tuple(change.From))
n2, _ = toD.GetUint64(0, val.Tuple(change.To))
if n < n2 {
sum.Adds += n2 - n
stat.Adds += n2 - n
} else {
sum.Removes += n - n2
stat.Removes += n - n2
}
default:
return errors.New("unknown change type")
}
select {
case ch <- sum:
case ch <- stat:
return nil
case <-ctx.Done():
return ctx.Err()
go/libraries/doltcore/sqle/database_provider.go
+2 -2
View File
@@ -943,8 +943,8 @@ func (p DoltDatabaseProvider) TableFunction(_ *sql.Context, name string) (sql.Ta
case "dolt_diff":
dtf := &DiffTableFunction{}
return dtf, nil
case "dolt_diff_summary":
dtf := &DiffSummaryTableFunction{}
case "dolt_diff_stat":
dtf := &DiffStatTableFunction{}
return dtf, nil
case "dolt_log":
dtf := &LogTableFunction{}
go/libraries/doltcore/sqle/dolt_diff_summary_table_function.go
+73 -73
View File
@@ -31,9 +31,9 @@ import (
"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dtables"
)
var _ sql.TableFunction = (*DiffSummaryTableFunction)(nil)
var _ sql.TableFunction = (*DiffStatTableFunction)(nil)
type DiffSummaryTableFunction struct {
type DiffStatTableFunction struct {
ctx *sql.Context
fromCommitExpr sql.Expression
@@ -43,7 +43,7 @@ type DiffSummaryTableFunction struct {
database sql.Database
}
var diffSummaryTableSchema = sql.Schema{
var diffStatTableSchema = sql.Schema{
&sql.Column{Name: "table_name", Type: types.LongText, Nullable: false},
&sql.Column{Name: "rows_unmodified", Type: types.Int64, Nullable: true},
&sql.Column{Name: "rows_added", Type: types.Int64, Nullable: true},
@@ -59,8 +59,8 @@ var diffSummaryTableSchema = sql.Schema{
}
// NewInstance creates a new instance of TableFunction interface
func (ds *DiffSummaryTableFunction) NewInstance(ctx *sql.Context, db sql.Database, expressions []sql.Expression) (sql.Node, error) {
newInstance := &DiffSummaryTableFunction{
func (ds *DiffStatTableFunction) NewInstance(ctx *sql.Context, db sql.Database, expressions []sql.Expression) (sql.Node, error) {
newInstance := &DiffStatTableFunction{
ctx: ctx,
database: db,
}
@@ -74,22 +74,22 @@ func (ds *DiffSummaryTableFunction) NewInstance(ctx *sql.Context, db sql.Databas
}
// Database implements the sql.Databaser interface
func (ds *DiffSummaryTableFunction) Database() sql.Database {
func (ds *DiffStatTableFunction) Database() sql.Database {
return ds.database
}
// WithDatabase implements the sql.Databaser interface
func (ds *DiffSummaryTableFunction) WithDatabase(database sql.Database) (sql.Node, error) {
func (ds *DiffStatTableFunction) WithDatabase(database sql.Database) (sql.Node, error) {
ds.database = database
return ds, nil
}
// Name implements the sql.TableFunction interface
func (ds *DiffSummaryTableFunction) Name() string {
return "dolt_diff_summary"
func (ds *DiffStatTableFunction) Name() string {
return "dolt_diff_stat"
}
func (ds *DiffSummaryTableFunction) commitsResolved() bool {
func (ds *DiffStatTableFunction) commitsResolved() bool {
if ds.dotCommitExpr != nil {
return ds.dotCommitExpr.Resolved()
}
@@ -97,7 +97,7 @@ func (ds *DiffSummaryTableFunction) commitsResolved() bool {
}
// Resolved implements the sql.Resolvable interface
func (ds *DiffSummaryTableFunction) Resolved() bool {
func (ds *DiffStatTableFunction) Resolved() bool {
if ds.tableNameExpr != nil {
return ds.commitsResolved() && ds.tableNameExpr.Resolved()
}
@@ -105,31 +105,31 @@ func (ds *DiffSummaryTableFunction) Resolved() bool {
}
// String implements the Stringer interface
func (ds *DiffSummaryTableFunction) String() string {
func (ds *DiffStatTableFunction) String() string {
if ds.dotCommitExpr != nil {
if ds.tableNameExpr != nil {
return fmt.Sprintf("DOLT_DIFF_SUMMARY(%s, %s)", ds.dotCommitExpr.String(), ds.tableNameExpr.String())
return fmt.Sprintf("DOLT_DIFF_STAT(%s, %s)", ds.dotCommitExpr.String(), ds.tableNameExpr.String())
}
return fmt.Sprintf("DOLT_DIFF_SUMMARY(%s)", ds.dotCommitExpr.String())
return fmt.Sprintf("DOLT_DIFF_STAT(%s)", ds.dotCommitExpr.String())
}
if ds.tableNameExpr != nil {
return fmt.Sprintf("DOLT_DIFF_SUMMARY(%s, %s, %s)", ds.fromCommitExpr.String(), ds.toCommitExpr.String(), ds.tableNameExpr.String())
return fmt.Sprintf("DOLT_DIFF_STAT(%s, %s, %s)", ds.fromCommitExpr.String(), ds.toCommitExpr.String(), ds.tableNameExpr.String())
}
return fmt.Sprintf("DOLT_DIFF_SUMMARY(%s, %s)", ds.fromCommitExpr.String(), ds.toCommitExpr.String())
return fmt.Sprintf("DOLT_DIFF_STAT(%s, %s)", ds.fromCommitExpr.String(), ds.toCommitExpr.String())
}
// Schema implements the sql.Node interface.
func (ds *DiffSummaryTableFunction) Schema() sql.Schema {
return diffSummaryTableSchema
func (ds *DiffStatTableFunction) Schema() sql.Schema {
return diffStatTableSchema
}
// Children implements the sql.Node interface.
func (ds *DiffSummaryTableFunction) Children() []sql.Node {
func (ds *DiffStatTableFunction) Children() []sql.Node {
return nil
}
// WithChildren implements the sql.Node interface.
func (ds *DiffSummaryTableFunction) WithChildren(children ...sql.Node) (sql.Node, error) {
func (ds *DiffStatTableFunction) WithChildren(children ...sql.Node) (sql.Node, error) {
if len(children) != 0 {
return nil, fmt.Errorf("unexpected children")
}
@@ -137,7 +137,7 @@ func (ds *DiffSummaryTableFunction) WithChildren(children ...sql.Node) (sql.Node
}
// CheckPrivileges implements the interface sql.Node.
func (ds *DiffSummaryTableFunction) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool {
func (ds *DiffStatTableFunction) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool {
if ds.tableNameExpr != nil {
if !types.IsText(ds.tableNameExpr.Type()) {
return false
@@ -171,7 +171,7 @@ func (ds *DiffSummaryTableFunction) CheckPrivileges(ctx *sql.Context, opChecker
}
// Expressions implements the sql.Expressioner interface.
func (ds *DiffSummaryTableFunction) Expressions() []sql.Expression {
func (ds *DiffStatTableFunction) Expressions() []sql.Expression {
exprs := []sql.Expression{}
if ds.dotCommitExpr != nil {
exprs = append(exprs, ds.dotCommitExpr)
@@ -185,7 +185,7 @@ func (ds *DiffSummaryTableFunction) Expressions() []sql.Expression {
}
// WithExpressions implements the sql.Expressioner interface.
func (ds *DiffSummaryTableFunction) WithExpressions(expression ...sql.Expression) (sql.Node, error) {
func (ds *DiffStatTableFunction) WithExpressions(expression ...sql.Expression) (sql.Node, error) {
if len(expression) < 1 {
return nil, sql.ErrInvalidArgumentNumber.New(ds.Name(), "1 to 3", len(expression))
}
@@ -243,7 +243,7 @@ func (ds *DiffSummaryTableFunction) WithExpressions(expression ...sql.Expression
}
// RowIter implements the sql.Node interface
func (ds *DiffSummaryTableFunction) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) {
func (ds *DiffStatTableFunction) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) {
fromCommitVal, toCommitVal, dotCommitVal, tableName, err := ds.evaluateArguments()
if err != nil {
return nil, err
@@ -278,44 +278,44 @@ func (ds *DiffSummaryTableFunction) RowIter(ctx *sql.Context, row sql.Row) (sql.
// If tableNameExpr defined, return a single table diff stat result
if ds.tableNameExpr != nil {
delta := findMatchingDelta(deltas, tableName)
diffSum, hasDiff, err := getDiffSummaryNodeFromDelta(ctx, delta, fromRoot, toRoot, tableName)
diffStat, hasDiff, err := getDiffStatNodeFromDelta(ctx, delta, fromRoot, toRoot, tableName)
if err != nil {
return nil, err
}
if !hasDiff {
return NewDiffSummaryTableFunctionRowIter([]diffSummaryNode{}), nil
return NewDiffStatTableFunctionRowIter([]diffStatNode{}), nil
}
return NewDiffSummaryTableFunctionRowIter([]diffSummaryNode{diffSum}), nil
return NewDiffStatTableFunctionRowIter([]diffStatNode{diffStat}), nil
}
var diffSummaries []diffSummaryNode
var diffStats []diffStatNode
for _, delta := range deltas {
tblName := delta.ToName
if tblName == "" {
tblName = delta.FromName
}
diffSum, hasDiff, err := getDiffSummaryNodeFromDelta(ctx, delta, fromRoot, toRoot, tblName)
diffStat, hasDiff, err := getDiffStatNodeFromDelta(ctx, delta, fromRoot, toRoot, tblName)
if err != nil {
if errors.Is(err, diff.ErrPrimaryKeySetChanged) {
ctx.Warn(dtables.PrimaryKeyChangeWarningCode, fmt.Sprintf("summary for table %s cannot be determined. Primary key set changed.", tblName))
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
diffSummaries = append(diffSummaries, diffSummaryNode{tblName: tblName})
diffStats = append(diffStats, diffStatNode{tblName: tblName})
continue
}
return nil, err
}
if hasDiff {
diffSummaries = append(diffSummaries, diffSum)
diffStats = append(diffStats, diffStat)
}
}
return NewDiffSummaryTableFunctionRowIter(diffSummaries), nil
return NewDiffStatTableFunctionRowIter(diffStats), nil
}
// evaluateArguments returns fromCommitVal, toCommitVal, dotCommitVal, and tableName.
// It evaluates the argument expressions to turn them into values this DiffSummaryTableFunction
// It evaluates the argument expressions to turn them into values this DiffStatTableFunction
// can use. Note that this method only evals the expressions, and doesn't validate the values.
func (ds *DiffSummaryTableFunction) evaluateArguments() (interface{}, interface{}, interface{}, string, error) {
func (ds *DiffStatTableFunction) evaluateArguments() (interface{}, interface{}, interface{}, string, error) {
var tableName string
if ds.tableNameExpr != nil {
tableNameVal, err := ds.tableNameExpr.Eval(ds.ctx, nil)
@@ -351,56 +351,56 @@ func (ds *DiffSummaryTableFunction) evaluateArguments() (interface{}, interface{
return fromCommitVal, toCommitVal, nil, tableName, nil
}
// getDiffSummaryNodeFromDelta returns diffSummaryNode object and whether there is data diff or not. It gets tables
// getDiffStatNodeFromDelta returns diffStatNode object and whether there is data diff or not. It gets tables
// from roots and diff stat if there is a valid table exists in both fromRoot and toRoot.
func getDiffSummaryNodeFromDelta(ctx *sql.Context, delta diff.TableDelta, fromRoot, toRoot *doltdb.RootValue, tableName string) (diffSummaryNode, bool, error) {
func getDiffStatNodeFromDelta(ctx *sql.Context, delta diff.TableDelta, fromRoot, toRoot *doltdb.RootValue, tableName string) (diffStatNode, bool, error) {
var oldColLen int
var newColLen int
fromTable, _, fromTableExists, err := fromRoot.GetTableInsensitive(ctx, tableName)
if err != nil {
return diffSummaryNode{}, false, err
return diffStatNode{}, false, err
}
if fromTableExists {
fromSch, err := fromTable.GetSchema(ctx)
if err != nil {
return diffSummaryNode{}, false, err
return diffStatNode{}, false, err
}
oldColLen = len(fromSch.GetAllCols().GetColumns())
}
toTable, _, toTableExists, err := toRoot.GetTableInsensitive(ctx, tableName)
if err != nil {
return diffSummaryNode{}, false, err
return diffStatNode{}, false, err
}
if toTableExists {
toSch, err := toTable.GetSchema(ctx)
if err != nil {
return diffSummaryNode{}, false, err
return diffStatNode{}, false, err
}
newColLen = len(toSch.GetAllCols().GetColumns())
}
if !fromTableExists && !toTableExists {
return diffSummaryNode{}, false, sql.ErrTableNotFound.New(tableName)
return diffStatNode{}, false, sql.ErrTableNotFound.New(tableName)
}
// no diff from tableDelta
if delta.FromTable == nil && delta.ToTable == nil {
return diffSummaryNode{}, false, nil
return diffStatNode{}, false, nil
}
diffSum, hasDiff, keyless, err := getDiffSummary(ctx, delta)
diffStat, hasDiff, keyless, err := getDiffStat(ctx, delta)
if err != nil {
return diffSummaryNode{}, false, err
return diffStatNode{}, false, err
}
return diffSummaryNode{tableName, diffSum, oldColLen, newColLen, keyless}, hasDiff, nil
return diffStatNode{tableName, diffStat, oldColLen, newColLen, keyless}, hasDiff, nil
}
// getDiffSummary returns diff.DiffStatProgress object and whether there is a data diff or not.
func getDiffSummary(ctx *sql.Context, td diff.TableDelta) (diff.DiffStatProgress, bool, bool, error) {
// getDiffStat returns diff.DiffStatProgress object and whether there is a data diff or not.
func getDiffStat(ctx *sql.Context, td diff.TableDelta) (diff.DiffStatProgress, bool, bool, error) {
// got this method from diff_output.go
ch := make(chan diff.DiffStatProgress)
@@ -453,60 +453,60 @@ func getDiffSummary(ctx *sql.Context, td diff.TableDelta) (diff.DiffStatProgress
}
//------------------------------------
// diffSummaryTableFunctionRowIter
// diffStatTableFunctionRowIter
//------------------------------------
var _ sql.RowIter = &diffSummaryTableFunctionRowIter{}
var _ sql.RowIter = &diffStatTableFunctionRowIter{}
type diffSummaryTableFunctionRowIter struct {
diffSums []diffSummaryNode
diffIdx int
type diffStatTableFunctionRowIter struct {
diffStats []diffStatNode
diffIdx int
}
func (d *diffSummaryTableFunctionRowIter) incrementIndexes() {
func (d *diffStatTableFunctionRowIter) incrementIndexes() {
d.diffIdx++
if d.diffIdx >= len(d.diffSums) {
if d.diffIdx >= len(d.diffStats) {
d.diffIdx = 0
d.diffSums = nil
d.diffStats = nil
}
}
type diffSummaryNode struct {
tblName string
diffSummary diff.DiffStatProgress
oldColLen int
newColLen int
keyless bool
type diffStatNode struct {
tblName string
diffStat diff.DiffStatProgress
oldColLen int
newColLen int
keyless bool
}
func NewDiffSummaryTableFunctionRowIter(ds []diffSummaryNode) sql.RowIter {
return &diffSummaryTableFunctionRowIter{
diffSums: ds,
func NewDiffStatTableFunctionRowIter(ds []diffStatNode) sql.RowIter {
return &diffStatTableFunctionRowIter{
diffStats: ds,
}
}
func (d *diffSummaryTableFunctionRowIter) Next(ctx *sql.Context) (sql.Row, error) {
func (d *diffStatTableFunctionRowIter) Next(ctx *sql.Context) (sql.Row, error) {
defer d.incrementIndexes()
if d.diffIdx >= len(d.diffSums) {
if d.diffIdx >= len(d.diffStats) {
return nil, io.EOF
}
if d.diffSums == nil {
if d.diffStats == nil {
return nil, io.EOF
}
ds := d.diffSums[d.diffIdx]
return getRowFromDiffSummary(ds.tblName, ds.diffSummary, ds.newColLen, ds.oldColLen, ds.keyless), nil
ds := d.diffStats[d.diffIdx]
return getRowFromDiffStat(ds.tblName, ds.diffStat, ds.newColLen, ds.oldColLen, ds.keyless), nil
}
func (d *diffSummaryTableFunctionRowIter) Close(context *sql.Context) error {
func (d *diffStatTableFunctionRowIter) Close(context *sql.Context) error {
return nil
}
// getRowFromDiffSummary takes diff.DiffStatProgress and calculates the row_modified, cell_added, cell_deleted.
// 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 getRowFromDiffSummary(tblName string, dsp diff.DiffStatProgress, newColLen, oldColLen int, keyless bool) sql.Row {
func getRowFromDiffStat(tblName string, 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{
go/libraries/doltcore/sqle/enginetest/dolt_engine_test.go
+4 -4
View File
@@ -1236,10 +1236,10 @@ func TestDiffTableFunctionPrepared(t *testing.T) {
}
}
func TestDiffSummaryTableFunction(t *testing.T) {
func TestDiffStatTableFunction(t *testing.T) {
harness := newDoltHarness(t)
harness.Setup(setup.MydbData)
for _, test := range DiffSummaryTableFunctionScriptTests {
for _, test := range DiffStatTableFunctionScriptTests {
harness.engine = nil
t.Run(test.Name, func(t *testing.T) {
enginetest.TestScript(t, harness, test)
@@ -1247,10 +1247,10 @@ func TestDiffSummaryTableFunction(t *testing.T) {
}
}
func TestDiffSummaryTableFunctionPrepared(t *testing.T) {
func TestDiffStatTableFunctionPrepared(t *testing.T) {
harness := newDoltHarness(t)
harness.Setup(setup.MydbData)
for _, test := range DiffSummaryTableFunctionScriptTests {
for _, test := range DiffStatTableFunctionScriptTests {
harness.engine = nil
t.Run(test.Name, func(t *testing.T) {
enginetest.TestScriptPrepared(t, harness, test)
go/libraries/doltcore/sqle/enginetest/dolt_queries.go
+18 -18
View File
@@ -818,17 +818,17 @@ var DoltUserPrivTests = []queries.UserPrivilegeTest{
ExpectedErr: sql.ErrDatabaseAccessDeniedForUser,
},
{
// Without access to the database, dolt_diff_summary should fail with a database access error
// Without access to the database, dolt_diff_stat should fail with a database access error
User: "tester",
Host: "localhost",
Query: "SELECT * FROM dolt_diff_summary('main~', 'main', 'test');",
Query: "SELECT * FROM dolt_diff_stat('main~', 'main', 'test');",
ExpectedErr: sql.ErrDatabaseAccessDeniedForUser,
},
{
// Without access to the database, dolt_diff_summary with dots should fail with a database access error
// Without access to the database, dolt_diff_stat with dots should fail with a database access error
User: "tester",
Host: "localhost",
Query: "SELECT * FROM dolt_diff_summary('main~..main', 'test');",
Query: "SELECT * FROM dolt_diff_stat('main~..main', 'test');",
ExpectedErr: sql.ErrDatabaseAccessDeniedForUser,
},
{
@@ -874,31 +874,31 @@ var DoltUserPrivTests = []queries.UserPrivilegeTest{
ExpectedErr: sql.ErrPrivilegeCheckFailed,
},
{
// With access to the db, but not the table, dolt_diff_summary should fail
// With access to the db, but not the table, dolt_diff_stat should fail
User: "tester",
Host: "localhost",
Query: "SELECT * FROM dolt_diff_summary('main~', 'main', 'test2');",
Query: "SELECT * FROM dolt_diff_stat('main~', 'main', 'test2');",
ExpectedErr: sql.ErrPrivilegeCheckFailed,
},
{
// With access to the db, but not the table, dolt_diff_summary with dots should fail
// With access to the db, but not the table, dolt_diff_stat with dots should fail
User: "tester",
Host: "localhost",
Query: "SELECT * FROM dolt_diff_summary('main~...main', 'test2');",
Query: "SELECT * FROM dolt_diff_stat('main~...main', 'test2');",
ExpectedErr: sql.ErrPrivilegeCheckFailed,
},
{
// With access to the db, dolt_diff_summary should fail for all tables if no access any of tables
// With access to the db, dolt_diff_stat should fail for all tables if no access any of tables
User: "tester",
Host: "localhost",
Query: "SELECT * FROM dolt_diff_summary('main~', 'main');",
Query: "SELECT * FROM dolt_diff_stat('main~', 'main');",
ExpectedErr: sql.ErrPrivilegeCheckFailed,
},
{
// With access to the db, dolt_diff_summary with dots should fail for all tables if no access any of tables
// With access to the db, dolt_diff_stat with dots should fail for all tables if no access any of tables
User: "tester",
Host: "localhost",
Query: "SELECT * FROM dolt_diff_summary('main~...main');",
Query: "SELECT * FROM dolt_diff_stat('main~...main');",
ExpectedErr: sql.ErrPrivilegeCheckFailed,
},
{
@@ -944,17 +944,17 @@ var DoltUserPrivTests = []queries.UserPrivilegeTest{
Expected: []sql.Row{{1}},
},
{
// After granting access to the entire db, dolt_diff_summary should work
// After granting access to the entire db, dolt_diff_stat should work
User: "tester",
Host: "localhost",
Query: "SELECT COUNT(*) FROM dolt_diff_summary('main~', 'main');",
Query: "SELECT COUNT(*) FROM dolt_diff_stat('main~', 'main');",
Expected: []sql.Row{{1}},
},
{
// After granting access to the entire db, dolt_diff_summary with dots should work
// After granting access to the entire db, dolt_diff_stat with dots should work
User: "tester",
Host: "localhost",
Query: "SELECT COUNT(*) FROM dolt_diff_summary('main~...main');",
Query: "SELECT COUNT(*) FROM dolt_diff_stat('main~...main');",
Expected: []sql.Row{{1}},
},
{
@@ -986,10 +986,10 @@ var DoltUserPrivTests = []queries.UserPrivilegeTest{
ExpectedErr: sql.ErrDatabaseAccessDeniedForUser,
},
{
// After revoking access, dolt_diff_summary should fail
// After revoking access, dolt_diff_stat should fail
User: "tester",
Host: "localhost",
Query: "SELECT * FROM dolt_diff_summary('main~', 'main', 'test');",
Query: "SELECT * FROM dolt_diff_stat('main~', 'main', 'test');",
ExpectedErr: sql.ErrDatabaseAccessDeniedForUser,
},
{
go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go
+89 -89
View File
@@ -1345,7 +1345,7 @@ inner join t on to_pk = t.pk;`,
},
}
var DiffSummaryTableFunctionScriptTests = []queries.ScriptTest{
var DiffStatTableFunctionScriptTests = []queries.ScriptTest{
{
Name: "invalid arguments",
SetUpScript: []string{
@@ -1360,71 +1360,71 @@ var DiffSummaryTableFunctionScriptTests = []queries.ScriptTest{
},
Assertions: []queries.ScriptTestAssertion{
{
Query: "SELECT * from dolt_diff_summary();",
Query: "SELECT * from dolt_diff_stat();",
ExpectedErr: sql.ErrInvalidArgumentNumber,
},
{
Query: "SELECT * from dolt_diff_summary('t');",
Query: "SELECT * from dolt_diff_stat('t');",
ExpectedErr: sql.ErrInvalidArgumentNumber,
},
{
Query: "SELECT * from dolt_diff_summary('t', @Commit1, @Commit2, 'extra');",
Query: "SELECT * from dolt_diff_stat('t', @Commit1, @Commit2, 'extra');",
ExpectedErr: sql.ErrInvalidArgumentNumber,
},
{
Query: "SELECT * from dolt_diff_summary(null, null, null);",
Query: "SELECT * from dolt_diff_stat(null, null, null);",
ExpectedErr: sql.ErrInvalidArgumentDetails,
},
{
Query: "SELECT * from dolt_diff_summary(123, @Commit1, @Commit2);",
Query: "SELECT * from dolt_diff_stat(123, @Commit1, @Commit2);",
ExpectedErr: sql.ErrInvalidArgumentDetails,
},
{
Query: "SELECT * from dolt_diff_summary('t', 123, @Commit2);",
Query: "SELECT * from dolt_diff_stat('t', 123, @Commit2);",
ExpectedErr: sql.ErrInvalidArgumentDetails,
},
{
Query: "SELECT * from dolt_diff_summary('t', @Commit1, 123);",
Query: "SELECT * from dolt_diff_stat('t', @Commit1, 123);",
ExpectedErr: sql.ErrInvalidArgumentDetails,
},
{
Query: "SELECT * from dolt_diff_summary('fake-branch', @Commit2, 't');",
Query: "SELECT * from dolt_diff_stat('fake-branch', @Commit2, 't');",
ExpectedErrStr: "branch not found: fake-branch",
},
{
Query: "SELECT * from dolt_diff_summary('fake-branch..main', 't');",
Query: "SELECT * from dolt_diff_stat('fake-branch..main', 't');",
ExpectedErrStr: "branch not found: fake-branch",
},
{
Query: "SELECT * from dolt_diff_summary(@Commit1, 'fake-branch', 't');",
Query: "SELECT * from dolt_diff_stat(@Commit1, 'fake-branch', 't');",
ExpectedErrStr: "branch not found: fake-branch",
},
{
Query: "SELECT * from dolt_diff_summary('main..fake-branch', 't');",
Query: "SELECT * from dolt_diff_stat('main..fake-branch', 't');",
ExpectedErrStr: "branch not found: fake-branch",
},
{
Query: "SELECT * from dolt_diff_summary(@Commit1, @Commit2, 'doesnotexist');",
Query: "SELECT * from dolt_diff_stat(@Commit1, @Commit2, 'doesnotexist');",
ExpectedErr: sql.ErrTableNotFound,
},
{
Query: "SELECT * from dolt_diff_summary('main^..main', 'doesnotexist');",
Query: "SELECT * from dolt_diff_stat('main^..main', 'doesnotexist');",
ExpectedErr: sql.ErrTableNotFound,
},
{
Query: "SELECT * from dolt_diff_summary(@Commit1, concat('fake', '-', 'branch'), 't');",
Query: "SELECT * from dolt_diff_stat(@Commit1, concat('fake', '-', 'branch'), 't');",
ExpectedErr: sqle.ErrInvalidNonLiteralArgument,
},
{
Query: "SELECT * from dolt_diff_summary(hashof('main'), @Commit2, 't');",
Query: "SELECT * from dolt_diff_stat(hashof('main'), @Commit2, 't');",
ExpectedErr: sqle.ErrInvalidNonLiteralArgument,
},
{
Query: "SELECT * from dolt_diff_summary(@Commit1, @Commit2, LOWER('T'));",
Query: "SELECT * from dolt_diff_stat(@Commit1, @Commit2, LOWER('T'));",
ExpectedErr: sqle.ErrInvalidNonLiteralArgument,
},
{
Query: "SELECT * from dolt_diff_summary('main..main~', LOWER('T'));",
Query: "SELECT * from dolt_diff_stat('main..main~', LOWER('T'));",
ExpectedErr: sqle.ErrInvalidNonLiteralArgument,
},
},
@@ -1461,39 +1461,39 @@ var DiffSummaryTableFunctionScriptTests = []queries.ScriptTest{
Assertions: []queries.ScriptTestAssertion{
{
// table is added, no data diff, result is empty
Query: "SELECT * from dolt_diff_summary(@Commit1, @Commit2, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit1, @Commit2, 't');",
Expected: []sql.Row{},
},
{
Query: "SELECT * from dolt_diff_summary(@Commit2, @Commit3, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit2, @Commit3, 't');",
Expected: []sql.Row{{"t", 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 3}},
},
{
Query: "SELECT * from dolt_diff_summary(@Commit3, @Commit4, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit3, @Commit4, 't');",
Expected: []sql.Row{{"t", 0, 2, 0, 1, 6, 0, 2, 1, 3, 3, 9}},
},
{
// change from and to commits
Query: "SELECT * from dolt_diff_summary(@Commit4, @Commit3, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit4, @Commit3, 't');",
Expected: []sql.Row{{"t", 0, 0, 2, 1, 0, 6, 2, 3, 1, 9, 3}},
},
{
// table is dropped
Query: "SELECT * from dolt_diff_summary(@Commit4, @Commit5, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit4, @Commit5, 't');",
Expected: []sql.Row{{"t", 0, 0, 3, 0, 0, 9, 0, 3, 0, 9, 0}},
},
{
Query: "SELECT * from dolt_diff_summary(@Commit1, @Commit4, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit1, @Commit4, 't');",
Expected: []sql.Row{{"t", 0, 3, 0, 0, 9, 0, 0, 0, 3, 0, 9}},
},
{
Query: "SELECT * from dolt_diff_summary(@Commit1, @Commit5, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit1, @Commit5, 't');",
ExpectedErr: sql.ErrTableNotFound,
},
{
Query: `
SELECT *
from dolt_diff_summary(@Commit3, @Commit4, 't')
from dolt_diff_stat(@Commit3, @Commit4, 't')
inner join t as of @Commit3 on rows_unmodified = t.pk;`,
Expected: []sql.Row{},
},
@@ -1531,37 +1531,37 @@ inner join t as of @Commit3 on rows_unmodified = t.pk;`,
Assertions: []queries.ScriptTestAssertion{
{
// table is added, no data diff, result is empty
Query: "SELECT * from dolt_diff_summary(@Commit1, @Commit2, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit1, @Commit2, 't');",
Expected: []sql.Row{},
},
{
Query: "SELECT * from dolt_diff_summary(@Commit2, @Commit3, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit2, @Commit3, 't');",
Expected: []sql.Row{{"t", nil, 1, 0, nil, nil, nil, nil, nil, nil, nil, nil}},
},
{
// TODO : (correct result is commented out)
// update row for keyless table deletes the row and insert the new row
// this causes row added = 3 and row deleted = 1
Query: "SELECT * from dolt_diff_summary(@Commit3, @Commit4, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit3, @Commit4, 't');",
//Expected: []sql.Row{{"t", nil, 2, 0, nil, nil, nil, nil, nil, nil, nil, nil}},
Expected: []sql.Row{{"t", nil, 3, 1, nil, nil, nil, nil, nil, nil, nil, nil}},
},
{
Query: "SELECT * from dolt_diff_summary(@Commit4, @Commit3, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit4, @Commit3, 't');",
//Expected: []sql.Row{{"t", nil, 0, 2, nil, nil, nil, nil, nil, nil, nil, nil}},
Expected: []sql.Row{{"t", nil, 1, 3, nil, nil, nil, nil, nil, nil, nil, nil}},
},
{
// table is dropped
Query: "SELECT * from dolt_diff_summary(@Commit4, @Commit5, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit4, @Commit5, 't');",
Expected: []sql.Row{{"t", nil, 0, 3, nil, nil, nil, nil, nil, nil, nil, nil}},
},
{
Query: "SELECT * from dolt_diff_summary(@Commit1, @Commit4, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit1, @Commit4, 't');",
Expected: []sql.Row{{"t", nil, 3, 0, nil, nil, nil, nil, nil, nil, nil, nil}},
},
{
Query: "SELECT * from dolt_diff_summary(@Commit1, @Commit5, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit1, @Commit5, 't');",
ExpectedErr: sql.ErrTableNotFound,
},
},
@@ -1603,27 +1603,27 @@ inner join t as of @Commit3 on rows_unmodified = t.pk;`,
},
Assertions: []queries.ScriptTestAssertion{
{
Query: "SELECT * from dolt_diff_summary(@Commit0, @Commit1);",
Query: "SELECT * from dolt_diff_stat(@Commit0, @Commit1);",
Expected: []sql.Row{{"t", 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 3}},
},
{
Query: "SELECT * from dolt_diff_summary(@Commit1, @Commit2);",
Query: "SELECT * from dolt_diff_stat(@Commit1, @Commit2);",
Expected: []sql.Row{{"t2", 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 3}},
},
{
Query: "SELECT * from dolt_diff_summary(@Commit2, @Commit3);",
Query: "SELECT * from dolt_diff_stat(@Commit2, @Commit3);",
Expected: []sql.Row{{"t", 0, 3, 0, 1, 9, 0, 2, 1, 4, 3, 12}, {"t2", 1, 1, 0, 0, 3, 0, 0, 1, 2, 3, 6}},
},
{
Query: "SELECT * from dolt_diff_summary(@Commit3, @Commit4);",
Query: "SELECT * from dolt_diff_stat(@Commit3, @Commit4);",
Expected: []sql.Row{{"t", 3, 0, 1, 0, 0, 3, 0, 4, 3, 12, 9}, {"t2", 1, 0, 0, 1, 0, 0, 1, 2, 2, 6, 6}},
},
{
Query: "SELECT * from dolt_diff_summary(@Commit4, @Commit2);",
Query: "SELECT * from dolt_diff_stat(@Commit4, @Commit2);",
Expected: []sql.Row{{"t", 0, 0, 2, 1, 0, 6, 2, 3, 1, 9, 3}, {"t2", 0, 0, 1, 1, 0, 3, 1, 2, 1, 6, 3}},
},
{
Query: "SELECT * from dolt_diff_summary(@Commit3, 'WORKING');",
Query: "SELECT * from dolt_diff_stat(@Commit3, 'WORKING');",
Expected: []sql.Row{{"t", 3, 0, 1, 0, 0, 3, 0, 4, 3, 12, 9}, {"t2", 1, 0, 0, 1, 0, 0, 1, 2, 2, 6, 6}},
},
},
@@ -1645,31 +1645,31 @@ inner join t as of @Commit3 on rows_unmodified = t.pk;`,
},
Assertions: []queries.ScriptTestAssertion{
{
Query: "SELECT * from dolt_diff_summary(@Commit1, 'WORKING', 't')",
Query: "SELECT * from dolt_diff_stat(@Commit1, 'WORKING', 't')",
Expected: []sql.Row{{"t", 0, 1, 1, 1, 3, 3, 1, 2, 2, 6, 6}},
},
{
Query: "SELECT * from dolt_diff_summary('STAGED', 'WORKING', 't')",
Query: "SELECT * from dolt_diff_stat('STAGED', 'WORKING', 't')",
Expected: []sql.Row{{"t", 0, 1, 1, 1, 3, 3, 1, 2, 2, 6, 6}},
},
{
Query: "SELECT * from dolt_diff_summary('STAGED..WORKING', 't')",
Query: "SELECT * from dolt_diff_stat('STAGED..WORKING', 't')",
Expected: []sql.Row{{"t", 0, 1, 1, 1, 3, 3, 1, 2, 2, 6, 6}},
},
{
Query: "SELECT * from dolt_diff_summary('WORKING', 'STAGED', 't')",
Query: "SELECT * from dolt_diff_stat('WORKING', 'STAGED', 't')",
Expected: []sql.Row{{"t", 0, 1, 1, 1, 3, 3, 1, 2, 2, 6, 6}},
},
{
Query: "SELECT * from dolt_diff_summary('WORKING', 'WORKING', 't')",
Query: "SELECT * from dolt_diff_stat('WORKING', 'WORKING', 't')",
Expected: []sql.Row{},
},
{
Query: "SELECT * from dolt_diff_summary('WORKING..WORKING', 't')",
Query: "SELECT * from dolt_diff_stat('WORKING..WORKING', 't')",
Expected: []sql.Row{},
},
{
Query: "SELECT * from dolt_diff_summary('STAGED', 'STAGED', 't')",
Query: "SELECT * from dolt_diff_stat('STAGED', 'STAGED', 't')",
Expected: []sql.Row{},
},
{
@@ -1677,11 +1677,11 @@ inner join t as of @Commit3 on rows_unmodified = t.pk;`,
SkipResultsCheck: true,
},
{
Query: "SELECT * from dolt_diff_summary('WORKING', 'STAGED', 't')",
Query: "SELECT * from dolt_diff_stat('WORKING', 'STAGED', 't')",
Expected: []sql.Row{},
},
{
Query: "SELECT * from dolt_diff_summary('HEAD', 'STAGED', 't')",
Query: "SELECT * from dolt_diff_stat('HEAD', 'STAGED', 't')",
Expected: []sql.Row{{"t", 0, 1, 1, 1, 3, 3, 1, 2, 2, 6, 6}},
},
},
@@ -1723,74 +1723,74 @@ inner join t as of @Commit3 on rows_unmodified = t.pk;`,
},
Assertions: []queries.ScriptTestAssertion{
{
Query: "SELECT * from dolt_diff_summary('main', 'branch1', 't');",
Query: "SELECT * from dolt_diff_stat('main', 'branch1', 't');",
Expected: []sql.Row{{"t", 0, 0, 1, 1, 0, 4, 0, 2, 1, 6, 2}},
},
{
Query: "SELECT * from dolt_diff_summary('main..branch1', 't');",
Query: "SELECT * from dolt_diff_stat('main..branch1', 't');",
Expected: []sql.Row{{"t", 0, 0, 1, 1, 0, 4, 0, 2, 1, 6, 2}},
},
{
Query: "SELECT * from dolt_diff_summary('main', 'branch1');",
Query: "SELECT * from dolt_diff_stat('main', 'branch1');",
Expected: []sql.Row{
{"t", 0, 0, 1, 1, 0, 4, 0, 2, 1, 6, 2},
{"newtable", 0, 0, 2, 0, 0, 2, 0, 2, 0, 2, 0},
},
},
{
Query: "SELECT * from dolt_diff_summary('main..branch1');",
Query: "SELECT * from dolt_diff_stat('main..branch1');",
Expected: []sql.Row{
{"t", 0, 0, 1, 1, 0, 4, 0, 2, 1, 6, 2},
{"newtable", 0, 0, 2, 0, 0, 2, 0, 2, 0, 2, 0},
},
},
{
Query: "SELECT * from dolt_diff_summary('branch1', 'main', 't');",
Query: "SELECT * from dolt_diff_stat('branch1', 'main', 't');",
Expected: []sql.Row{{"t", 0, 1, 0, 1, 4, 0, 1, 1, 2, 2, 6}},
},
{
Query: "SELECT * from dolt_diff_summary('branch1..main', 't');",
Query: "SELECT * from dolt_diff_stat('branch1..main', 't');",
Expected: []sql.Row{{"t", 0, 1, 0, 1, 4, 0, 1, 1, 2, 2, 6}},
},
{
Query: "SELECT * from dolt_diff_summary('main~2', 'branch1', 't');",
Query: "SELECT * from dolt_diff_stat('main~2', 'branch1', 't');",
Expected: []sql.Row{{"t", 0, 1, 1, 0, 2, 3, 0, 1, 1, 3, 2}},
},
{
Query: "SELECT * from dolt_diff_summary('main~2..branch1', 't');",
Query: "SELECT * from dolt_diff_stat('main~2..branch1', 't');",
Expected: []sql.Row{{"t", 0, 1, 1, 0, 2, 3, 0, 1, 1, 3, 2}},
},
// Three dot
{
Query: "SELECT * from dolt_diff_summary('main...branch1', 't');",
Query: "SELECT * from dolt_diff_stat('main...branch1', 't');",
Expected: []sql.Row{{"t", 0, 1, 1, 0, 2, 3, 0, 1, 1, 3, 2}},
},
{
Query: "SELECT * from dolt_diff_summary('main...branch1');",
Query: "SELECT * from dolt_diff_stat('main...branch1');",
Expected: []sql.Row{{"t", 0, 1, 1, 0, 2, 3, 0, 1, 1, 3, 2}},
},
{
Query: "SELECT * from dolt_diff_summary('branch1...main', 't');",
Query: "SELECT * from dolt_diff_stat('branch1...main', 't');",
Expected: []sql.Row{{"t", 1, 1, 0, 0, 3, 0, 0, 1, 2, 3, 6}},
},
{
Query: "SELECT * from dolt_diff_summary('branch1...main');",
Query: "SELECT * from dolt_diff_stat('branch1...main');",
Expected: []sql.Row{
{"t", 1, 1, 0, 0, 3, 0, 0, 1, 2, 3, 6},
{"newtable", 0, 2, 0, 0, 2, 0, 0, 0, 2, 0, 2},
},
},
{
Query: "SELECT * from dolt_diff_summary('branch1...main^');",
Query: "SELECT * from dolt_diff_stat('branch1...main^');",
Expected: []sql.Row{{"t", 1, 1, 0, 0, 3, 0, 0, 1, 2, 3, 6}},
},
{
Query: "SELECT * from dolt_diff_summary('branch1...main', 'newtable');",
Query: "SELECT * from dolt_diff_stat('branch1...main', 'newtable');",
Expected: []sql.Row{{"newtable", 0, 2, 0, 0, 2, 0, 0, 0, 2, 0, 2}},
},
{
Query: "SELECT * from dolt_diff_summary('main...main', 'newtable');",
Query: "SELECT * from dolt_diff_stat('main...main', 'newtable');",
Expected: []sql.Row{},
},
},
@@ -1823,23 +1823,23 @@ inner join t as of @Commit3 on rows_unmodified = t.pk;`,
},
Assertions: []queries.ScriptTestAssertion{
{
Query: "SELECT * from dolt_diff_summary(@Commit1, @Commit2, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit1, @Commit2, 't');",
Expected: []sql.Row{{"t", 0, 0, 0, 2, 0, 2, 0, 2, 2, 6, 4}},
},
{
Query: "SELECT * from dolt_diff_summary(@Commit2, @Commit3, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit2, @Commit3, 't');",
Expected: []sql.Row{{"t", 2, 1, 0, 0, 2, 0, 0, 2, 3, 4, 6}},
},
{
Query: "SELECT * from dolt_diff_summary(@Commit1, @Commit3, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit1, @Commit3, 't');",
Expected: []sql.Row{{"t", 0, 1, 0, 2, 2, 2, 0, 2, 3, 6, 6}},
},
{
Query: "SELECT * from dolt_diff_summary(@Commit3, @Commit4, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit3, @Commit4, 't');",
Expected: []sql.Row{{"t", 2, 1, 0, 1, 6, 0, 1, 3, 4, 6, 12}},
},
{
Query: "SELECT * from dolt_diff_summary(@Commit1, @Commit4, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit1, @Commit4, 't');",
Expected: []sql.Row{{"t", 0, 2, 0, 2, 6, 0, 2, 2, 4, 6, 12}},
},
},
@@ -1872,23 +1872,23 @@ inner join t as of @Commit3 on rows_unmodified = t.pk;`,
},
Assertions: []queries.ScriptTestAssertion{
{
Query: "SELECT * from dolt_diff_summary(@Commit1, @Commit2, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit1, @Commit2, 't');",
Expected: []sql.Row{{"t", 0, 2, 0, 0, 6, 0, 0, 0, 2, 0, 6}},
},
{
Query: "SELECT * from dolt_diff_summary(@Commit2, @Commit3, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit2, @Commit3, 't');",
Expected: []sql.Row{},
},
{
Query: "SELECT * from dolt_diff_summary(@Commit3, @Commit4, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit3, @Commit4, 't');",
Expected: []sql.Row{{"t", 1, 1, 0, 1, 3, 0, 1, 2, 3, 6, 9}},
},
{
Query: "SELECT * from dolt_diff_summary(@Commit4, @Commit5, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit4, @Commit5, 't');",
Expected: []sql.Row{{"t", 3, 1, 0, 0, 3, 0, 0, 3, 4, 9, 12}},
},
{
Query: "SELECT * from dolt_diff_summary(@Commit1, @Commit5, 't');",
Query: "SELECT * from dolt_diff_stat(@Commit1, @Commit5, 't');",
Expected: []sql.Row{{"t", 0, 4, 0, 0, 12, 0, 0, 0, 4, 0, 12}},
},
},
@@ -1900,11 +1900,11 @@ inner join t as of @Commit3 on rows_unmodified = t.pk;`,
},
Assertions: []queries.ScriptTestAssertion{
{
Query: "select * from dolt_diff_summary('HEAD', 'WORKING')",
Query: "select * from dolt_diff_stat('HEAD', 'WORKING')",
Expected: []sql.Row{},
},
{
Query: "select * from dolt_diff_summary('WORKING', 'HEAD')",
Query: "select * from dolt_diff_stat('WORKING', 'HEAD')",
Expected: []sql.Row{},
},
{
@@ -1912,11 +1912,11 @@ inner join t as of @Commit3 on rows_unmodified = t.pk;`,
SkipResultsCheck: true,
},
{
Query: "select * from dolt_diff_summary('HEAD', 'WORKING', 't1')",
Query: "select * from dolt_diff_stat('HEAD', 'WORKING', 't1')",
Expected: []sql.Row{{"t1", 0, 1, 0, 0, 2, 0, 0, 0, 1, 0, 2}},
},
{
Query: "select * from dolt_diff_summary('WORKING', 'HEAD', 't1')",
Query: "select * from dolt_diff_stat('WORKING', 'HEAD', 't1')",
Expected: []sql.Row{{"t1", 0, 0, 1, 0, 0, 2, 0, 1, 0, 2, 0}},
},
},
@@ -1933,11 +1933,11 @@ inner join t as of @Commit3 on rows_unmodified = t.pk;`,
},
Assertions: []queries.ScriptTestAssertion{
{
Query: "select * from dolt_diff_summary('HEAD~', 'HEAD', 't1')",
Query: "select * from dolt_diff_stat('HEAD~', 'HEAD', 't1')",
Expected: []sql.Row{{"t1", 0, 0, 1, 0, 0, 2, 0, 1, 0, 2, 0}},
},
{
Query: "select * from dolt_diff_summary('HEAD', 'HEAD~', 't1')",
Query: "select * from dolt_diff_stat('HEAD', 'HEAD~', 't1')",
Expected: []sql.Row{{"t1", 0, 1, 0, 0, 2, 0, 0, 0, 1, 0, 2}},
},
},
@@ -1956,21 +1956,21 @@ inner join t as of @Commit3 on rows_unmodified = t.pk;`,
},
Assertions: []queries.ScriptTestAssertion{
{
Query: "select * from dolt_diff_summary('HEAD~', 'HEAD', 't2')",
Query: "select * from dolt_diff_stat('HEAD~', 'HEAD', 't2')",
Expected: []sql.Row{{"t2", 1, 1, 0, 0, 2, 0, 0, 1, 2, 2, 4}},
},
{
Query: "select * from dolt_diff_summary('HEAD~..HEAD', 't2')",
Query: "select * from dolt_diff_stat('HEAD~..HEAD', 't2')",
Expected: []sql.Row{{"t2", 1, 1, 0, 0, 2, 0, 0, 1, 2, 2, 4}},
},
{
// Old table name can be matched as well
Query: "select * from dolt_diff_summary('HEAD~', 'HEAD', 't1')",
Query: "select * from dolt_diff_stat('HEAD~', 'HEAD', 't1')",
Expected: []sql.Row{{"t1", 1, 1, 0, 0, 2, 0, 0, 1, 2, 2, 4}},
},
{
// Old table name can be matched as well
Query: "select * from dolt_diff_summary('HEAD~..HEAD', 't1')",
Query: "select * from dolt_diff_stat('HEAD~..HEAD', 't1')",
Expected: []sql.Row{{"t1", 1, 1, 0, 0, 2, 0, 0, 1, 2, 2, 4}},
},
},
@@ -1992,17 +1992,17 @@ inner join t as of @Commit3 on rows_unmodified = t.pk;`,
},
Assertions: []queries.ScriptTestAssertion{
{
Query: "SELECT * from dolt_diff_summary('HEAD~2', 'HEAD');",
Query: "SELECT * from dolt_diff_stat('HEAD~2', 'HEAD');",
Expected: []sql.Row{{"t", 1, 0, 0, 0, 2, 0, 0, 1, 1, 1, 3}},
},
{
Query: "SELECT * from dolt_diff_summary('HEAD~', 'HEAD');",
Query: "SELECT * from dolt_diff_stat('HEAD~', 'HEAD');",
Expected: []sql.Row{},
},
},
},
{
Name: "pk set change should throw an error for 3 argument dolt_diff_summary",
Name: "pk set change should throw an error for 3 argument dolt_diff_stat",
SetUpScript: []string{
"CREATE table t (pk int primary key);",
"INSERT INTO t values (1);",
@@ -2014,13 +2014,13 @@ inner join t as of @Commit3 on rows_unmodified = t.pk;`,
},
Assertions: []queries.ScriptTestAssertion{
{
Query: "SELECT * from dolt_diff_summary('HEAD~', 'HEAD', 't');",
Query: "SELECT * from dolt_diff_stat('HEAD~', 'HEAD', 't');",
ExpectedErrStr: "failed to compute diff stat for table t: primary key set changed",
},
},
},
{
Name: "pk set change should report warning for 2 argument dolt_diff_summary",
Name: "pk set change should report warning for 2 argument dolt_diff_stat",
SetUpScript: []string{
"CREATE table t (pk int primary key);",
"INSERT INTO t values (1);",
@@ -2035,7 +2035,7 @@ inner join t as of @Commit3 on rows_unmodified = t.pk;`,
},
Assertions: []queries.ScriptTestAssertion{
{
Query: "SELECT * from dolt_diff_summary('HEAD~', 'HEAD')",
Query: "SELECT * from dolt_diff_stat('HEAD~', 'HEAD')",
Expected: []sql.Row{
{"t", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{"t2", 1, 3, 0, 0, 3, 0, 0, 1, 4, 1, 4},