sql: make Row a concrete implementation.

cmd/gitql/query.go

@@ -114,7 +114,12 @@ func (c *CmdQuery) printQuery(schema sql.Schema, iter sql.RowIter) error {
 			return err
 		}
 
-		if err := f.Write(row.Fields()); err != nil {
+		record := make([]interface{}, len(row))
+		for i := 0; i < len(row); i++ {
+			record[i] = row[i]
+		}
+
+		if err := f.Write(record); err != nil {
 			return err
 		}
 	}

engine.go

@@ -3,8 +3,8 @@ package gitql
 import (
 	"github.com/gitql/gitql/sql"
 	"github.com/gitql/gitql/sql/analyzer"
-	"github.com/gitql/gitql/sql/parse"
 	"github.com/gitql/gitql/sql/expression"
+	"github.com/gitql/gitql/sql/parse"
 )
 
 type Engine struct {

engine_test.go

@@ -16,46 +16,46 @@ func TestEngine_Query(t *testing.T) {
 	testQuery(t, e,
 		"SELECT i FROM mytable;",
 		[]sql.Row{
-			sql.NewMemoryRow(int64(1)),
-			sql.NewMemoryRow(int64(2)),
-			sql.NewMemoryRow(int64(3)),
+			sql.NewRow(int64(1)),
+			sql.NewRow(int64(2)),
+			sql.NewRow(int64(3)),
 		},
 	)
 
 	testQuery(t, e,
 		"SELECT i FROM mytable WHERE i = 2;",
 		[]sql.Row{
-			sql.NewMemoryRow(int64(2)),
+			sql.NewRow(int64(2)),
 		},
 	)
 
 	testQuery(t, e,
 		"SELECT i FROM mytable ORDER BY i DESC;",
 		[]sql.Row{
-			sql.NewMemoryRow(int64(3)),
-			sql.NewMemoryRow(int64(2)),
-			sql.NewMemoryRow(int64(1)),
+			sql.NewRow(int64(3)),
+			sql.NewRow(int64(2)),
+			sql.NewRow(int64(1)),
 		},
 	)
 
 	testQuery(t, e,
 		"SELECT i FROM mytable WHERE s = 'a' ORDER BY i DESC;",
 		[]sql.Row{
-			sql.NewMemoryRow(int64(1)),
+			sql.NewRow(int64(1)),
 		},
 	)
 
 	testQuery(t, e,
 		"SELECT i FROM mytable WHERE s = 'a' ORDER BY i DESC LIMIT 1;",
 		[]sql.Row{
-			sql.NewMemoryRow(int64(1)),
+			sql.NewRow(int64(1)),
 		},
 	)
 
 	testQuery(t, e,
 		"SELECT COUNT(*) FROM mytable;",
 		[]sql.Row{
-			sql.NewMemoryRow(int32(3)),
+			sql.NewRow(int32(3)),
 		},
 	)
 }
@@ -91,9 +91,9 @@ func newEngine(t *testing.T) *gitql.Engine {
 		{"i", sql.BigInteger},
 		{"s", sql.String},
 	})
-	assert.Nil(table.Insert(int64(1), "a"))
-	assert.Nil(table.Insert(int64(2), "b"))
-	assert.Nil(table.Insert(int64(3), "c"))
+	assert.Nil(table.Insert(sql.NewRow(int64(1), "a")))
+	assert.Nil(table.Insert(sql.NewRow(int64(2), "b")))
+	assert.Nil(table.Insert(sql.NewRow(int64(3), "c")))
 
 	db := mem.NewDatabase("mydb")
 	db.AddTable("mytable", table)

git/blobs.go

