sql: rename Field to Column. (#100)

smola · web-flow · commit f2951eee6ad2 · 2017-02-09T18:07:51.000+01:00
A Field would mean a cell in a row, but our previous
Field type is actually a column definition in a schema,
so Column is a more previse name.
diff --git a/git/blobs.go b/git/blobs.go
@@ -25,8 +25,8 @@ func (blobsTable) Name() string {
 
 func (blobsTable) Schema() sql.Schema {
 	return sql.Schema{
-		sql.Field{"hash", sql.String},
-		sql.Field{"size", sql.BigInteger},
+		sql.Column{"hash", sql.String},
+		sql.Column{"size", sql.BigInteger},
 	}
 }
 
diff --git a/git/commits.go b/git/commits.go
@@ -25,14 +25,14 @@ func (commitsTable) Name() string {
 
 func (commitsTable) Schema() sql.Schema {
 	return sql.Schema{
-		sql.Field{"hash", sql.String},
-		sql.Field{"author_name", sql.String},
-		sql.Field{"author_email", sql.String},
-		sql.Field{"author_when", sql.TimestampWithTimezone},
-		sql.Field{"comitter_name", sql.String},
-		sql.Field{"comitter_email", sql.String},
-		sql.Field{"comitter_when", sql.TimestampWithTimezone},
-		sql.Field{"message", sql.String},
+		sql.Column{"hash", sql.String},
+		sql.Column{"author_name", sql.String},
+		sql.Column{"author_email", sql.String},
+		sql.Column{"author_when", sql.TimestampWithTimezone},
+		sql.Column{"comitter_name", sql.String},
+		sql.Column{"comitter_email", sql.String},
+		sql.Column{"comitter_when", sql.TimestampWithTimezone},
+		sql.Column{"message", sql.String},
 	}
 }
 
diff --git a/git/objects.go b/git/objects.go
@@ -25,8 +25,8 @@ func (objectsTable) Name() string {
 
 func (objectsTable) Schema() sql.Schema {
 	return sql.Schema{
-		sql.Field{"id", sql.String},
-		sql.Field{"type", sql.String},
+		sql.Column{"id", sql.String},
+		sql.Column{"type", sql.String},
 	}
 }
 
diff --git a/git/references.go b/git/references.go
@@ -26,13 +26,13 @@ func (referencesTable) Name() string {
 
 func (referencesTable) Schema() sql.Schema {
 	return sql.Schema{
-		sql.Field{"hash", sql.String},
-		sql.Field{"name", sql.String},
-		sql.Field{"is_branch", sql.Boolean},
-		sql.Field{"is_note", sql.Boolean},
-		sql.Field{"is_remote", sql.Boolean},
-		sql.Field{"is_tag", sql.Boolean},
-		sql.Field{"target", sql.String},
+		sql.Column{"hash", sql.String},
+		sql.Column{"name", sql.String},
+		sql.Column{"is_branch", sql.Boolean},
+		sql.Column{"is_note", sql.Boolean},
+		sql.Column{"is_remote", sql.Boolean},
+		sql.Column{"is_tag", sql.Boolean},
+		sql.Column{"target", sql.String},
 	}
 }
 
diff --git a/git/tags.go b/git/tags.go
@@ -25,13 +25,13 @@ func (tagsTable) Name() string {
 
 func (tagsTable) Schema() sql.Schema {
 	return sql.Schema{
-		sql.Field{"hash", sql.String},
-		sql.Field{"name", sql.String},
-		sql.Field{"tagger_email", sql.String},
-		sql.Field{"tagger_name", sql.String},
-		sql.Field{"tagger_when", sql.TimestampWithTimezone},
-		sql.Field{"message", sql.String},
-		sql.Field{"target", sql.String},
+		sql.Column{"hash", sql.String},
+		sql.Column{"name", sql.String},
+		sql.Column{"tagger_email", sql.String},
+		sql.Column{"tagger_name", sql.String},
+		sql.Column{"tagger_when", sql.TimestampWithTimezone},
+		sql.Column{"message", sql.String},
+		sql.Column{"target", sql.String},
 	}
 }
 
diff --git a/git/tree_entries.go b/git/tree_entries.go
@@ -27,10 +27,10 @@ func (treeEntriesTable) Name() string {
 
 func (treeEntriesTable) Schema() sql.Schema {
 	return sql.Schema{
-		sql.Field{"tree_hash", sql.String},
-		sql.Field{"entry_hash", sql.String},
-		sql.Field{"mode", sql.String},
-		sql.Field{"name", sql.String},
+		sql.Column{"tree_hash", sql.String},
+		sql.Column{"entry_hash", sql.String},
+		sql.Column{"mode", sql.String},
+		sql.Column{"name", sql.String},
 	}
 }
 
diff --git a/mem/table_test.go b/mem/table_test.go
@@ -11,7 +11,7 @@ import (
 func TestTable_Name(t *testing.T) {
 	assert := assert.New(t)
 	s := sql.Schema{
-		sql.Field{"col1", sql.String},
+		sql.Column{"col1", sql.String},
 	}
 	table := NewTable("test", s)
 	assert.Equal("test", table.Name())
@@ -20,7 +20,7 @@ func TestTable_Name(t *testing.T) {
 func TestTable_Insert_RowIter(t *testing.T) {
 	assert := assert.New(t)
 	s := sql.Schema{
-		sql.Field{"col1", sql.String},
+		sql.Column{"col1", sql.String},
 	}
 
 	table := NewTable("test", s)
diff --git a/sql/plan/cross_join_test.go b/sql/plan/cross_join_test.go
@@ -11,31 +11,31 @@ import (
 )
 
 var lSchema = sql.Schema{
-	sql.Field{"lcol1", sql.String},
-	sql.Field{"lcol2", sql.String},
-	sql.Field{"lcol3", sql.Integer},
-	sql.Field{"lcol4", sql.BigInteger},
+	sql.Column{"lcol1", sql.String},
+	sql.Column{"lcol2", sql.String},
+	sql.Column{"lcol3", sql.Integer},
+	sql.Column{"lcol4", sql.BigInteger},
 }
 
 var rSchema = sql.Schema{
-	sql.Field{"rcol1", sql.String},
-	sql.Field{"rcol2", sql.String},
-	sql.Field{"rcol3", sql.Integer},
-	sql.Field{"rcol4", sql.BigInteger},
+	sql.Column{"rcol1", sql.String},
+	sql.Column{"rcol2", sql.String},
+	sql.Column{"rcol3", sql.Integer},
+	sql.Column{"rcol4", sql.BigInteger},
 }
 
 func TestCrossJoin(t *testing.T) {
 	assert := assert.New(t)
 
 	resultSchema := sql.Schema{
-		sql.Field{"lcol1", sql.String},
-		sql.Field{"lcol2", sql.String},
-		sql.Field{"lcol3", sql.Integer},
-		sql.Field{"lcol4", sql.BigInteger},
-		sql.Field{"rcol1", sql.String},
-		sql.Field{"rcol2", sql.String},
-		sql.Field{"rcol3", sql.Integer},
-		sql.Field{"rcol4", sql.BigInteger},
+		sql.Column{"lcol1", sql.String},
+		sql.Column{"lcol2", sql.String},
+		sql.Column{"lcol3", sql.Integer},
+		sql.Column{"lcol4", sql.BigInteger},
+		sql.Column{"rcol1", sql.String},
+		sql.Column{"rcol2", sql.String},
+		sql.Column{"rcol3", sql.Integer},
+		sql.Column{"rcol4", sql.BigInteger},
 	}
 
 	ltable := mem.NewTable("left", lSchema)
diff --git a/sql/plan/describe.go b/sql/plan/describe.go
@@ -16,11 +16,11 @@ func NewDescribe(child sql.Node) *Describe {
 
 func (d *Describe) Schema() sql.Schema {
 	return sql.Schema{
-		sql.Field{
+		sql.Column{
 			Name: "name",
 			Type: sql.String,
 		},
-		sql.Field{
+		sql.Column{
 			Name: "type",
 			Type: sql.String,
 		},
diff --git a/sql/plan/describe_test.go b/sql/plan/describe_test.go
@@ -13,8 +13,8 @@ func TestDescribe(t *testing.T) {
 	assert := assert.New(t)
 
 	table := mem.NewTable("test", sql.Schema{
-		sql.Field{Name: "c1", Type: sql.String},
-		sql.Field{Name: "c2", Type: sql.Integer},
+		sql.Column{Name: "c1", Type: sql.String},
+		sql.Column{Name: "c2", Type: sql.Integer},
 	})
 
 	d := NewDescribe(table)
diff --git a/sql/plan/filter_test.go b/sql/plan/filter_test.go
@@ -13,10 +13,10 @@ import (
 func TestFilter(t *testing.T) {
 	assert := assert.New(t)
 	childSchema := sql.Schema{
-		sql.Field{"col1", sql.String},
-		sql.Field{"col2", sql.String},
-		sql.Field{"col3", sql.Integer},
-		sql.Field{"col4", sql.BigInteger},
+		sql.Column{"col1", sql.String},
+		sql.Column{"col2", sql.String},
+		sql.Column{"col3", sql.Integer},
+		sql.Column{"col4", sql.BigInteger},
 	}
 	child := mem.NewTable("test", childSchema)
 	err := child.Insert(sql.NewRow("col1_1", "col2_1", int32(1111), int64(2222)))
diff --git a/sql/plan/group_by.go b/sql/plan/group_by.go
@@ -34,7 +34,7 @@ func (p *GroupBy) Resolved() bool {
 func (p *GroupBy) Schema() sql.Schema {
 	s := sql.Schema{}
 	for _, e := range p.aggregate {
-		s = append(s, sql.Field{
+		s = append(s, sql.Column{
 			Name: e.Name(),
 			Type: e.Type(),
 		})
diff --git a/sql/plan/group_by_test.go b/sql/plan/group_by_test.go
@@ -20,8 +20,8 @@ func TestGroupBy_Schema(t *testing.T) {
 	}
 	gb := NewGroupBy(agg, nil, child)
 	assert.Equal(sql.Schema{
-		sql.Field{Name: "c1", Type: sql.String},
-		sql.Field{Name: "c2", Type: sql.Integer},
+		sql.Column{Name: "c1", Type: sql.String},
+		sql.Column{Name: "c2", Type: sql.Integer},
 	}, gb.Schema())
 }
 
@@ -45,8 +45,8 @@ func TestGroupBy_Resolved(t *testing.T) {
 func TestGroupBy_RowIter(t *testing.T) {
 	assert := assert.New(t)
 	childSchema := sql.Schema{
-		sql.Field{"col1", sql.String},
-		sql.Field{"col2", sql.BigInteger},
+		sql.Column{"col1", sql.String},
+		sql.Column{"col2", sql.BigInteger},
 	}
 	child := mem.NewTable("test", childSchema)
 	child.Insert(sql.NewRow("col1_1", int64(1111)))
diff --git a/sql/plan/limit_test.go b/sql/plan/limit_test.go
@@ -87,7 +87,7 @@ func getTestingTable() (*mem.Table, int) {
 	}
 
 	childSchema := sql.Schema{
-		sql.Field{"col1", sql.String},
+		sql.Column{"col1", sql.String},
 	}
 	testingTable = mem.NewTable("test", childSchema)
 	testingTable.Insert(sql.NewRow("11a"))
diff --git a/sql/plan/project.go b/sql/plan/project.go
@@ -19,7 +19,7 @@ func NewProject(expressions []sql.Expression, child sql.Node) *Project {
 func (p *Project) Schema() sql.Schema {
 	var s sql.Schema
 	for _, e := range p.Expressions {
-		f := sql.Field{
+		f := sql.Column{
 			Name: e.Name(),
 			Type: e.Type(),
 		}
diff --git a/sql/plan/project_test.go b/sql/plan/project_test.go
@@ -14,16 +14,16 @@ import (
 func TestProject(t *testing.T) {
 	require := require.New(t)
 	childSchema := sql.Schema{
-		sql.Field{"col1", sql.String},
-		sql.Field{"col2", sql.String},
+		sql.Column{"col1", sql.String},
+		sql.Column{"col2", sql.String},
 	}
 	child := mem.NewTable("test", childSchema)
 	child.Insert(sql.NewRow("col1_1", "col2_1"))
 	child.Insert(sql.NewRow("col1_2", "col2_2"))
 	p := NewProject([]sql.Expression{expression.NewGetField(1, sql.String, "col2")}, child)
 	require.Equal(1, len(p.Children()))
 	schema := sql.Schema{
-		sql.Field{"col2", sql.String},
+		sql.Column{"col2", sql.String},
 	}
 	require.Equal(schema, p.Schema())
 	iter, err := p.RowIter()
@@ -53,7 +53,7 @@ func TestProject(t *testing.T) {
 		),
 	}, child)
 	schema = sql.Schema{
-		sql.Field{"foo", sql.String},
+		sql.Column{"foo", sql.String},
 	}
 	require.Equal(schema, p.Schema())
 }
diff --git a/sql/plan/sort_test.go b/sql/plan/sort_test.go
@@ -14,8 +14,8 @@ import (
 func TestSort(t *testing.T) {
 	assert := assert.New(t)
 	childSchema := sql.Schema{
-		sql.Field{"col1", sql.String},
-		sql.Field{"col2", sql.Integer},
+		sql.Column{"col1", sql.String},
+		sql.Column{"col2", sql.Integer},
 	}
 
 	child := mem.NewTable("test", childSchema)
@@ -53,7 +53,7 @@ func TestSort(t *testing.T) {
 func TestSort_Ascending(t *testing.T) {
 	assert := assert.New(t)
 	childSchema := sql.Schema{
-		sql.Field{"col1", sql.String},
+		sql.Column{"col1", sql.String},
 	}
 
 	child := mem.NewTable("test", childSchema)
@@ -90,7 +90,7 @@ func TestSort_Ascending(t *testing.T) {
 func TestSort_Descending(t *testing.T) {
 	assert := assert.New(t)
 	childSchema := sql.Schema{
-		sql.Field{"col1", sql.String},
+		sql.Column{"col1", sql.String},
 	}
 
 	child := mem.NewTable("test", childSchema)
diff --git a/sql/plan/transform_test.go b/sql/plan/transform_test.go
@@ -19,8 +19,8 @@ func TestTransformUp(t *testing.T) {
 	p := NewProject([]sql.Expression{aCol, bCol}, NewFilter(expression.NewEquals(aCol, bCol), ur))
 
 	schema := sql.Schema{
-		sql.Field{"a", sql.String},
-		sql.Field{"b", sql.String},
+		sql.Column{"a", sql.String},
+		sql.Column{"b", sql.String},
 	}
 	table := mem.NewTable("resolved", schema)
 
diff --git a/sql/type.go b/sql/type.go
@@ -8,7 +8,7 @@ import (
 	"time"
 )
 
-type Schema []Field
+type Schema []Column
 
 func (s Schema) CheckRow(row Row) error {
 	expected := len(s)
@@ -32,7 +32,7 @@ func (s Schema) CheckRow(row Row) error {
 	return nil
 }
 
-type Field struct {
+type Column struct {
 	Name string
 	Type Type
 }

Original file line number	Diff line number	Diff line change
`@@ -25,8 +25,8 @@ func (blobsTable) Name() string {`
`25`	`25`
`26`	`26`	`func (blobsTable) Schema() sql.Schema {`
`27`	`27`	`return sql.Schema{`
`28`		`- sql.Field{"hash", sql.String},`
`29`		`- sql.Field{"size", sql.BigInteger},`
	`28`	`+ sql.Column{"hash", sql.String},`
	`29`	`+ sql.Column{"size", sql.BigInteger},`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
Original file line number	Diff line number	Diff line change
`@@ -25,8 +25,8 @@ func (objectsTable) Name() string {`
`25`	`25`
`26`	`26`	`func (objectsTable) Schema() sql.Schema {`
`27`	`27`	`return sql.Schema{`
`28`		`- sql.Field{"id", sql.String},`
`29`		`- sql.Field{"type", sql.String},`
	`28`	`+ sql.Column{"id", sql.String},`
	`29`	`+ sql.Column{"type", sql.String},`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
Original file line number	Diff line number	Diff line change
`@@ -27,10 +27,10 @@ func (treeEntriesTable) Name() string {`
`27`	`27`
`28`	`28`	`func (treeEntriesTable) Schema() sql.Schema {`
`29`	`29`	`return sql.Schema{`
`30`		`- sql.Field{"tree_hash", sql.String},`
`31`		`- sql.Field{"entry_hash", sql.String},`
`32`		`- sql.Field{"mode", sql.String},`
`33`		`- sql.Field{"name", sql.String},`
	`30`	`+ sql.Column{"tree_hash", sql.String},`
	`31`	`+ sql.Column{"entry_hash", sql.String},`
	`32`	`+ sql.Column{"mode", sql.String},`
	`33`	`+ sql.Column{"name", sql.String},`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`