Skip to content

Commit 5fb8fb1

Browse files
tbantle22tbantle22
authored
Merge pull request #8527 from dolthub/taylor/pref-dtables
Support multiple schema for system tables with $tablename for doltgres
2 parents 1785ef9 + eba40a9 commit 5fb8fb1

14 files changed

+213
-136
lines changed

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

Lines changed: 60 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -330,20 +330,38 @@ func (db Database) getTableInsensitive(ctx *sql.Context, head *doltdb.Commit, ds
330330
}
331331
}
332332

333-
tableName := tblName[len(doltdb.DoltDiffTablePrefix):]
334-
dt, err := dtables.NewDiffTable(ctx, db.Name(), tableName, db.ddb, root, head)
333+
baseTableName := tblName[len(doltdb.DoltDiffTablePrefix):]
334+
tname := doltdb.TableName{Name: baseTableName, Schema: db.schemaName}
335+
if resolve.UseSearchPath && db.schemaName == "" {
336+
var err error
337+
tname, _, _, err = resolve.Table(ctx, root, baseTableName)
338+
if err != nil {
339+
return nil, false, err
340+
}
341+
}
342+
343+
dt, err := dtables.NewDiffTable(ctx, db.Name(), tname, db.ddb, root, head)
335344
if err != nil {
336345
return nil, false, err
337346
}
338347
return dt, true, nil
339348

340349
case strings.HasPrefix(lwrName, doltdb.DoltCommitDiffTablePrefix):
341-
suffix := tblName[len(doltdb.DoltCommitDiffTablePrefix):]
350+
baseTableName := tblName[len(doltdb.DoltCommitDiffTablePrefix):]
351+
tname := doltdb.TableName{Name: baseTableName, Schema: db.schemaName}
352+
if resolve.UseSearchPath && db.schemaName == "" {
353+
var err error
354+
tname, _, _, err = resolve.Table(ctx, root, baseTableName)
355+
if err != nil {
356+
return nil, false, err
357+
}
358+
}
359+
342360
ws, err := ds.WorkingSet(ctx, db.RevisionQualifiedName())
343361
if err != nil {
344362
return nil, false, err
345363
}
346-
dt, err := dtables.NewCommitDiffTable(ctx, db.Name(), suffix, db.ddb, root, ws.StagedRoot())
364+
dt, err := dtables.NewCommitDiffTable(ctx, db.Name(), tname, db.ddb, root, ws.StagedRoot())
347365
if err != nil {
348366
return nil, false, err
349367
}
@@ -377,22 +395,40 @@ func (db Database) getTableInsensitive(ctx *sql.Context, head *doltdb.Commit, ds
377395
}
378396

379397
case strings.HasPrefix(lwrName, doltdb.DoltConfTablePrefix):
380-
suffix := tblName[len(doltdb.DoltConfTablePrefix):]
381-
srcTable, ok, err := db.getTableInsensitive(ctx, head, ds, root, suffix, asOf)
398+
baseTableName := tblName[len(doltdb.DoltConfTablePrefix):]
399+
tname := doltdb.TableName{Name: baseTableName, Schema: db.schemaName}
400+
if resolve.UseSearchPath && db.schemaName == "" {
401+
var err error
402+
tname, _, _, err = resolve.Table(ctx, root, baseTableName)
403+
if err != nil {
404+
return nil, false, err
405+
}
406+
}
407+
408+
srcTable, ok, err := db.getTableInsensitive(ctx, head, ds, root, tname.Name, asOf)
382409
if err != nil {
383410
return nil, false, err
384411
} else if !ok {
385412
return nil, false, nil
386413
}
387-
dt, err := dtables.NewConflictsTable(ctx, suffix, srcTable, root, dtables.RootSetter(db))
414+
dt, err := dtables.NewConflictsTable(ctx, tname, srcTable, root, dtables.RootSetter(db))
388415
if err != nil {
389416
return nil, false, err
390417
}
391418
return dt, true, nil
392419