@@ -65,7 +65,7 @@ func (i *blobIter) Next() (sql.Row, error) {
 }
 
 func blobToRow(c *object.Blob) sql.Row {
-	return sql.NewMemoryRow(
+	return sql.NewRow(
 		c.Hash.String(),
 		c.Size,
 	)

git/commits.go

@@ -70,7 +70,7 @@ func (i *commitIter) Next() (sql.Row, error) {
 }
 
 func commitToRow(c *object.Commit) sql.Row {
-	return sql.NewMemoryRow(
+	return sql.NewRow(
 		c.Hash.String(),
 		c.Author.Name,
 		c.Author.Email,

git/objects.go

@@ -65,7 +65,7 @@ func (i *objectIter) Next() (sql.Row, error) {
 }
 
 func objectToRow(o object.Object) sql.Row {
-	return sql.NewMemoryRow(
+	return sql.NewRow(
 		o.ID().String(),
 		o.Type().String(),
 	)

git/references.go

@@ -71,7 +71,7 @@ func (i *referenceIter) Next() (sql.Row, error) {
 }
 
 func referenceToRow(c *plumbing.Reference) sql.Row {
-	return sql.NewMemoryRow(
+	return sql.NewRow(
 		c.Hash().String(),
 		c.Name().String(),
 		c.IsBranch(),

git/tags.go

@@ -70,7 +70,7 @@ func (i *tagIter) Next() (sql.Row, error) {
 }
 
 func tagToRow(c *object.Tag) sql.Row {
-	return sql.NewMemoryRow(
+	return sql.NewRow(
 		c.Hash.String(),
 		c.Name,
 		c.Tagger.Email,

git/tree_entries.go

@@ -86,7 +86,7 @@ func (i *treeEntryIter) Next() (sql.Row, error) {
 }
 
 func treeEntryToRow(t *object.Tree, e object.TreeEntry) sql.Row {
-	return sql.NewMemoryRow(
+	return sql.NewRow(
 		t.ID().String(),
 		e.Hash.String(),
 		strconv.FormatInt(int64(e.Mode), 8),

internal/format/json_test.go

@@ -19,7 +19,6 @@ func TestNewJsonFormat(t *testing.T) {
 	}, w, t)
 }
 
-
 func TestNewFormat_Json(t *testing.T) {
 	testNewFormat("json", t)
-}
+}

mem/table.go

@@ -10,14 +10,13 @@ import (
 type Table struct {
 	name   string
 	schema sql.Schema
-	data   [][]interface{}
+	data   []sql.Row
 }
 
 func NewTable(name string, schema sql.Schema) *Table {
 	return &Table{
 		name:   name,
 		schema: schema,
-		data:   [][]interface{}{},
 	}
 }
 
@@ -38,7 +37,7 @@ func (t *Table) Children() []sql.Node {
 }
 
 func (t *Table) RowIter() (sql.RowIter, error) {
-	return &iter{data: t.data}, nil
+	return &iter{rows: t.data}, nil
 }
 
 func (t *Table) TransformUp(f func(sql.Node) sql.Node) sql.Node {
@@ -49,30 +48,33 @@ func (t *Table) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sq
 	return t
 }
 
-func (t *Table) Insert(values ...interface{}) error {
-	if len(values) != len(t.schema) {
-		return fmt.Errorf("insert expected %d values, got %d", len(t.schema), len(values))
+func (t *Table) Insert(row sql.Row) error {
+	if len(row) != len(t.schema) {
+		return fmt.Errorf("insert expected %d values, got %d", len(t.schema), len(row))
 	}
-	for idx, value := range values {
+
+	for idx, value := range row {
 		f := t.schema[idx]
 		if !f.Type.Check(value) {
 			return sql.ErrInvalidType
 		}
 	}
-	t.data = append(t.data, values)
+
+	t.data = append(t.data, row.Copy())
 	return nil
 }
 
 type iter struct {
 	idx  int
-	data [][]interface{}
+	rows []sql.Row
 }
 
 func (i *iter) Next() (sql.Row, error) {
-	if i.idx >= len(i.data) {
+	if i.idx >= len(i.rows) {
 		return nil, io.EOF
 	}
-	row := sql.NewMemoryRow(i.data[i.idx]...)
+
+	row := i.rows[i.idx]
 	i.idx++
-	return row, nil
+	return row.Copy(), nil
 }

mem/table_test.go

@@ -29,13 +29,13 @@ func TestTable_Insert_RowIter(t *testing.T) {
 	assert.Nil(err)
 	assert.Len(rows, 0)
 
-	err = table.Insert("foo")
+	err = table.Insert(sql.NewRow("foo"))
 	rows, err = sql.NodeToRows(table)
 	assert.Nil(err)
 	assert.Len(rows, 1)
 	assert.Nil(s.CheckRow(rows[0]))
 
-	err = table.Insert("bar")
+	err = table.Insert(sql.NewRow("bar"))
 	rows, err = sql.NodeToRows(table)
 	assert.Nil(err)
 	assert.Len(rows, 2)

sql/expression/aggregation.go

@@ -15,7 +15,7 @@ func NewCount(e sql.Expression) *Count {
 }
 
 func (c *Count) NewBuffer() sql.Row {
-	return sql.NewMemoryRow(int32(0))
+	return sql.NewRow(int32(0))
 }
 
 func (c *Count) Type() sql.Type {
@@ -40,7 +40,6 @@ func (c *Count) TransformUp(f func(sql.Expression) sql.Expression) sql.Expressio
 }
 
 func (c *Count) Update(buffer, row sql.Row) {
-	mr := buffer.(sql.MemoryRow)
 	var inc bool
 	if _, ok := c.Child.(*Star); ok {
 		inc = true
@@ -52,17 +51,16 @@ func (c *Count) Update(buffer, row sql.Row) {
 	}
 
 	if inc {
-		mr[0] = getInt32At(buffer, 0) + int32(1)
+		buffer[0] = buffer[0].(int32) + int32(1)
 	}
 }
 
 func (c *Count) Merge(buffer, partial sql.Row) {
-	mb := buffer.(sql.MemoryRow)
-	mb[0] = getInt32At(buffer, 0) + getInt32At(partial, 0)
+	buffer[0] = buffer[0].(int32) + partial[0].(int32)
 }
 
 func (c *Count) Eval(buffer sql.Row) interface{} {
-	return getInt32At(buffer, 0)
+	return buffer[0]
 }
 
 type First struct {
@@ -74,7 +72,7 @@ func NewFirst(e sql.Expression) *First {
 }
 
 func (e *First) NewBuffer() sql.Row {
-	return sql.NewMemoryRow(nil)
+	return sql.NewRow(nil)
 }
 
 func (e *First) Type() sql.Type {
@@ -91,25 +89,17 @@ func (e *First) TransformUp(f func(sql.Expression) sql.Expression) sql.Expressio
 }
 
 func (e *First) Update(buffer, row sql.Row) {
-	mr := buffer.(sql.MemoryRow)
-	if mr[0] == nil {
-		mr[0] = e.Child.Eval(row)
+	if buffer[0] == nil {
+		buffer[0] = e.Child.Eval(row)
 	}
 }
 
 func (e *First) Merge(buffer, partial sql.Row) {
-	mb := buffer.(sql.MemoryRow)
-	if mb[0] == nil {
-		mp := partial.(sql.MemoryRow)
-		mb[0] = mp[0]
+	if buffer[0] == nil {
+		buffer[0] = partial[0]
 	}
 }
 
 func (e *First) Eval(buffer sql.Row) interface{} {
-	return buffer.Fields()[0]
-}
-
-func getInt32At(row sql.Row, i int) int32 {
-	f := row.Fields()
-	return f[i].(int32)
+	return buffer[0]
 }

sql/expression/aggregation_test.go

@@ -22,15 +22,15 @@ func TestCount_Eval_1(t *testing.T) {
 	b := c.NewBuffer()
 	assert.Equal(int32(0), c.Eval(b))
 
-	c.Update(b, sql.NewMemoryRow())
-	c.Update(b, sql.NewMemoryRow("foo"))
-	c.Update(b, sql.NewMemoryRow(1))
-	c.Update(b, sql.NewMemoryRow(1, 2, 3))
+	c.Update(b, nil)
+	c.Update(b, sql.NewRow("foo"))
+	c.Update(b, sql.NewRow(1))
+	c.Update(b, sql.NewRow(1, 2, 3))
 	assert.Equal(int32(4), c.Eval(b))
 
 	b2 := c.NewBuffer()
-	c.Update(b2, sql.NewMemoryRow())
-	c.Update(b2, sql.NewMemoryRow("foo"))
+	c.Update(b2, nil)
+	c.Update(b2, sql.NewRow("foo"))
 	c.Merge(b, b2)
 	assert.Equal(int32(6), c.Eval(b))
 }
@@ -42,15 +42,15 @@ func TestCount_Eval_Star(t *testing.T) {
 	b := c.NewBuffer()
 	assert.Equal(int32(0), c.Eval(b))
 
-	c.Update(b, sql.NewMemoryRow())
-	c.Update(b, sql.NewMemoryRow("foo"))
-	c.Update(b, sql.NewMemoryRow(1))
-	c.Update(b, sql.NewMemoryRow(1, 2, 3))
+	c.Update(b, nil)
+	c.Update(b, sql.NewRow("foo"))
+	c.Update(b, sql.NewRow(1))
+	c.Update(b, sql.NewRow(1, 2, 3))
 	assert.Equal(int32(4), c.Eval(b))
 
 	b2 := c.NewBuffer()
-	c.Update(b2, sql.NewMemoryRow())
-	c.Update(b2, sql.NewMemoryRow("foo"))
+	c.Update(b2, sql.NewRow())
+	c.Update(b2, sql.NewRow("foo"))
 	c.Merge(b, b2)
 	assert.Equal(int32(6), c.Eval(b))
 }
@@ -62,10 +62,10 @@ func TestCount_Eval_String(t *testing.T) {
 	b := c.NewBuffer()
 	assert.Equal(int32(0), c.Eval(b))
 
-	c.Update(b, sql.NewMemoryRow("foo"))
+	c.Update(b, sql.NewRow("foo"))
 	assert.Equal(int32(1), c.Eval(b))
 
-	c.Update(b, sql.NewMemoryRow(nil))
+	c.Update(b, sql.NewRow(nil))
 	assert.Equal(int32(1), c.Eval(b))
 }
 
@@ -83,14 +83,14 @@ func TestFirst_Eval(t *testing.T) {
 	b := c.NewBuffer()
 	assert.Nil(c.Eval(b))
 
-	c.Update(b, sql.NewMemoryRow(int32(1)))
+	c.Update(b, sql.NewRow(int32(1)))
 	assert.Equal(int32(1), c.Eval(b))
 
-	c.Update(b, sql.NewMemoryRow(int32(2)))
+	c.Update(b, sql.NewRow(int32(2)))
 	assert.Equal(int32(1), c.Eval(b))
 
 	b2 := c.NewBuffer()
-	c.Update(b2, sql.NewMemoryRow(int32(2)))
+	c.Update(b2, sql.NewRow(int32(2)))
 	c.Merge(b, b2)
 	assert.Equal(int32(1), c.Eval(b))
 }