rename *relation to *table.

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{}
 }
 

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)
 

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{}
 }
 

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)
 

git/database.go

@@ -7,43 +7,43 @@ 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),
 	}
 }
 
 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,
 	}
 }

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()

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{}
 }
 

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)
 

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{}
 }
 

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)
 

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{}
 }
 

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)
 

mem/database.go

@@ -4,21 +4,21 @@ 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{},
 	}
 }
 
 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
 }
 

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)
 }

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)
 }

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
 		}

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(

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)

sql/core.go

@@ -23,7 +23,7 @@ type Node interface {
 	RowIter() (RowIter, error)
 }
 
-type PhysicalRelation interface {
+type Table interface {
 	Nameable
 	Node
 }

sql/database.go

@@ -2,5 +2,5 @@ package sql
 
 type Database interface {
 	Nameable
-	Relations() map[string]PhysicalRelation
+	Tables() map[string]Table
 }

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)

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"),
 				),
 			),
 		),

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

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
 }

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)
 }