Skip to content

Commit df46da9

Browse files
tbantle22tbantle22
committed
PR feedback
1 parent f426cb0 commit df46da9

File tree

8 files changed

+53
-52
lines changed

8 files changed

+53
-52
lines changed

‎go/libraries/doltcore/sqle/database.go‎

Lines changed: 39 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -321,59 +321,53 @@ func (db Database) getTableInsensitive(ctx *sql.Context, head *doltdb.Commit, ds
321321
// at runtime
322322
switch {
323323
case strings.HasPrefix(lwrName, doltdb.DoltDiffTablePrefix):
324-
if resolve.UseSearchPath && db.schemaName == "" {
325-
schemaName, err := resolve.FirstExistingSchemaOnSearchPath(ctx, root)
324+
if head == nil {
325+
var err error
326+
head, err = ds.GetHeadCommit(ctx, db.RevisionQualifiedName())
327+
326328
if err != nil {
327329
return nil, false, err
328330
}
329-
db.schemaName = schemaName
330331
}
331332

332-
if head == nil {
333+
baseTableName := tblName[len(doltdb.DoltDiffTablePrefix):]
334+
tname := doltdb.TableName{Name: baseTableName, Schema: db.schemaName}
335+
if resolve.UseSearchPath && db.schemaName == "" {
333336
var err error
334-
head, err = ds.GetHeadCommit(ctx, db.RevisionQualifiedName())
335-
337+
tname, _, _, err = resolve.Table(ctx, root, baseTableName)
336338
if err != nil {
337339
return nil, false, err
338340
}
339341
}
340342

341-
tableName := tblName[len(doltdb.DoltDiffTablePrefix):]
342-
dt, err := dtables.NewDiffTable(ctx, db.Name(), doltdb.TableName{Name: tableName, Schema: db.schemaName}, db.ddb, root, head)
343+
dt, err := dtables.NewDiffTable(ctx, db.Name(), tname, db.ddb, root, head)
343344
if err != nil {
344345
return nil, false, err
345346
}
346347
return dt, true, nil
347348

348349
case strings.HasPrefix(lwrName, doltdb.DoltCommitDiffTablePrefix):
350+
baseTableName := tblName[len(doltdb.DoltCommitDiffTablePrefix):]
351+
tname := doltdb.TableName{Name: baseTableName, Schema: db.schemaName}
349352
if resolve.UseSearchPath && db.schemaName == "" {
350-
schemaName, err := resolve.FirstExistingSchemaOnSearchPath(ctx, root)
353+
var err error
354+
tname, _, _, err = resolve.Table(ctx, root, baseTableName)
351355
if err != nil {
352356
return nil, false, err
353357
}
354-
db.schemaName = schemaName
355358
}
356359

357-
suffix := tblName[len(doltdb.DoltCommitDiffTablePrefix):]
358360
ws, err := ds.WorkingSet(ctx, db.RevisionQualifiedName())
359361
if err != nil {
360362
return nil, false, err
361363
}
362-
dt, err := dtables.NewCommitDiffTable(ctx, db.Name(), doltdb.TableName{Name: suffix, Schema: db.schemaName}, db.ddb, root, ws.StagedRoot())
364+
dt, err := dtables.NewCommitDiffTable(ctx, db.Name(), tname, db.ddb, root, ws.StagedRoot())
363365
if err != nil {
364366
return nil, false, err
365367
}
366368
return dt, true, nil
367369

368370
case strings.HasPrefix(lwrName, doltdb.DoltHistoryTablePrefix):
369-
if resolve.UseSearchPath && db.schemaName == "" {
370-
schemaName, err := resolve.FirstExistingSchemaOnSearchPath(ctx, root)
371-
if err != nil {
372-
return nil, false, err
373-
}
374-
db.schemaName = schemaName
375-
}
376-
377371
baseTableName := tblName[len(doltdb.DoltHistoryTablePrefix):]
378372
baseTable, ok, err := db.getTable(ctx, root, baseTableName)
379373
if err != nil {
@@ -401,50 +395,45 @@ func (db Database) getTableInsensitive(ctx *sql.Context, head *doltdb.Commit, ds
401395
}
402396

403397
case strings.HasPrefix(lwrName, doltdb.DoltConfTablePrefix):
398+
baseTableName := tblName[len(doltdb.DoltConfTablePrefix):]
399+
tname := doltdb.TableName{Name: baseTableName, Schema: db.schemaName}
404400
if resolve.UseSearchPath && db.schemaName == "" {
405-
schemaName, err := resolve.FirstExistingSchemaOnSearchPath(ctx, root)
401+
var err error
402+
tname, _, _, err = resolve.Table(ctx, root, baseTableName)
406403
if err != nil {
407404
return nil, false, err
408405
}
409-
db.schemaName = schemaName
410406
}
411407

412-
suffix := tblName[len(doltdb.DoltConfTablePrefix):]
413-
srcTable, ok, err := db.getTableInsensitive(ctx, head, ds, root, suffix, asOf)
408+
srcTable, ok, err := db.getTableInsensitive(ctx, head, ds, root, tname.Name, asOf)
414409
if err != nil {
415410
return nil, false, err
416411
} else if !ok {
417412
return nil, false, nil
418413
}
419-
dt, err := dtables.NewConflictsTable(ctx, doltdb.TableName{Name: suffix, Schema: db.schemaName}, srcTable, root, dtables.RootSetter(db))
414+
dt, err := dtables.NewConflictsTable(ctx, tname, srcTable, root, dtables.RootSetter(db))
420415
if err != nil {
421416
return nil, false, err
422417
}
423418
return dt, true, nil
424419

425420
case strings.HasPrefix(lwrName, doltdb.DoltConstViolTablePrefix):
421+
baseTableName := tblName[len(doltdb.DoltConstViolTablePrefix):]
422+
tname := doltdb.TableName{Name: baseTableName, Schema: db.schemaName}
426423
if resolve.UseSearchPath && db.schemaName == "" {
427-
schemaName, err := resolve.FirstExistingSchemaOnSearchPath(ctx, root)
424+
var err error
425+
tname, _, _, err = resolve.Table(ctx, root, baseTableName)
428426
if err != nil {
429427
return nil, false, err
430428
}
431-
db.schemaName = schemaName
432429
}
433430

434-
suffix := tblName[len(doltdb.DoltConstViolTablePrefix):]
435-
dt, err := dtables.NewConstraintViolationsTable(ctx, doltdb.TableName{Name: suffix, Schema: db.schemaName}, root, dtables.RootSetter(db))
431+
dt, err := dtables.NewConstraintViolationsTable(ctx, tname, root, dtables.RootSetter(db))
436432
if err != nil {
437433
return nil, false, err
438434
}
439435
return dt, true, nil
440436
case strings.HasPrefix(lwrName, doltdb.DoltWorkspaceTablePrefix):
441-
if resolve.UseSearchPath && db.schemaName == "" {
442-
schemaName, err := resolve.FirstExistingSchemaOnSearchPath(ctx, root)
443-
if err != nil {
444-
return nil, false, err
445-
}
446-
db.schemaName = schemaName
447-
}
448437
sess := dsess.DSessFromSess(ctx.Session)
449438

450439
ws, err := sess.WorkingSet(ctx, db.RevisionQualifiedName())
@@ -455,9 +444,21 @@ func (db Database) getTableInsensitive(ctx *sql.Context, head *doltdb.Commit, ds
455444
roots, _ := sess.GetRoots(ctx, db.RevisionQualifiedName())
456445
head := roots.Head
457446

458-
userTable := tblName[len(doltdb.DoltWorkspaceTablePrefix):]
447+
baseTableName := tblName[len(doltdb.DoltWorkspaceTablePrefix):]
448+
tname := doltdb.TableName{Name: baseTableName, Schema: db.schemaName}
449+
if resolve.UseSearchPath && db.schemaName == "" {
450+
var err error
451+
baseName, _, exists, err := resolve.Table(ctx, root, baseTableName)
452+
if err != nil {
453+
return nil, false, err
454+
}
455+
// Only set tname if table exists so that emptyWorkspaceTable is used if the table does not exist
456+
if exists {
457+
tname = baseName
458+
}
459+
}
459460

460-
dt, err := dtables.NewWorkspaceTable(ctx, tblName, doltdb.TableName{Name: userTable, Schema: db.schemaName}, head, ws)
461+
dt, err := dtables.NewWorkspaceTable(ctx, tblName, tname, head, ws)
461462
if err != nil {
462463
return nil, false, err
463464
}

‎go/libraries/doltcore/sqle/dtables/blame_view.go‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -70,7 +70,7 @@ const (
7070
func NewBlameView(ctx *sql.Context, tableName doltdb.TableName, root doltdb.RootValue) (string, error) {
7171
var table *doltdb.Table
7272
var err error
73-
table, tableName, err = mustGetTableInsensitive(ctx, root, tableName)
73+
table, tableName, err = getTableInsensitiveOrError(ctx, root, tableName)
7474
if err != nil {
7575
return "", err
7676
}

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -62,7 +62,7 @@ func NewCommitDiffTable(ctx *sql.Context, dbName string, tblName doltdb.TableNam
6262

6363
var table *doltdb.Table
6464
var err error
65-
table, tblName, err = mustGetTableInsensitive(ctx, wRoot, tblName)
65+
table, tblName, err = getTableInsensitiveOrError(ctx, wRoot, tblName)
6666
if err != nil {
6767
return nil, err
6868
}

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

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -28,16 +28,16 @@ import (
2828
)
2929

3030
// NewConflictsTable returns a new ConflictsTable instance
31-
func NewConflictsTable(ctx *sql.Context, tblName doltdb.TableName, srcTbl sql.Table, root doltdb.RootValue, rs RootSetter) (sql.Table, error) {
31+
func NewConflictsTable(ctx *sql.Context, tblName doltdb.TableName, srcTable sql.Table, root doltdb.RootValue, rs RootSetter) (sql.Table, error) {
3232
var tbl *doltdb.Table
3333
var err error
34-
tbl, tblName, err = mustGetTableInsensitive(ctx, root, tblName)
34+
tbl, tblName, err = getTableInsensitiveOrError(ctx, root, tblName)
3535
if err != nil {
3636
return nil, err
3737
}
3838

3939
if types.IsFormat_DOLT(tbl.Format()) {
40-
upd, ok := srcTbl.(sql.UpdatableTable)
40+
upd, ok := srcTable.(sql.UpdatableTable)
4141
if !ok {
4242
return nil, fmt.Errorf("%s can not have conflicts because it is not updateable", tblName)
4343
}

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

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -119,8 +119,7 @@ func (ct ProllyConflictsTable) PartitionRows(ctx *sql.Context, part sql.Partitio
119119
}
120120

121121
func (ct ProllyConflictsTable) Updater(ctx *sql.Context) sql.RowUpdater {
122-
ourUpdater := ct.sqlTable.Updater(ctx)
123-
return newProllyConflictOurTableUpdater(ourUpdater, ct.versionMappings, ct.baseSch, ct.ourSch, ct.theirSch)
122+
return newProllyConflictOurTableUpdater(ctx, ct)
124123
}
125124

126125
func (ct ProllyConflictsTable) Deleter(ctx *sql.Context) sql.RowDeleter {
@@ -469,11 +468,12 @@ type prollyConflictOurTableUpdater struct {
469468
schemaOK bool
470469
}
471470

472-
func newProllyConflictOurTableUpdater(ourUpdater sql.RowUpdater, versionMappings *versionMappings, baseSch, ourSch, theirSch schema.Schema) *prollyConflictOurTableUpdater {
471+
func newProllyConflictOurTableUpdater(ctx *sql.Context, ct ProllyConflictsTable) *prollyConflictOurTableUpdater {
472+
ourUpdater := ct.sqlTable.Updater(ctx)
473473
return &prollyConflictOurTableUpdater{
474474
srcUpdater: ourUpdater,
475-
versionMappings: versionMappings,
476-
pkOrdinals: ourSch.GetPkOrdinals(),
475+
versionMappings: ct.versionMappings,
476+
pkOrdinals: ct.ourSch.GetPkOrdinals(),
477477
}
478478
}
479479

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,7 @@ func NewConstraintViolationsTable(ctx *sql.Context, tblName doltdb.TableName, ro
3838
func newNomsCVTable(ctx *sql.Context, tblName doltdb.TableName, root doltdb.RootValue, rs RootSetter) (sql.Table, error) {
3939
var tbl *doltdb.Table
4040
var err error
41-
tbl, tblName, err = mustGetTableInsensitive(ctx, root, tblName)
41+
tbl, tblName, err = getTableInsensitiveOrError(ctx, root, tblName)
4242
if err != nil {
4343
return nil, err
4444
}

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,7 @@ import (
3535
func newProllyCVTable(ctx *sql.Context, tblName doltdb.TableName, root doltdb.RootValue, rs RootSetter) (sql.Table, error) {
3636
var tbl *doltdb.Table
3737
var err error
38-
tbl, tblName, err = mustGetTableInsensitive(ctx, root, tblName)
38+
tbl, tblName, err = getTableInsensitiveOrError(ctx, root, tblName)
3939
if err != nil {
4040
return nil, err
4141
}

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

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -86,7 +86,7 @@ var PrimaryKeyChangeWarning = "cannot render full diff between commits %s and %s
8686

8787
const PrimaryKeyChangeWarningCode int = 1105 // Since this is our own custom warning we'll use 1105, the code for an unknown error
8888

89-
func mustGetTableInsensitive(ctx *sql.Context, root doltdb.RootValue, tblName doltdb.TableName) (*doltdb.Table, doltdb.TableName, error) {
89+
func getTableInsensitiveOrError(ctx *sql.Context, root doltdb.RootValue, tblName doltdb.TableName) (*doltdb.Table, doltdb.TableName, error) {
9090
table, correctedTableName, tableExists, err := doltdb.GetTableInsensitive(ctx, root, tblName)
9191
if err != nil {
9292
return nil, tblName, err
@@ -103,7 +103,7 @@ func NewDiffTable(ctx *sql.Context, dbName string, tblName doltdb.TableName, ddb
103103

104104
var table *doltdb.Table
105105
var err error
106-
table, tblName, err = mustGetTableInsensitive(ctx, root, tblName)
106+
table, tblName, err = getTableInsensitiveOrError(ctx, root, tblName)
107107
if err != nil {
108108
return nil, err
109109
}

0 commit comments

Comments
 (0)