Skip to content

Commit c15d2d7

Browse files
smolasmola
authored
rename *relation to *table. (src-d#55)
PhysicalRelation is now Table, this is shorter, readable and more understandeable for most people.
1 parent 8e63ad1 commit c15d2d7

13 files changed

+56
-56
lines changed

‎mem/database.go

+3-3
Original file line numberDiff line numberDiff line change
@@ -4,21 +4,21 @@ import "github.com/gitql/gitql/sql"
44

55
type Database struct {
66
name string
7-
tables map[string]sql.PhysicalRelation
7+
tables map[string]sql.Table
88
}
99

1010
func NewDatabase(name string) *Database {
1111
return &Database{
1212
name: name,
13-
tables: map[string]sql.PhysicalRelation{},
13+
tables: map[string]sql.Table{},
1414
}
1515
}
1616

1717
func (d *Database) Name() string {
1818
return d.name
1919
}
2020

21-
func (d *Database) Relations() map[string]sql.PhysicalRelation {
21+
func (d *Database) Tables() map[string]sql.Table {
2222
return d.tables
2323
}
2424

‎mem/database_test.go

+6-6
Original file line numberDiff line numberDiff line change
@@ -17,13 +17,13 @@ func TestDatabase_Name(t *testing.T) {
1717
func TestDatabase_AddTable(t *testing.T) {
1818
assert := assert.New(t)
1919
db := NewDatabase("test")
20-
relations := db.Relations()
21-
assert.Equal(0, len(relations))
20+
tables := db.Tables()
21+
assert.Equal(0, len(tables))
2222
table := &Table{"test_table", sql.Schema{}, nil}
2323
db.AddTable("test_table", table)
24-
relations = db.Relations()
25-
assert.Equal(1, len(relations))
26-
rel, ok := relations["test_table"]
24+
tables = db.Tables()
25+
assert.Equal(1, len(tables))
26+
tt, ok := tables["test_table"]
2727
assert.True(ok)
28-
assert.NotNil(rel)
28+
assert.NotNil(tt)
2929
}

‎sql/analyzer/analyzer_test.go

+7-7
Original file line numberDiff line numberDiff line change
@@ -24,12 +24,12 @@ func TestAnalyzer_Analyze(t *testing.T) {
2424
a := analyzer.New(catalog)
2525
a.CurrentDatabase = "mydb"
2626

27-
var notAnalyzed sql.Node = plan.NewUnresolvedRelation("mytable")
27+
var notAnalyzed sql.Node = plan.NewUnresolvedTable("mytable")
2828
analyzed, err := a.Analyze(notAnalyzed)
2929
assert.Nil(err)
3030
assert.Equal(table, analyzed)
3131

32-
notAnalyzed = plan.NewUnresolvedRelation("nonexistant")
32+
notAnalyzed = plan.NewUnresolvedTable("nonexistant")
3333
analyzed, err = a.Analyze(notAnalyzed)
3434
assert.NotNil(err)
3535
assert.Equal(notAnalyzed, analyzed)
@@ -40,7 +40,7 @@ func TestAnalyzer_Analyze(t *testing.T) {
4040

4141
notAnalyzed = plan.NewProject(
4242
[]sql.Expression{expression.NewUnresolvedColumn("i")},
43-
plan.NewUnresolvedRelation("mytable"),
43+
plan.NewUnresolvedTable("mytable"),
4444
)
4545
analyzed, err = a.Analyze(notAnalyzed)
4646
expected := plan.NewProject(
@@ -57,7 +57,7 @@ func TestAnalyzer_Analyze(t *testing.T) {
5757
expression.NewUnresolvedColumn("i"),
5858
expression.NewLiteral(int32(1), sql.Integer),
5959
),
60-
plan.NewUnresolvedRelation("mytable"),
60+
plan.NewUnresolvedTable("mytable"),
6161
),
6262
)
6363
analyzed, err = a.Analyze(notAnalyzed)
@@ -87,12 +87,12 @@ func TestAnalyzer_Analyze_MaxIterations(t *testing.T) {
8787
"infinite",
8888
func(a *analyzer.Analyzer, n sql.Node) sql.Node {
8989
i += 1
90-
return plan.NewUnresolvedRelation(fmt.Sprintf("rel%d", i))
90+
return plan.NewUnresolvedTable(fmt.Sprintf("table%d", i))
9191
},
9292
}}
9393

94-
notAnalyzed := plan.NewUnresolvedRelation("mytable")
94+
notAnalyzed := plan.NewUnresolvedTable("mytable")
9595
analyzed, err := a.Analyze(notAnalyzed)
9696
assert.NotNil(err)
97-
assert.Equal(plan.NewUnresolvedRelation("rel1001"), analyzed)
97+
assert.Equal(plan.NewUnresolvedTable("table1001"), analyzed)
9898
}

‎sql/analyzer/rules.go

+1-1
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ var DefaultRules = []Rule{
1313

1414
func resolveTables(a *Analyzer, n sql.Node) sql.Node {
1515
return n.TransformUp(func(n sql.Node) sql.Node {
16-
t, ok := n.(*plan.UnresolvedRelation)
16+
t, ok := n.(*plan.UnresolvedTable)
1717
if !ok {
1818
return n
1919
}

‎sql/analyzer/rules_test.go

+3-3
Original file line numberDiff line numberDiff line change
@@ -27,11 +27,11 @@ func Test_resolveTables(t *testing.T) {
2727
a.Rules = []analyzer.Rule{f}
2828

2929
a.CurrentDatabase = "mydb"
30-
var notAnalyzed sql.Node = plan.NewUnresolvedRelation("mytable")
30+
var notAnalyzed sql.Node = plan.NewUnresolvedTable("mytable")
3131
analyzed := f.Apply(a, notAnalyzed)
3232
assert.Equal(table, analyzed)
3333

34-
notAnalyzed = plan.NewUnresolvedRelation("nonexistant")
34+
notAnalyzed = plan.NewUnresolvedTable("nonexistant")
3535
analyzed = f.Apply(a, notAnalyzed)
3636
assert.Equal(notAnalyzed, analyzed)
3737

@@ -57,7 +57,7 @@ func Test_resolveTables_Nested(t *testing.T) {
5757

5858
notAnalyzed := plan.NewProject(
5959
[]sql.Expression{expression.NewGetField(0, sql.Integer, "i")},
60-
plan.NewUnresolvedRelation("mytable"),
60+
plan.NewUnresolvedTable("mytable"),
6161
)
6262
analyzed := f.Apply(a, notAnalyzed)
6363
expected := plan.NewProject(

‎sql/catalog.go

+2-2
Original file line numberDiff line numberDiff line change
@@ -18,13 +18,13 @@ func (c Catalog) Database(name string) (Database, error) {
1818
return nil, fmt.Errorf("database not found: %s", name)
1919
}
2020

21-
func (c Catalog) Table(dbName string, tableName string) (PhysicalRelation, error) {
21+
func (c Catalog) Table(dbName string, tableName string) (Table, error) {
2222
db, err := c.Database(dbName)
2323
if err != nil {
2424
return nil, err
2525
}
2626

27-
tables := db.Relations()
27+
tables := db.Tables()
2828
table, found := tables[tableName]
2929
if !found {
3030
return nil, fmt.Errorf("table not found: %s", tableName)

‎sql/core.go

+1-1
Original file line numberDiff line numberDiff line change
@@ -23,7 +23,7 @@ type Node interface {
2323
RowIter() (RowIter, error)
2424
}
2525

26-
type PhysicalRelation interface {
26+
type Table interface {
2727
Nameable
2828
Node
2929
}

‎sql/database.go

+1-1
Original file line numberDiff line numberDiff line change
@@ -2,5 +2,5 @@ package sql
22

33
type Database interface {
44
Nameable
5-
Relations() map[string]PhysicalRelation
5+
Tables() map[string]Table
66
}

‎sql/parse/parse.go

+8-8
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ const (
2020
SelectState
2121
SelectFieldList
2222
FromState
23-
FromRelationState
23+
FromTableState
2424
WhereState
2525
WhereClauseState
2626
OrderState
@@ -43,7 +43,7 @@ type parser struct {
4343
err error
4444

4545
projection []sql.Expression
46-
relation string
46+
table string
4747
filterClauses []sql.Expression
4848
sortFields []plan.SortField
4949
limit *int
@@ -166,17 +166,17 @@ func (p *parser) parse() error {
166166
p.errorf("expecting 'FROM', %q received", t.Value)
167167
} else {
168168
p.stateStack.pop()
169-
p.stateStack.put(FromRelationState)
169+
p.stateStack.put(FromTableState)
170170
}
171171

172-
case FromRelationState:
172+
case FromTableState:
173173
t = p.lexer.Next()
174174
if t == nil || t.Type == EOFToken {
175175
p.errorf("expecting table name, nothing received")
176176
} else if t.Type != IdentifierToken {
177177
p.errorf("expecting table name, %q received instead", t.Value)
178178
} else {
179-
p.relation = t.Value
179+
p.table = t.Value
180180
p.stateStack.pop()
181181
p.stateStack.put(WhereState)
182182
}
@@ -272,11 +272,11 @@ func (p *parser) parse() error {
272272
}
273273

274274
func (p *parser) buildPlan() (sql.Node, error) {
275-
if p.relation == "" {
276-
return nil, errors.New("missing relation name")
275+
if p.table == "" {
276+
return nil, errors.New("missing table name")
277277
}
278278

279-
var node sql.Node = plan.NewUnresolvedRelation(p.relation)
279+
var node sql.Node = plan.NewUnresolvedTable(p.table)
280280

281281
if len(p.filterClauses) > 0 {
282282
node = plan.NewFilter(p.filterClauses[0], node)

‎sql/parse/parse_test.go

+8-8
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@ var fixtures = map[string]sql.Node{
1717
expression.NewUnresolvedColumn("foo"),
1818
expression.NewUnresolvedColumn("bar"),
1919
},
20-
plan.NewUnresolvedRelation("foo"),
20+
plan.NewUnresolvedTable("foo"),
2121
),
2222
`SELECT foo, bar FROM foo WHERE foo = bar;`: plan.NewProject(
2323
[]sql.Expression{
@@ -29,7 +29,7 @@ var fixtures = map[string]sql.Node{
2929
expression.NewUnresolvedColumn("foo"),
3030
expression.NewUnresolvedColumn("bar"),
3131
),
32-
plan.NewUnresolvedRelation("foo"),
32+
plan.NewUnresolvedTable("foo"),
3333
),
3434
),
3535
`SELECT foo, bar FROM foo WHERE foo = 'bar';`: plan.NewProject(
@@ -42,7 +42,7 @@ var fixtures = map[string]sql.Node{
4242
expression.NewUnresolvedColumn("foo"),
4343
expression.NewLiteral("bar", sql.String),
4444
),
45-
plan.NewUnresolvedRelation("foo"),
45+
plan.NewUnresolvedTable("foo"),
4646
),
4747
),
4848
`SELECT foo, bar FROM foo LIMIT 10;`: plan.NewProject(
@@ -51,7 +51,7 @@ var fixtures = map[string]sql.Node{
5151
expression.NewUnresolvedColumn("bar"),
5252
},
5353
plan.NewLimit(int64(10),
54-
plan.NewUnresolvedRelation("foo"),
54+
plan.NewUnresolvedTable("foo"),
5555
),
5656
),
5757
`SELECT foo, bar FROM foo ORDER BY baz DESC;`: plan.NewProject(
@@ -61,7 +61,7 @@ var fixtures = map[string]sql.Node{
6161
},
6262
plan.NewSort(
6363
[]plan.SortField{{expression.NewUnresolvedColumn("baz"), plan.Descending}},
64-
plan.NewUnresolvedRelation("foo"),
64+
plan.NewUnresolvedTable("foo"),
6565
),
6666
),
6767
`SELECT foo, bar FROM foo WHERE foo = bar LIMIT 10;`: plan.NewProject(
@@ -75,7 +75,7 @@ var fixtures = map[string]sql.Node{
7575
expression.NewUnresolvedColumn("foo"),
7676
expression.NewUnresolvedColumn("bar"),
7777
),
78-
plan.NewUnresolvedRelation("foo"),
78+
plan.NewUnresolvedTable("foo"),
7979
),
8080
),
8181
),
@@ -87,7 +87,7 @@ var fixtures = map[string]sql.Node{
8787
plan.NewLimit(int64(1),
8888
plan.NewSort(
8989
[]plan.SortField{{expression.NewUnresolvedColumn("baz"), plan.Descending}},
90-
plan.NewUnresolvedRelation("foo"),
90+
plan.NewUnresolvedTable("foo"),
9191
),
9292
),
9393
),
@@ -104,7 +104,7 @@ var fixtures = map[string]sql.Node{
104104
expression.NewUnresolvedColumn("qux"),
105105
expression.NewLiteral(int64(1), sql.BigInteger),
106106
),
107-
plan.NewUnresolvedRelation("foo"),
107+
plan.NewUnresolvedTable("foo"),
108108
),
109109
),
110110
),

‎sql/plan/transform_test.go

+2-2
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ func TestTransformUp(t *testing.T) {
1515

1616
aCol := expression.NewUnresolvedColumn("a")
1717
bCol := expression.NewUnresolvedColumn("a")
18-
ur := &UnresolvedRelation{"unresolved"}
18+
ur := &UnresolvedTable{"unresolved"}
1919
p := NewProject([]sql.Expression{aCol, bCol}, NewFilter(expression.NewEquals(aCol, bCol), ur))
2020

2121
schema := sql.Schema{
@@ -26,7 +26,7 @@ func TestTransformUp(t *testing.T) {
2626

2727
pt := p.TransformUp(func(n sql.Node) sql.Node {
2828
switch n.(type) {
29-
case *UnresolvedRelation:
29+
case *UnresolvedTable:
3030
return table
3131
default:
3232
return n

‎sql/plan/unresolved.go

+11-11
Original file line numberDiff line numberDiff line change
@@ -6,34 +6,34 @@ import (
66
"github.com/gitql/gitql/sql"
77
)
88

9-
type UnresolvedRelation struct {
9+
type UnresolvedTable struct {
1010
Name string
1111
}
1212

13-
func NewUnresolvedRelation(name string) *UnresolvedRelation {
14-
return &UnresolvedRelation{name}
13+
func NewUnresolvedTable(name string) *UnresolvedTable {
14+
return &UnresolvedTable{name}
1515
}
1616

17-
func (*UnresolvedRelation) Resolved() bool {
17+
func (*UnresolvedTable) Resolved() bool {
1818
return false
1919
}
2020

21-
func (*UnresolvedRelation) Children() []sql.Node {
21+
func (*UnresolvedTable) Children() []sql.Node {
2222
return []sql.Node{}
2323
}
2424

25-
func (*UnresolvedRelation) Schema() sql.Schema {
25+
func (*UnresolvedTable) Schema() sql.Schema {
2626
return sql.Schema{}
2727
}
2828

29-
func (*UnresolvedRelation) RowIter() (sql.RowIter, error) {
30-
return nil, fmt.Errorf("unresolved relation")
29+
func (*UnresolvedTable) RowIter() (sql.RowIter, error) {
30+
return nil, fmt.Errorf("unresolved table")
3131
}
3232

33-
func (p *UnresolvedRelation) TransformUp(f func(sql.Node) sql.Node) sql.Node {
34-
return f(NewUnresolvedRelation(p.Name))
33+
func (p *UnresolvedTable) TransformUp(f func(sql.Node) sql.Node) sql.Node {
34+
return f(NewUnresolvedTable(p.Name))
3535
}
3636

37-
func (p *UnresolvedRelation) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node {
37+
func (p *UnresolvedTable) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node {
3838
return p
3939
}

‎sql/plan/unresolved_test.go

+3-3
Original file line numberDiff line numberDiff line change
@@ -8,8 +8,8 @@ import (
88
"github.com/stretchr/testify/assert"
99
)
1010

11-
func TestUnresolvedRelation(t *testing.T) {
11+
func TestUnresolvedTable(t *testing.T) {
1212
assert := assert.New(t)
13-
var r sql.Node = NewUnresolvedRelation("test_table")
14-
assert.NotNil(r)
13+
var n sql.Node = NewUnresolvedTable("test_table")
14+
assert.NotNil(n)
1515
}

0 commit comments

Comments
 (0)