393420
case strings.HasPrefix(lwrName, doltdb.DoltConstViolTablePrefix):
394-
suffix := tblName[len(doltdb.DoltConstViolTablePrefix):]
395-
dt, err := dtables.NewConstraintViolationsTable(ctx, suffix, root, dtables.RootSetter(db))
421+
baseTableName := tblName[len(doltdb.DoltConstViolTablePrefix):]
422+
tname := doltdb.TableName{Name: baseTableName, Schema: db.schemaName}
423+
if resolve.UseSearchPath && db.schemaName == "" {
424+
var err error
425+
tname, _, _, err = resolve.Table(ctx, root, baseTableName)
426+
if err != nil {
427+
return nil, false, err
428+
}
429+
}
430+
431+
dt, err := dtables.NewConstraintViolationsTable(ctx, tname, root, dtables.RootSetter(db))
396432
if err != nil {
397433
return nil, false, err
398434
}
@@ -408,9 +444,21 @@ func (db Database) getTableInsensitive(ctx *sql.Context, head *doltdb.Commit, ds
408444
roots, _ := sess.GetRoots(ctx, db.RevisionQualifiedName())
409445
head := roots.Head
410446

411-
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+
}
412460

413-
dt, err := dtables.NewWorkspaceTable(ctx, tblName, userTable, head, ws)
461+
dt, err := dtables.NewWorkspaceTable(ctx, tblName, tname, head, ws)
414462
if err != nil {
415463
return nil, false, err
416464
}
@@ -1621,7 +1669,7 @@ func (db Database) GetViewDefinition(ctx *sql.Context, viewName string) (sql.Vie
16211669
case strings.HasPrefix(lwrViewName, doltdb.DoltBlameViewPrefix):
16221670
tableName := lwrViewName[len(doltdb.DoltBlameViewPrefix):]
16231671

1624-
blameViewTextDef, err := dtables.NewBlameView(ctx, tableName, root)
1672+
blameViewTextDef, err := dtables.NewBlameView(ctx, doltdb.TableName{Name: tableName, Schema: db.schemaName}, root)
16251673
if err != nil {
16261674
return sql.ViewDefinition{}, false, err
16271675
}

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

Lines changed: 5 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -67,21 +67,20 @@ const (
6767
// NewBlameView returns a view expression for the DOLT_BLAME system view for the specified table.
6868
// The DOLT_BLAME system view is a view on the DOLT_DIFF system table that shows the latest commit
6969
// for each primary key in the specified table.
70-
func NewBlameView(ctx *sql.Context, tableName string, root doltdb.RootValue) (string, error) {
71-
table, _, ok, err := doltdb.GetTableInsensitive(ctx, root, doltdb.TableName{Name: tableName})
70+
func NewBlameView(ctx *sql.Context, tableName doltdb.TableName, root doltdb.RootValue) (string, error) {
71+
var table *doltdb.Table
72+
var err error
73+
table, tableName, err = getTableInsensitiveOrError(ctx, root, tableName)
7274
if err != nil {
7375
return "", err
7476
}
75-
if !ok {
76-
return "", doltdb.ErrTableNotFound
77-
}
7877

7978
sch, err := table.GetSchema(ctx)
8079
if err != nil {
8180
return "", nil
8281
}
8382

84-
blameViewExpression, err := createDoltBlameViewExpression(tableName, sch.GetPKCols().GetColumns())
83+
blameViewExpression, err := createDoltBlameViewExpression(tableName.Name, sch.GetPKCols().GetColumns())
8584
if err != nil {
8685
return "", err
8786
}

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

Lines changed: 12 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -27,7 +27,6 @@ import (
2727
"github.com/dolthub/dolt/go/libraries/doltcore/rowconv"
2828
"github.com/dolthub/dolt/go/libraries/doltcore/schema"
2929
"github.com/dolthub/dolt/go/libraries/doltcore/sqle/index"
30-
"github.com/dolthub/dolt/go/libraries/doltcore/sqle/resolve"
3130
"github.com/dolthub/dolt/go/libraries/doltcore/sqle/sqlutil"
3231
"github.com/dolthub/dolt/go/store/types"
3332
)
@@ -39,7 +38,7 @@ var ErrExactlyOneFromCommit = errors.New("dolt_commit_diff_* tables must be filt
3938
var ErrInvalidCommitDiffTableArgs = errors.New("commit_diff_<table> requires one 'to_commit' and one 'from_commit'")
4039

4140
type CommitDiffTable struct {
42-
name string
41+
tableName doltdb.TableName
4342
dbName string
4443
ddb *doltdb.DoltDB
4544
joiner *rowconv.Joiner
@@ -58,16 +57,15 @@ var _ sql.Table = (*CommitDiffTable)(nil)
5857
var _ sql.IndexAddressable = (*CommitDiffTable)(nil)
5958
var _ sql.StatisticsTable = (*CommitDiffTable)(nil)
6059

61-
func NewCommitDiffTable(ctx *sql.Context, dbName, tblName string, ddb *doltdb.DoltDB, wRoot, sRoot doltdb.RootValue) (sql.Table, error) {
62-
diffTblName := doltdb.DoltCommitDiffTablePrefix + tblName
60+
func NewCommitDiffTable(ctx *sql.Context, dbName string, tblName doltdb.TableName, ddb *doltdb.DoltDB, wRoot, sRoot doltdb.RootValue) (sql.Table, error) {
61+
diffTblName := doltdb.DoltCommitDiffTablePrefix + tblName.Name
6362

64-
_, table, tableExists, err := resolve.Table(ctx, wRoot, tblName)
63+
var table *doltdb.Table
64+
var err error
65+
table, tblName, err = getTableInsensitiveOrError(ctx, wRoot, tblName)
6566
if err != nil {
6667
return nil, err
6768
}
68-
if !tableExists {
69-
return nil, sql.ErrTableNotFound.New(diffTblName)
70-
}
7169

7270
sch, err := table.GetSchema(ctx)
7371
if err != nil {
@@ -86,7 +84,7 @@ func NewCommitDiffTable(ctx *sql.Context, dbName, tblName string, ddb *doltdb.Do
8684

8785
return &CommitDiffTable{
8886
dbName: dbName,
89-
name: tblName,
87+
tableName: tblName,
9088
ddb: ddb,
9189
workingRoot: wRoot,
9290
stagedRoot: sRoot,
@@ -110,11 +108,11 @@ func (dt *CommitDiffTable) RowCount(_ *sql.Context) (uint64, bool, error) {
110108
}
111109

112110
func (dt *CommitDiffTable) Name() string {
113-
return doltdb.DoltCommitDiffTablePrefix + dt.name
111+
return doltdb.DoltCommitDiffTablePrefix + dt.tableName.Name
114112
}
115113

116114
func (dt *CommitDiffTable) String() string {
117-
return doltdb.DoltCommitDiffTablePrefix + dt.name
115+
return doltdb.DoltCommitDiffTablePrefix + dt.tableName.Name
118116
}
119117

120118
func (dt *CommitDiffTable) Schema() sql.Schema {
@@ -128,7 +126,7 @@ func (dt *CommitDiffTable) Collation() sql.CollationID {
128126

129127
// GetIndexes implements sql.IndexAddressable
130128
func (dt *CommitDiffTable) GetIndexes(ctx *sql.Context) ([]sql.Index, error) {
131-
return []sql.Index{index.DoltToFromCommitIndex(dt.name)}, nil
129+
return []sql.Index{index.DoltToFromCommitIndex(dt.tableName.Name)}, nil
132130
}
133131

134132
// IndexedAccess implements sql.IndexAddressable
@@ -197,12 +195,12 @@ func (dt *CommitDiffTable) LookupPartitions(ctx *sql.Context, i sql.IndexLookup)
197195
return nil, err
198196
}
199197

200-
toTable, _, _, err := doltdb.GetTableInsensitive(ctx, toRoot, doltdb.TableName{Name: dt.name})
198+
toTable, _, _, err := doltdb.GetTableInsensitive(ctx, toRoot, dt.tableName)
201199
if err != nil {
202200
return nil, err
203201
}
204202

205-
fromTable, _, _, err := doltdb.GetTableInsensitive(ctx, fromRoot, doltdb.TableName{Name: dt.name})
203+
fromTable, _, _, err := doltdb.GetTableInsensitive(ctx, fromRoot, dt.tableName)
206204
if err != nil {
207205
return nil, err
208206
}

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

Lines changed: 15 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -23,39 +23,38 @@ import (
2323
"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
2424
"github.com/dolthub/dolt/go/libraries/doltcore/merge"
2525
"github.com/dolthub/dolt/go/libraries/doltcore/sqle/index"
26-
"github.com/dolthub/dolt/go/libraries/doltcore/sqle/resolve"
2726
"github.com/dolthub/dolt/go/libraries/doltcore/sqle/sqlutil"
2827
"github.com/dolthub/dolt/go/store/types"
2928
)
3029

3130
// NewConflictsTable returns a new ConflictsTable instance
32-
func NewConflictsTable(ctx *sql.Context, tblName string, srcTbl sql.Table, root doltdb.RootValue, rs RootSetter) (sql.Table, error) {
33-
resolvedTableName, tbl, ok, err := resolve.Table(ctx, root, tblName)
31+
func NewConflictsTable(ctx *sql.Context, tblName doltdb.TableName, srcTable sql.Table, root doltdb.RootValue, rs RootSetter) (sql.Table, error) {
32+
var tbl *doltdb.Table
33+
var err error
34+
tbl, tblName, err = getTableInsensitiveOrError(ctx, root, tblName)
3435
if err != nil {
3536
return nil, err
36-
} else if !ok {
37-
return nil, sql.ErrTableNotFound.New(tblName)
3837
}
3938

4039
if types.IsFormat_DOLT(tbl.Format()) {
41-
upd, ok := srcTbl.(sql.UpdatableTable)
40+
upd, ok := srcTable.(sql.UpdatableTable)
4241
if !ok {
4342
return nil, fmt.Errorf("%s can not have conflicts because it is not updateable", tblName)
4443
}
45-
return newProllyConflictsTable(ctx, tbl, upd, resolvedTableName, root, rs)
44+
return newProllyConflictsTable(ctx, tbl, upd, tblName, root, rs)
4645
}
4746

48-
return newNomsConflictsTable(ctx, tbl, resolvedTableName.Name, root, rs)
47+
return newNomsConflictsTable(ctx, tbl, tblName, root, rs)
4948
}
5049

51-
func newNomsConflictsTable(ctx *sql.Context, tbl *doltdb.Table, tblName string, root doltdb.RootValue, rs RootSetter) (sql.Table, error) {
52-
rd, err := merge.NewConflictReader(ctx, tbl, doltdb.TableName{Name: tblName})
50+
func newNomsConflictsTable(ctx *sql.Context, tbl *doltdb.Table, tblName doltdb.TableName, root doltdb.RootValue, rs RootSetter) (sql.Table, error) {
51+
rd, err := merge.NewConflictReader(ctx, tbl, tblName)
5352
if err != nil {
5453
return nil, err
5554
}
5655
confSch := rd.GetSchema()
5756

58-
sqlSch, err := sqlutil.FromDoltSchema("", doltdb.DoltConfTablePrefix+tblName, confSch)
57+
sqlSch, err := sqlutil.FromDoltSchema("", doltdb.DoltConfTablePrefix+tblName.Name, confSch)
5958
if err != nil {
6059
return nil, err
6160
}
@@ -75,7 +74,7 @@ var _ sql.DeletableTable = ConflictsTable{}
7574

7675
// ConflictsTable is a sql.Table implementation that provides access to the conflicts that exist for a user table
7776
type ConflictsTable struct {
78-
tblName string
77+
tblName doltdb.TableName
7978
sqlSch sql.PrimaryKeySchema
8079
root doltdb.RootValue
8180
tbl *doltdb.Table
@@ -89,12 +88,12 @@ type RootSetter interface {
8988

9089
// Name returns the name of the table
9190
func (ct ConflictsTable) Name() string {
92-
return doltdb.DoltConfTablePrefix + ct.tblName
91+
return doltdb.DoltConfTablePrefix + ct.tblName.Name
9392
}
9493

9594
// String returns a string identifying the table
9695
func (ct ConflictsTable) String() string {
97-
return doltdb.DoltConfTablePrefix + ct.tblName
96+
return doltdb.DoltConfTablePrefix + ct.tblName.Name
9897
}
9998

10099
// Schema returns the sql.Schema of the table
@@ -115,8 +114,7 @@ func (ct ConflictsTable) Partitions(ctx *sql.Context) (sql.PartitionIter, error)
115114
// PartitionRows returns a RowIter for the given partition
116115
func (ct ConflictsTable) PartitionRows(ctx *sql.Context, part sql.Partition) (sql.RowIter, error) {
117116
// conflict reader must be reset each time partitionRows is called.
118-
// TODO: schema name
119-
rd, err := merge.NewConflictReader(ctx, ct.tbl, doltdb.TableName{Name: ct.tblName})
117+
rd, err := merge.NewConflictReader(ctx, ct.tbl, ct.tblName)
120118
if err != nil {
121119
return nil, err
122120
}
@@ -205,7 +203,7 @@ func (cd *conflictDeleter) Close(ctx *sql.Context) error {
205203
return err
206204
}
207205

208-
updatedRoot, err := cd.ct.root.PutTable(ctx, doltdb.TableName{Name: cd.ct.tblName}, updatedTbl)
206+
updatedRoot, err := cd.ct.root.PutTable(ctx, cd.ct.tblName, updatedTbl)
209207

210208
if err != nil {
211209
return err

‎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

0 commit comments

Comments
 (0)