From a47ace9b655753e24ebe737b08c98edb18e80b71 Mon Sep 17 00:00:00 2001 From: "Santiago M. Mola" Date: Fri, 18 Nov 2016 11:18:36 +0100 Subject: [PATCH] rename *relation to *table. PhysicalRelation is now Table, this is shorter, readable and more understandeable for most people. --- git/blobs.go | 22 +++++++++--------- git/blobs_test.go | 14 +++++------ git/commits.go | 22 +++++++++--------- git/commits_test.go | 14 +++++------ git/database.go | 44 +++++++++++++++++------------------ git/database_test.go | 8 +++---- git/references.go | 22 +++++++++--------- git/references_test.go | 14 +++++------ git/tags.go | 22 +++++++++--------- git/tags_test.go | 14 +++++------ git/tree_entries.go | 22 +++++++++--------- git/tree_entries_test.go | 14 +++++------ mem/database.go | 6 ++--- mem/database_test.go | 12 +++++----- sql/analyzer/analyzer_test.go | 14 +++++------ sql/analyzer/rules.go | 2 +- sql/analyzer/rules_test.go | 6 ++--- sql/catalog.go | 4 ++-- sql/core.go | 2 +- sql/database.go | 2 +- sql/parse/parse.go | 16 ++++++------- sql/parse/parse_test.go | 16 ++++++------- sql/plan/transform_test.go | 4 ++-- sql/plan/unresolved.go | 22 +++++++++--------- sql/plan/unresolved_test.go | 6 ++--- 25 files changed, 172 insertions(+), 172 deletions(-) diff --git a/git/blobs.go b/git/blobs.go index f33db1e44..69528cd3b 100644 --- a/git/blobs.go +++ b/git/blobs.go @@ -6,38 +6,38 @@ import ( "gopkg.in/src-d/go-git.v4" ) -type blobsRelation struct { +type blobsTable struct { r *git.Repository } -func newBlobsRelation(r *git.Repository) sql.PhysicalRelation { - return &blobsRelation{r: r} +func newBlobsTable(r *git.Repository) sql.Table { + return &blobsTable{r: r} } -func (blobsRelation) Resolved() bool { +func (blobsTable) Resolved() bool { return true } -func (blobsRelation) Name() string { - return blobsRelationName +func (blobsTable) Name() string { + return blobsTableName } -func (blobsRelation) Schema() sql.Schema { +func (blobsTable) Schema() sql.Schema { return sql.Schema{ sql.Field{"hash", sql.String}, sql.Field{"size", sql.BigInteger}, } } -func (r *blobsRelation) TransformUp(f func(sql.Node) sql.Node) sql.Node { +func (r *blobsTable) TransformUp(f func(sql.Node) sql.Node) sql.Node { return f(r) } -func (r *blobsRelation) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node { +func (r *blobsTable) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node { return r } -func (r blobsRelation) RowIter() (sql.RowIter, error) { +func (r blobsTable) RowIter() (sql.RowIter, error) { bIter, err := r.r.Blobs() if err != nil { return nil, err @@ -46,7 +46,7 @@ func (r blobsRelation) RowIter() (sql.RowIter, error) { return iter, nil } -func (blobsRelation) Children() []sql.Node { +func (blobsTable) Children() []sql.Node { return []sql.Node{} } diff --git a/git/blobs_test.go b/git/blobs_test.go index 97ec43900..c0e22478b 100644 --- a/git/blobs_test.go +++ b/git/blobs_test.go @@ -8,7 +8,7 @@ import ( "gopkg.in/src-d/go-git.v4/fixtures" ) -func TestBlobsRelation(t *testing.T) { +func TestBlobsTable(t *testing.T) { assert := assert.New(t) f := fixtures.Basic().One() @@ -18,14 +18,14 @@ func TestBlobsRelation(t *testing.T) { db := NewDatabase("foo", r) assert.NotNil(db) - relations := db.Relations() - rel, ok := relations[blobsRelationName] + tables := db.Tables() + table, ok := tables[blobsTableName] assert.True(ok) - assert.NotNil(rel) - assert.Equal(blobsRelationName, rel.Name()) - assert.Equal(0, len(rel.Children())) + assert.NotNil(table) + assert.Equal(blobsTableName, table.Name()) + assert.Equal(0, len(table.Children())) - iter, err := rel.RowIter() + iter, err := table.RowIter() assert.Nil(err) assert.NotNil(iter) diff --git a/git/commits.go b/git/commits.go index 241427857..d0c294151 100644 --- a/git/commits.go +++ b/git/commits.go @@ -6,23 +6,23 @@ import ( "gopkg.in/src-d/go-git.v4" ) -type commitsRelation struct { +type commitsTable struct { r *git.Repository } -func newCommitsRelation(r *git.Repository) sql.PhysicalRelation { - return &commitsRelation{r: r} +func newCommitsTable(r *git.Repository) sql.Table { + return &commitsTable{r: r} } -func (commitsRelation) Resolved() bool { +func (commitsTable) Resolved() bool { return true } -func (commitsRelation) Name() string { - return commitsRelationName +func (commitsTable) Name() string { + return commitsTableName } -func (commitsRelation) Schema() sql.Schema { +func (commitsTable) Schema() sql.Schema { return sql.Schema{ sql.Field{"hash", sql.String}, sql.Field{"author_name", sql.String}, @@ -35,15 +35,15 @@ func (commitsRelation) Schema() sql.Schema { } } -func (r *commitsRelation) TransformUp(f func(sql.Node) sql.Node) sql.Node { +func (r *commitsTable) TransformUp(f func(sql.Node) sql.Node) sql.Node { return f(r) } -func (r *commitsRelation) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node { +func (r *commitsTable) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node { return r } -func (r commitsRelation) RowIter() (sql.RowIter, error) { +func (r commitsTable) RowIter() (sql.RowIter, error) { cIter, err := r.r.Commits() if err != nil { return nil, err @@ -52,7 +52,7 @@ func (r commitsRelation) RowIter() (sql.RowIter, error) { return iter, nil } -func (commitsRelation) Children() []sql.Node { +func (commitsTable) Children() []sql.Node { return []sql.Node{} } diff --git a/git/commits_test.go b/git/commits_test.go index 155b7ca38..fbbda0d6c 100644 --- a/git/commits_test.go +++ b/git/commits_test.go @@ -8,7 +8,7 @@ import ( "gopkg.in/src-d/go-git.v4/fixtures" ) -func TestCommitsRelation(t *testing.T) { +func TestCommitsTable(t *testing.T) { assert := assert.New(t) f := fixtures.Basic().One() @@ -18,14 +18,14 @@ func TestCommitsRelation(t *testing.T) { db := NewDatabase("foo", r) assert.NotNil(db) - relations := db.Relations() - rel, ok := relations[commitsRelationName] + tables := db.Tables() + table, ok := tables[commitsTableName] assert.True(ok) - assert.NotNil(rel) - assert.Equal(commitsRelationName, rel.Name()) - assert.Equal(0, len(rel.Children())) + assert.NotNil(table) + assert.Equal(commitsTableName, table.Name()) + assert.Equal(0, len(table.Children())) - iter, err := rel.RowIter() + iter, err := table.RowIter() assert.Nil(err) assert.NotNil(iter) diff --git a/git/database.go b/git/database.go index 7dd7aabbd..844c19865 100644 --- a/git/database.go +++ b/git/database.go @@ -7,30 +7,30 @@ import ( ) const ( - referencesRelationName = "references" - commitsRelationName = "commits" - tagsRelationName = "tags" - blobsRelationName = "blobs" - treeEntriesRelationName = "tree_entries" + referencesTableName = "references" + commitsTableName = "commits" + tagsTableName = "tags" + blobsTableName = "blobs" + treeEntriesTableName = "tree_entries" ) type Database struct { name string - cr sql.PhysicalRelation - tr sql.PhysicalRelation - rr sql.PhysicalRelation - ter sql.PhysicalRelation - br sql.PhysicalRelation + cr sql.Table + tr sql.Table + rr sql.Table + ter sql.Table + br sql.Table } func NewDatabase(name string, r *git.Repository) sql.Database { return &Database{ name: name, - cr: newCommitsRelation(r), - rr: newReferencesRelation(r), - tr: newTagsRelation(r), - br: newBlobsRelation(r), - ter: newTreeEntriesRelation(r), + cr: newCommitsTable(r), + rr: newReferencesTable(r), + tr: newTagsTable(r), + br: newBlobsTable(r), + ter: newTreeEntriesTable(r), } } @@ -38,12 +38,12 @@ func (d *Database) Name() string { return d.name } -func (d *Database) Relations() map[string]sql.PhysicalRelation { - return map[string]sql.PhysicalRelation{ - commitsRelationName: d.cr, - tagsRelationName: d.tr, - referencesRelationName: d.rr, - blobsRelationName: d.br, - treeEntriesRelationName: d.ter, +func (d *Database) Tables() map[string]sql.Table { + return map[string]sql.Table{ + commitsTableName: d.cr, + tagsTableName: d.tr, + referencesTableName: d.rr, + blobsTableName: d.br, + treeEntriesTableName: d.ter, } } diff --git a/git/database_test.go b/git/database_test.go index f56935025..9b091b7fc 100644 --- a/git/database_test.go +++ b/git/database_test.go @@ -12,7 +12,7 @@ func init() { fixtures.RootFolder = "../../../../gopkg.in/src-d/go-git.v4/fixtures/" } -func TestDatabaseRelations(t *testing.T) { +func TestDatabase_Tables(t *testing.T) { assert := assert.New(t) f := fixtures.Basic().One() @@ -22,12 +22,12 @@ func TestDatabaseRelations(t *testing.T) { db := NewDatabase("foo", r) assert.NotNil(db) - relations := db.Relations() - _, ok := relations[commitsRelationName] + tables := db.Tables() + _, ok := tables[commitsTableName] assert.True(ok) } -func TestDatabaseName(t *testing.T) { +func TestDatabase_Name(t *testing.T) { assert := assert.New(t) f := fixtures.Basic().One() diff --git a/git/references.go b/git/references.go index a01a747ec..f6cddc796 100644 --- a/git/references.go +++ b/git/references.go @@ -8,23 +8,23 @@ import ( "gopkg.in/src-d/go-git.v4/plumbing/storer" ) -type referencesRelation struct { +type referencesTable struct { r *git.Repository } -func newReferencesRelation(r *git.Repository) sql.PhysicalRelation { - return &referencesRelation{r: r} +func newReferencesTable(r *git.Repository) sql.Table { + return &referencesTable{r: r} } -func (referencesRelation) Resolved() bool { +func (referencesTable) Resolved() bool { return true } -func (referencesRelation) Name() string { - return referencesRelationName +func (referencesTable) Name() string { + return referencesTableName } -func (referencesRelation) Schema() sql.Schema { +func (referencesTable) Schema() sql.Schema { return sql.Schema{ sql.Field{"hash", sql.String}, sql.Field{"name", sql.String}, @@ -36,15 +36,15 @@ func (referencesRelation) Schema() sql.Schema { } } -func (r *referencesRelation) TransformUp(f func(sql.Node) sql.Node) sql.Node { +func (r *referencesTable) TransformUp(f func(sql.Node) sql.Node) sql.Node { return f(r) } -func (r *referencesRelation) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node { +func (r *referencesTable) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node { return r } -func (r referencesRelation) RowIter() (sql.RowIter, error) { +func (r referencesTable) RowIter() (sql.RowIter, error) { rIter, err := r.r.Refs() if err != nil { return nil, err @@ -53,7 +53,7 @@ func (r referencesRelation) RowIter() (sql.RowIter, error) { return iter, nil } -func (referencesRelation) Children() []sql.Node { +func (referencesTable) Children() []sql.Node { return []sql.Node{} } diff --git a/git/references_test.go b/git/references_test.go index ee59ad52b..df1438764 100644 --- a/git/references_test.go +++ b/git/references_test.go @@ -8,7 +8,7 @@ import ( "gopkg.in/src-d/go-git.v4/fixtures" ) -func TestRefsRelation(t *testing.T) { +func TestReferencesTable(t *testing.T) { assert := assert.New(t) f := fixtures.Basic().One() @@ -18,14 +18,14 @@ func TestRefsRelation(t *testing.T) { db := NewDatabase("foo", r) assert.NotNil(db) - relations := db.Relations() - rel, ok := relations[referencesRelationName] + tables := db.Tables() + table, ok := tables[referencesTableName] assert.True(ok) - assert.NotNil(rel) - assert.Equal(referencesRelationName, rel.Name()) - assert.Equal(0, len(rel.Children())) + assert.NotNil(table) + assert.Equal(referencesTableName, table.Name()) + assert.Equal(0, len(table.Children())) - iter, err := rel.RowIter() + iter, err := table.RowIter() assert.Nil(err) assert.NotNil(iter) diff --git a/git/tags.go b/git/tags.go index c61e25fb9..6106edd44 100644 --- a/git/tags.go +++ b/git/tags.go @@ -6,23 +6,23 @@ import ( "gopkg.in/src-d/go-git.v4" ) -type tagsRelation struct { +type tagsTable struct { r *git.Repository } -func newTagsRelation(r *git.Repository) sql.PhysicalRelation { - return &tagsRelation{r: r} +func newTagsTable(r *git.Repository) sql.Table { + return &tagsTable{r: r} } -func (tagsRelation) Resolved() bool { +func (tagsTable) Resolved() bool { return true } -func (tagsRelation) Name() string { - return tagsRelationName +func (tagsTable) Name() string { + return tagsTableName } -func (tagsRelation) Schema() sql.Schema { +func (tagsTable) Schema() sql.Schema { return sql.Schema{ sql.Field{"hash", sql.String}, sql.Field{"name", sql.String}, @@ -34,15 +34,15 @@ func (tagsRelation) Schema() sql.Schema { } } -func (r *tagsRelation) TransformUp(f func(sql.Node) sql.Node) sql.Node { +func (r *tagsTable) TransformUp(f func(sql.Node) sql.Node) sql.Node { return f(r) } -func (r *tagsRelation) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node { +func (r *tagsTable) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node { return r } -func (r tagsRelation) RowIter() (sql.RowIter, error) { +func (r tagsTable) RowIter() (sql.RowIter, error) { tIter, err := r.r.Tags() if err != nil { return nil, err @@ -51,7 +51,7 @@ func (r tagsRelation) RowIter() (sql.RowIter, error) { return iter, nil } -func (tagsRelation) Children() []sql.Node { +func (tagsTable) Children() []sql.Node { return []sql.Node{} } diff --git a/git/tags_test.go b/git/tags_test.go index afd643b7b..b67d369fd 100644 --- a/git/tags_test.go +++ b/git/tags_test.go @@ -9,7 +9,7 @@ import ( "gopkg.in/src-d/go-git.v4/fixtures" ) -func TestTagsRelation(t *testing.T) { +func TestTagsTable(t *testing.T) { assert := assert.New(t) f := fixtures.ByTag("tags").One() @@ -19,14 +19,14 @@ func TestTagsRelation(t *testing.T) { db := NewDatabase("foo", r) assert.NotNil(db) - relations := db.Relations() - rel, ok := relations[tagsRelationName] + tables := db.Tables() + table, ok := tables[tagsTableName] assert.True(ok) - assert.NotNil(rel) - assert.Equal(tagsRelationName, rel.Name()) - assert.Equal(0, len(rel.Children())) + assert.NotNil(table) + assert.Equal(tagsTableName, table.Name()) + assert.Equal(0, len(table.Children())) - iter, err := rel.RowIter() + iter, err := table.RowIter() assert.Nil(err) assert.NotNil(iter) diff --git a/git/tree_entries.go b/git/tree_entries.go index 32d9528b4..24816f5b8 100644 --- a/git/tree_entries.go +++ b/git/tree_entries.go @@ -8,23 +8,23 @@ import ( "gopkg.in/src-d/go-git.v4" ) -type treeEntriesRelation struct { +type treeEntriesTable struct { r *git.Repository } -func newTreeEntriesRelation(r *git.Repository) sql.PhysicalRelation { - return &treeEntriesRelation{r: r} +func newTreeEntriesTable(r *git.Repository) sql.Table { + return &treeEntriesTable{r: r} } -func (treeEntriesRelation) Resolved() bool { +func (treeEntriesTable) Resolved() bool { return true } -func (treeEntriesRelation) Name() string { - return treeEntriesRelationName +func (treeEntriesTable) Name() string { + return treeEntriesTableName } -func (treeEntriesRelation) Schema() sql.Schema { +func (treeEntriesTable) Schema() sql.Schema { return sql.Schema{ sql.Field{"tree_hash", sql.String}, sql.Field{"entry_hash", sql.String}, @@ -33,15 +33,15 @@ func (treeEntriesRelation) Schema() sql.Schema { } } -func (r *treeEntriesRelation) TransformUp(f func(sql.Node) sql.Node) sql.Node { +func (r *treeEntriesTable) TransformUp(f func(sql.Node) sql.Node) sql.Node { return f(r) } -func (r *treeEntriesRelation) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node { +func (r *treeEntriesTable) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node { return r } -func (r treeEntriesRelation) RowIter() (sql.RowIter, error) { +func (r treeEntriesTable) RowIter() (sql.RowIter, error) { cIter, err := r.r.Trees() if err != nil { return nil, err @@ -50,7 +50,7 @@ func (r treeEntriesRelation) RowIter() (sql.RowIter, error) { return iter, nil } -func (treeEntriesRelation) Children() []sql.Node { +func (treeEntriesTable) Children() []sql.Node { return []sql.Node{} } diff --git a/git/tree_entries_test.go b/git/tree_entries_test.go index 7d8589e8e..332460511 100644 --- a/git/tree_entries_test.go +++ b/git/tree_entries_test.go @@ -8,7 +8,7 @@ import ( "gopkg.in/src-d/go-git.v4/fixtures" ) -func TestTreeEntriesRelation(t *testing.T) { +func TestTreeEntriesTable(t *testing.T) { assert := assert.New(t) f := fixtures.Basic().One() @@ -18,14 +18,14 @@ func TestTreeEntriesRelation(t *testing.T) { db := NewDatabase("foo", r) assert.NotNil(db) - relations := db.Relations() - rel, ok := relations[treeEntriesRelationName] + tables := db.Tables() + table, ok := tables[treeEntriesTableName] assert.True(ok) - assert.NotNil(rel) - assert.Equal(treeEntriesRelationName, rel.Name()) - assert.Equal(0, len(rel.Children())) + assert.NotNil(table) + assert.Equal(treeEntriesTableName, table.Name()) + assert.Equal(0, len(table.Children())) - iter, err := rel.RowIter() + iter, err := table.RowIter() assert.Nil(err) assert.NotNil(iter) diff --git a/mem/database.go b/mem/database.go index 075143bcf..d081c5a11 100644 --- a/mem/database.go +++ b/mem/database.go @@ -4,13 +4,13 @@ import "github.com/gitql/gitql/sql" type Database struct { name string - tables map[string]sql.PhysicalRelation + tables map[string]sql.Table } func NewDatabase(name string) *Database { return &Database{ name: name, - tables: map[string]sql.PhysicalRelation{}, + tables: map[string]sql.Table{}, } } @@ -18,7 +18,7 @@ func (d *Database) Name() string { return d.name } -func (d *Database) Relations() map[string]sql.PhysicalRelation { +func (d *Database) Tables() map[string]sql.Table { return d.tables } diff --git a/mem/database_test.go b/mem/database_test.go index f79fb0661..a11656314 100644 --- a/mem/database_test.go +++ b/mem/database_test.go @@ -17,13 +17,13 @@ func TestDatabase_Name(t *testing.T) { func TestDatabase_AddTable(t *testing.T) { assert := assert.New(t) db := NewDatabase("test") - relations := db.Relations() - assert.Equal(0, len(relations)) + tables := db.Tables() + assert.Equal(0, len(tables)) table := &Table{"test_table", sql.Schema{}, nil} db.AddTable("test_table", table) - relations = db.Relations() - assert.Equal(1, len(relations)) - rel, ok := relations["test_table"] + tables = db.Tables() + assert.Equal(1, len(tables)) + tt, ok := tables["test_table"] assert.True(ok) - assert.NotNil(rel) + assert.NotNil(tt) } diff --git a/sql/analyzer/analyzer_test.go b/sql/analyzer/analyzer_test.go index 8362bfbe2..909bcc3c7 100644 --- a/sql/analyzer/analyzer_test.go +++ b/sql/analyzer/analyzer_test.go @@ -24,12 +24,12 @@ func TestAnalyzer_Analyze(t *testing.T) { a := analyzer.New(catalog) a.CurrentDatabase = "mydb" - var notAnalyzed sql.Node = plan.NewUnresolvedRelation("mytable") + var notAnalyzed sql.Node = plan.NewUnresolvedTable("mytable") analyzed, err := a.Analyze(notAnalyzed) assert.Nil(err) assert.Equal(table, analyzed) - notAnalyzed = plan.NewUnresolvedRelation("nonexistant") + notAnalyzed = plan.NewUnresolvedTable("nonexistant") analyzed, err = a.Analyze(notAnalyzed) assert.NotNil(err) assert.Equal(notAnalyzed, analyzed) @@ -40,7 +40,7 @@ func TestAnalyzer_Analyze(t *testing.T) { notAnalyzed = plan.NewProject( []sql.Expression{expression.NewUnresolvedColumn("i")}, - plan.NewUnresolvedRelation("mytable"), + plan.NewUnresolvedTable("mytable"), ) analyzed, err = a.Analyze(notAnalyzed) expected := plan.NewProject( @@ -57,7 +57,7 @@ func TestAnalyzer_Analyze(t *testing.T) { expression.NewUnresolvedColumn("i"), expression.NewLiteral(int32(1), sql.Integer), ), - plan.NewUnresolvedRelation("mytable"), + plan.NewUnresolvedTable("mytable"), ), ) analyzed, err = a.Analyze(notAnalyzed) @@ -87,12 +87,12 @@ func TestAnalyzer_Analyze_MaxIterations(t *testing.T) { "infinite", func(a *analyzer.Analyzer, n sql.Node) sql.Node { i += 1 - return plan.NewUnresolvedRelation(fmt.Sprintf("rel%d", i)) + return plan.NewUnresolvedTable(fmt.Sprintf("table%d", i)) }, }} - notAnalyzed := plan.NewUnresolvedRelation("mytable") + notAnalyzed := plan.NewUnresolvedTable("mytable") analyzed, err := a.Analyze(notAnalyzed) assert.NotNil(err) - assert.Equal(plan.NewUnresolvedRelation("rel1001"), analyzed) + assert.Equal(plan.NewUnresolvedTable("table1001"), analyzed) } diff --git a/sql/analyzer/rules.go b/sql/analyzer/rules.go index 1d5c553a3..24e8924fa 100644 --- a/sql/analyzer/rules.go +++ b/sql/analyzer/rules.go @@ -13,7 +13,7 @@ var DefaultRules = []Rule{ func resolveTables(a *Analyzer, n sql.Node) sql.Node { return n.TransformUp(func(n sql.Node) sql.Node { - t, ok := n.(*plan.UnresolvedRelation) + t, ok := n.(*plan.UnresolvedTable) if !ok { return n } diff --git a/sql/analyzer/rules_test.go b/sql/analyzer/rules_test.go index 4b9a60b44..0de3f67c8 100644 --- a/sql/analyzer/rules_test.go +++ b/sql/analyzer/rules_test.go @@ -27,11 +27,11 @@ func Test_resolveTables(t *testing.T) { a.Rules = []analyzer.Rule{f} a.CurrentDatabase = "mydb" - var notAnalyzed sql.Node = plan.NewUnresolvedRelation("mytable") + var notAnalyzed sql.Node = plan.NewUnresolvedTable("mytable") analyzed := f.Apply(a, notAnalyzed) assert.Equal(table, analyzed) - notAnalyzed = plan.NewUnresolvedRelation("nonexistant") + notAnalyzed = plan.NewUnresolvedTable("nonexistant") analyzed = f.Apply(a, notAnalyzed) assert.Equal(notAnalyzed, analyzed) @@ -57,7 +57,7 @@ func Test_resolveTables_Nested(t *testing.T) { notAnalyzed := plan.NewProject( []sql.Expression{expression.NewGetField(0, sql.Integer, "i")}, - plan.NewUnresolvedRelation("mytable"), + plan.NewUnresolvedTable("mytable"), ) analyzed := f.Apply(a, notAnalyzed) expected := plan.NewProject( diff --git a/sql/catalog.go b/sql/catalog.go index 48a36fe85..d61d60d01 100644 --- a/sql/catalog.go +++ b/sql/catalog.go @@ -18,13 +18,13 @@ func (c Catalog) Database(name string) (Database, error) { return nil, fmt.Errorf("database not found: %s", name) } -func (c Catalog) Table(dbName string, tableName string) (PhysicalRelation, error) { +func (c Catalog) Table(dbName string, tableName string) (Table, error) { db, err := c.Database(dbName) if err != nil { return nil, err } - tables := db.Relations() + tables := db.Tables() table, found := tables[tableName] if !found { return nil, fmt.Errorf("table not found: %s", tableName) diff --git a/sql/core.go b/sql/core.go index d0ca0a163..87f1b3950 100644 --- a/sql/core.go +++ b/sql/core.go @@ -23,7 +23,7 @@ type Node interface { RowIter() (RowIter, error) } -type PhysicalRelation interface { +type Table interface { Nameable Node } diff --git a/sql/database.go b/sql/database.go index 463c604a1..7eb97f988 100644 --- a/sql/database.go +++ b/sql/database.go @@ -2,5 +2,5 @@ package sql type Database interface { Nameable - Relations() map[string]PhysicalRelation + Tables() map[string]Table } diff --git a/sql/parse/parse.go b/sql/parse/parse.go index 6c14829b7..decf43b59 100644 --- a/sql/parse/parse.go +++ b/sql/parse/parse.go @@ -20,7 +20,7 @@ const ( SelectState SelectFieldList FromState - FromRelationState + FromTableState WhereState WhereClauseState OrderState @@ -43,7 +43,7 @@ type parser struct { err error projection []sql.Expression - relation string + table string filterClauses []sql.Expression sortFields []plan.SortField limit *int @@ -166,17 +166,17 @@ func (p *parser) parse() error { p.errorf("expecting 'FROM', %q received", t.Value) } else { p.stateStack.pop() - p.stateStack.put(FromRelationState) + p.stateStack.put(FromTableState) } - case FromRelationState: + case FromTableState: t = p.lexer.Next() if t == nil || t.Type == EOFToken { p.errorf("expecting table name, nothing received") } else if t.Type != IdentifierToken { p.errorf("expecting table name, %q received instead", t.Value) } else { - p.relation = t.Value + p.table = t.Value p.stateStack.pop() p.stateStack.put(WhereState) } @@ -272,11 +272,11 @@ func (p *parser) parse() error { } func (p *parser) buildPlan() (sql.Node, error) { - if p.relation == "" { - return nil, errors.New("missing relation name") + if p.table == "" { + return nil, errors.New("missing table name") } - var node sql.Node = plan.NewUnresolvedRelation(p.relation) + var node sql.Node = plan.NewUnresolvedTable(p.table) if len(p.filterClauses) > 0 { node = plan.NewFilter(p.filterClauses[0], node) diff --git a/sql/parse/parse_test.go b/sql/parse/parse_test.go index 6c202e063..b3de3a858 100644 --- a/sql/parse/parse_test.go +++ b/sql/parse/parse_test.go @@ -17,7 +17,7 @@ var fixtures = map[string]sql.Node{ expression.NewUnresolvedColumn("foo"), expression.NewUnresolvedColumn("bar"), }, - plan.NewUnresolvedRelation("foo"), + plan.NewUnresolvedTable("foo"), ), `SELECT foo, bar FROM foo WHERE foo = bar;`: plan.NewProject( []sql.Expression{ @@ -29,7 +29,7 @@ var fixtures = map[string]sql.Node{ expression.NewUnresolvedColumn("foo"), expression.NewUnresolvedColumn("bar"), ), - plan.NewUnresolvedRelation("foo"), + plan.NewUnresolvedTable("foo"), ), ), `SELECT foo, bar FROM foo WHERE foo = 'bar';`: plan.NewProject( @@ -42,7 +42,7 @@ var fixtures = map[string]sql.Node{ expression.NewUnresolvedColumn("foo"), expression.NewLiteral("bar", sql.String), ), - plan.NewUnresolvedRelation("foo"), + plan.NewUnresolvedTable("foo"), ), ), `SELECT foo, bar FROM foo LIMIT 10;`: plan.NewProject( @@ -51,7 +51,7 @@ var fixtures = map[string]sql.Node{ expression.NewUnresolvedColumn("bar"), }, plan.NewLimit(int64(10), - plan.NewUnresolvedRelation("foo"), + plan.NewUnresolvedTable("foo"), ), ), `SELECT foo, bar FROM foo ORDER BY baz DESC;`: plan.NewProject( @@ -61,7 +61,7 @@ var fixtures = map[string]sql.Node{ }, plan.NewSort( []plan.SortField{{expression.NewUnresolvedColumn("baz"), plan.Descending}}, - plan.NewUnresolvedRelation("foo"), + plan.NewUnresolvedTable("foo"), ), ), `SELECT foo, bar FROM foo WHERE foo = bar LIMIT 10;`: plan.NewProject( @@ -75,7 +75,7 @@ var fixtures = map[string]sql.Node{ expression.NewUnresolvedColumn("foo"), expression.NewUnresolvedColumn("bar"), ), - plan.NewUnresolvedRelation("foo"), + plan.NewUnresolvedTable("foo"), ), ), ), @@ -87,7 +87,7 @@ var fixtures = map[string]sql.Node{ plan.NewLimit(int64(1), plan.NewSort( []plan.SortField{{expression.NewUnresolvedColumn("baz"), plan.Descending}}, - plan.NewUnresolvedRelation("foo"), + plan.NewUnresolvedTable("foo"), ), ), ), @@ -104,7 +104,7 @@ var fixtures = map[string]sql.Node{ expression.NewUnresolvedColumn("qux"), expression.NewLiteral(int64(1), sql.BigInteger), ), - plan.NewUnresolvedRelation("foo"), + plan.NewUnresolvedTable("foo"), ), ), ), diff --git a/sql/plan/transform_test.go b/sql/plan/transform_test.go index 4f58a6970..471e29d45 100644 --- a/sql/plan/transform_test.go +++ b/sql/plan/transform_test.go @@ -15,7 +15,7 @@ func TestTransformUp(t *testing.T) { aCol := expression.NewUnresolvedColumn("a") bCol := expression.NewUnresolvedColumn("a") - ur := &UnresolvedRelation{"unresolved"} + ur := &UnresolvedTable{"unresolved"} p := NewProject([]sql.Expression{aCol, bCol}, NewFilter(expression.NewEquals(aCol, bCol), ur)) schema := sql.Schema{ @@ -26,7 +26,7 @@ func TestTransformUp(t *testing.T) { pt := p.TransformUp(func(n sql.Node) sql.Node { switch n.(type) { - case *UnresolvedRelation: + case *UnresolvedTable: return table default: return n diff --git a/sql/plan/unresolved.go b/sql/plan/unresolved.go index 192438cf6..937d15132 100644 --- a/sql/plan/unresolved.go +++ b/sql/plan/unresolved.go @@ -6,34 +6,34 @@ import ( "github.com/gitql/gitql/sql" ) -type UnresolvedRelation struct { +type UnresolvedTable struct { Name string } -func NewUnresolvedRelation(name string) *UnresolvedRelation { - return &UnresolvedRelation{name} +func NewUnresolvedTable(name string) *UnresolvedTable { + return &UnresolvedTable{name} } -func (*UnresolvedRelation) Resolved() bool { +func (*UnresolvedTable) Resolved() bool { return false } -func (*UnresolvedRelation) Children() []sql.Node { +func (*UnresolvedTable) Children() []sql.Node { return []sql.Node{} } -func (*UnresolvedRelation) Schema() sql.Schema { +func (*UnresolvedTable) Schema() sql.Schema { return sql.Schema{} } -func (*UnresolvedRelation) RowIter() (sql.RowIter, error) { - return nil, fmt.Errorf("unresolved relation") +func (*UnresolvedTable) RowIter() (sql.RowIter, error) { + return nil, fmt.Errorf("unresolved table") } -func (p *UnresolvedRelation) TransformUp(f func(sql.Node) sql.Node) sql.Node { - return f(NewUnresolvedRelation(p.Name)) +func (p *UnresolvedTable) TransformUp(f func(sql.Node) sql.Node) sql.Node { + return f(NewUnresolvedTable(p.Name)) } -func (p *UnresolvedRelation) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node { +func (p *UnresolvedTable) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node { return p } diff --git a/sql/plan/unresolved_test.go b/sql/plan/unresolved_test.go index 6e8541255..3d4b05b72 100644 --- a/sql/plan/unresolved_test.go +++ b/sql/plan/unresolved_test.go @@ -8,8 +8,8 @@ import ( "github.com/stretchr/testify/assert" ) -func TestUnresolvedRelation(t *testing.T) { +func TestUnresolvedTable(t *testing.T) { assert := assert.New(t) - var r sql.Node = NewUnresolvedRelation("test_table") - assert.NotNil(r) + var n sql.Node = NewUnresolvedTable("test_table") + assert.NotNil(n) }