diff --git a/cmd/gitql/query.go b/cmd/gitql/query.go index 7e78ffd76..a55e74a2d 100644 --- a/cmd/gitql/query.go +++ b/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 } } diff --git a/engine.go b/engine.go index 388e3564f..f6aaebb38 100644 --- a/engine.go +++ b/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 { diff --git a/engine_test.go b/engine_test.go index be0a03a81..71390abe7 100644 --- a/engine_test.go +++ b/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) diff --git a/git/blobs.go b/git/blobs.go index 8b3d54b93..319475ebc 100644 --- a/git/blobs.go +++ b/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, ) diff --git a/git/commits.go b/git/commits.go index 72aa33e5b..cd10a16cb 100644 --- a/git/commits.go +++ b/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, diff --git a/git/objects.go b/git/objects.go index f723c809c..ae31a7696 100644 --- a/git/objects.go +++ b/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(), ) diff --git a/git/references.go b/git/references.go index 2b1bfbea9..173ce9ed2 100644 --- a/git/references.go +++ b/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(), diff --git a/git/tags.go b/git/tags.go index 720b1c4ef..5d253c2ff 100644 --- a/git/tags.go +++ b/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, diff --git a/git/tree_entries.go b/git/tree_entries.go index 6ba813f5e..10e0be8cc 100644 --- a/git/tree_entries.go +++ b/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), diff --git a/internal/format/json_test.go b/internal/format/json_test.go index 70689a8af..7e69d738d 100644 --- a/internal/format/json_test.go +++ b/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) -} \ No newline at end of file +} diff --git a/mem/table.go b/mem/table.go index 77bdbaa75..24e6d8f08 100644 --- a/mem/table.go +++ b/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 } diff --git a/mem/table_test.go b/mem/table_test.go index 2fb9a6c0c..bfd834e47 100644 --- a/mem/table_test.go +++ b/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) diff --git a/sql/expression/aggregation.go b/sql/expression/aggregation.go index 1e45e5b89..cc3c7d4b6 100644 --- a/sql/expression/aggregation.go +++ b/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] } diff --git a/sql/expression/aggregation_test.go b/sql/expression/aggregation_test.go index ff79becda..f8fcafb3b 100644 --- a/sql/expression/aggregation_test.go +++ b/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)) } diff --git a/sql/expression/comparison_test.go b/sql/expression/comparison_test.go index 30910db1c..63d90ce2c 100644 --- a/sql/expression/comparison_test.go +++ b/sql/expression/comparison_test.go @@ -57,7 +57,7 @@ func TestComparisons_Equals(t *testing.T) { assert.Equal(sql.Boolean, eq.Type()) for cmpResult, cases := range cmpCase { for _, pair := range cases { - row := sql.NewMemoryRow(pair[0], pair[1]) + row := sql.NewRow(pair[0], pair[1]) assert.NotNil(row) cmp := eq.Eval(row) assert.NotNil(cmp) @@ -83,7 +83,7 @@ func TestComparisons_LessThan(t *testing.T) { assert.Equal(sql.Boolean, eq.Type()) for cmpResult, cases := range cmpCase { for _, pair := range cases { - row := sql.NewMemoryRow(pair[0], pair[1]) + row := sql.NewRow(pair[0], pair[1]) assert.NotNil(row) cmp := eq.Eval(row) assert.NotNil(cmp) @@ -109,7 +109,7 @@ func TestComparisons_GreaterThan(t *testing.T) { assert.Equal(sql.Boolean, eq.Type()) for cmpResult, cases := range cmpCase { for _, pair := range cases { - row := sql.NewMemoryRow(pair[0], pair[1]) + row := sql.NewRow(pair[0], pair[1]) assert.NotNil(row) cmp := eq.Eval(row) assert.NotNil(cmp) diff --git a/sql/expression/get_field.go b/sql/expression/get_field.go index 4637f6704..5988e376f 100644 --- a/sql/expression/get_field.go +++ b/sql/expression/get_field.go @@ -25,7 +25,7 @@ func (p GetField) Type() sql.Type { } func (p GetField) Eval(row sql.Row) interface{} { - return row.Fields()[p.fieldIndex] + return row[p.fieldIndex] } func (p GetField) Name() string { diff --git a/sql/plan/cross_join.go b/sql/plan/cross_join.go index 9cb6463a5..77093518f 100644 --- a/sql/plan/cross_join.go +++ b/sql/plan/cross_join.go @@ -91,14 +91,14 @@ func (i *crossJoinIterator) Next() (sql.Row, error) { i.leftRow = lr } - fields := append(i.leftRow.Fields(), i.rightRows[i.index].Fields()...) + row := append(i.leftRow, i.rightRows[i.index]...) i.index++ if i.index >= len(i.rightRows) { i.index = 0 i.leftRow = nil } - return sql.NewMemoryRow(fields...), nil + return row, nil } func (i *crossJoinIterator) fillRows() error { diff --git a/sql/plan/cross_join_test.go b/sql/plan/cross_join_test.go index ff08cd059..7dac2a00e 100644 --- a/sql/plan/cross_join_test.go +++ b/sql/plan/cross_join_test.go @@ -55,29 +55,29 @@ func TestCrossJoin(t *testing.T) { assert.Nil(err) assert.NotNil(row) - assert.Equal(8, len(row.Fields())) + assert.Equal(8, len(row)) - assert.Equal("col1_1", row.Fields()[0]) - assert.Equal("col2_1", row.Fields()[1]) - assert.Equal(int32(1111), row.Fields()[2]) - assert.Equal(int64(2222), row.Fields()[3]) - assert.Equal("col1_1", row.Fields()[4]) - assert.Equal("col2_1", row.Fields()[5]) - assert.Equal(int32(1111), row.Fields()[6]) - assert.Equal(int64(2222), row.Fields()[7]) + assert.Equal("col1_1", row[0]) + assert.Equal("col2_1", row[1]) + assert.Equal(int32(1111), row[2]) + assert.Equal(int64(2222), row[3]) + assert.Equal("col1_1", row[4]) + assert.Equal("col2_1", row[5]) + assert.Equal(int32(1111), row[6]) + assert.Equal(int64(2222), row[7]) row, err = iter.Next() assert.Nil(err) assert.NotNil(row) - assert.Equal("col1_1", row.Fields()[0]) - assert.Equal("col2_1", row.Fields()[1]) - assert.Equal(int32(1111), row.Fields()[2]) - assert.Equal(int64(2222), row.Fields()[3]) - assert.Equal("col1_2", row.Fields()[4]) - assert.Equal("col2_2", row.Fields()[5]) - assert.Equal(int32(3333), row.Fields()[6]) - assert.Equal(int64(4444), row.Fields()[7]) + assert.Equal("col1_1", row[0]) + assert.Equal("col2_1", row[1]) + assert.Equal(int32(1111), row[2]) + assert.Equal(int64(2222), row[3]) + assert.Equal("col1_2", row[4]) + assert.Equal("col2_2", row[5]) + assert.Equal(int32(3333), row[6]) + assert.Equal(int64(4444), row[7]) for i := 0; i < 2; i++ { row, err = iter.Next() @@ -125,8 +125,8 @@ func TestCrossJoin_Empty(t *testing.T) { } func insertData(assert *assert.Assertions, table *mem.Table) { - err := table.Insert("col1_1", "col2_1", int32(1111), int64(2222)) + err := table.Insert(sql.NewRow("col1_1", "col2_1", int32(1111), int64(2222))) assert.Nil(err) - err = table.Insert("col1_2", "col2_2", int32(3333), int64(4444)) + err = table.Insert(sql.NewRow("col1_2", "col2_2", int32(3333), int64(4444))) assert.Nil(err) } diff --git a/sql/plan/describe.go b/sql/plan/describe.go index fb86dacba..f330e2fd5 100644 --- a/sql/plan/describe.go +++ b/sql/plan/describe.go @@ -57,5 +57,5 @@ func (i *describeIter) Next() (sql.Row, error) { f := i.schema[i.i] i.i++ - return sql.NewMemoryRow(f.Name, f.Type.Name()), nil + return sql.NewRow(f.Name, f.Type.Name()), nil } diff --git a/sql/plan/describe_test.go b/sql/plan/describe_test.go index 3d0910d2a..dbc7826fa 100644 --- a/sql/plan/describe_test.go +++ b/sql/plan/describe_test.go @@ -24,11 +24,11 @@ func TestDescribe(t *testing.T) { n, err := iter.Next() assert.Nil(err) - assert.Equal(sql.NewMemoryRow("c1", "string"), n) + assert.Equal(sql.NewRow("c1", "string"), n) n, err = iter.Next() assert.Nil(err) - assert.Equal(sql.NewMemoryRow("c2", "integer"), n) + assert.Equal(sql.NewRow("c2", "integer"), n) n, err = iter.Next() assert.Equal(io.EOF, err) diff --git a/sql/plan/filter_test.go b/sql/plan/filter_test.go index 217f615a6..08e122244 100644 --- a/sql/plan/filter_test.go +++ b/sql/plan/filter_test.go @@ -19,9 +19,9 @@ func TestFilter(t *testing.T) { sql.Field{"col4", sql.BigInteger}, } child := mem.NewTable("test", childSchema) - err := child.Insert("col1_1", "col2_1", int32(1111), int64(2222)) + err := child.Insert(sql.NewRow("col1_1", "col2_1", int32(1111), int64(2222))) assert.Nil(err) - err = child.Insert("col1_2", "col2_2", int32(3333), int64(4444)) + err = child.Insert(sql.NewRow("col1_2", "col2_2", int32(3333), int64(4444))) assert.Nil(err) f := NewFilter( @@ -40,8 +40,8 @@ func TestFilter(t *testing.T) { assert.Nil(err) assert.NotNil(row) - assert.Equal("col1_1", row.Fields()[0]) - assert.Equal("col2_1", row.Fields()[1]) + assert.Equal("col1_1", row[0]) + assert.Equal("col2_1", row[1]) row, err = iter.Next() assert.NotNil(err) @@ -60,8 +60,8 @@ func TestFilter(t *testing.T) { assert.Nil(err) assert.NotNil(row) - assert.Equal(int32(1111), row.Fields()[2]) - assert.Equal(int64(2222), row.Fields()[3]) + assert.Equal(int32(1111), row[2]) + assert.Equal(int64(2222), row[3]) f = NewFilter(expression.NewEquals( expression.NewGetField(3, sql.BigInteger, "col4"), @@ -76,6 +76,6 @@ func TestFilter(t *testing.T) { assert.Nil(err) assert.NotNil(row) - assert.Equal(int32(3333), row.Fields()[2]) - assert.Equal(int64(4444), row.Fields()[3]) + assert.Equal(int32(3333), row[2]) + assert.Equal(int64(4444), row[3]) } diff --git a/sql/plan/group_by.go b/sql/plan/group_by.go index 8419c56bf..36b0c9af8 100644 --- a/sql/plan/group_by.go +++ b/sql/plan/group_by.go @@ -172,7 +172,7 @@ func aggregate(exprs []sql.Expression, rows []sql.Row) sql.Row { fields = append(fields, agg.Eval(buffers[i])) } - return sql.NewMemoryRow(fields...) + return sql.NewRow(fields...) } func exprsToAggregateExprs(exprs []sql.Expression) []sql.AggregationExpression { diff --git a/sql/plan/group_by_test.go b/sql/plan/group_by_test.go index 5c1d893d4..fe712035d 100644 --- a/sql/plan/group_by_test.go +++ b/sql/plan/group_by_test.go @@ -49,11 +49,11 @@ func TestGroupBy_RowIter(t *testing.T) { sql.Field{"col2", sql.BigInteger}, } child := mem.NewTable("test", childSchema) - child.Insert("col1_1", int64(1111)) - child.Insert("col1_1", int64(1111)) - child.Insert("col1_2", int64(4444)) - child.Insert("col1_1", int64(1111)) - child.Insert("col1_2", int64(4444)) + child.Insert(sql.NewRow("col1_1", int64(1111))) + child.Insert(sql.NewRow("col1_1", int64(1111))) + child.Insert(sql.NewRow("col1_2", int64(4444))) + child.Insert(sql.NewRow("col1_1", int64(1111))) + child.Insert(sql.NewRow("col1_2", int64(4444))) p := NewSort( []SortField{ @@ -83,6 +83,6 @@ func TestGroupBy_RowIter(t *testing.T) { assert.NoError(err) assert.Len(rows, 2) - assert.Equal(sql.NewMemoryRow("col1_1", int64(1111)), rows[0]) - assert.Equal(sql.NewMemoryRow("col1_2", int64(4444)), rows[1]) + assert.Equal(sql.NewRow("col1_1", int64(1111)), rows[0]) + assert.Equal(sql.NewRow("col1_2", int64(4444)), rows[1]) } diff --git a/sql/plan/limit_test.go b/sql/plan/limit_test.go index ee837776c..db0ffec14 100644 --- a/sql/plan/limit_test.go +++ b/sql/plan/limit_test.go @@ -90,9 +90,9 @@ func getTestingTable() (*mem.Table, int) { sql.Field{"col1", sql.String}, } testingTable = mem.NewTable("test", childSchema) - testingTable.Insert("11a") - testingTable.Insert("22a") - testingTable.Insert("33a") + testingTable.Insert(sql.NewRow("11a")) + testingTable.Insert(sql.NewRow("22a")) + testingTable.Insert(sql.NewRow("33a")) testingTableSize = 3 return testingTable, testingTableSize diff --git a/sql/plan/project.go b/sql/plan/project.go index 60561abed..04db92fe5 100644 --- a/sql/plan/project.go +++ b/sql/plan/project.go @@ -74,5 +74,5 @@ func filterRow(expressions []sql.Expression, row sql.Row) sql.Row { for _, expr := range expressions { fields = append(fields, expr.Eval(row)) } - return sql.NewMemoryRow(fields...) + return sql.NewRow(fields...) } diff --git a/sql/plan/project_test.go b/sql/plan/project_test.go index 6b76d3fee..cc4c69386 100644 --- a/sql/plan/project_test.go +++ b/sql/plan/project_test.go @@ -18,8 +18,8 @@ func TestProject(t *testing.T) { sql.Field{"col2", sql.String}, } child := mem.NewTable("test", childSchema) - child.Insert("col1_1", "col2_1") - child.Insert("col1_2", "col2_2") + 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{ @@ -32,15 +32,13 @@ func TestProject(t *testing.T) { row, err := iter.Next() require.Nil(err) require.NotNil(row) - fields := row.Fields() - require.Equal(1, len(fields)) - require.Equal("col2_1", fields[0]) + require.Equal(1, len(row)) + require.Equal("col2_1", row[0]) row, err = iter.Next() require.Nil(err) require.NotNil(row) - fields = row.Fields() - require.Equal(1, len(fields)) - require.Equal("col2_2", fields[0]) + require.Equal(1, len(row)) + require.Equal("col2_2", row[0]) row, err = iter.Next() require.Equal(io.EOF, err) require.Nil(row) diff --git a/sql/plan/show_tables.go b/sql/plan/show_tables.go index 9737c67f7..3a1d9c78d 100644 --- a/sql/plan/show_tables.go +++ b/sql/plan/show_tables.go @@ -60,7 +60,7 @@ func (i *showTablesIter) Next() (sql.Row, error) { if i.idx >= len(i.tableNames) { return nil, io.EOF } - row := sql.NewMemoryRow(i.tableNames[i.idx]) + row := sql.NewRow(i.tableNames[i.idx]) i.idx++ return row, nil diff --git a/sql/plan/show_tables_test.go b/sql/plan/show_tables_test.go index 81eb1220d..52ca00f6c 100644 --- a/sql/plan/show_tables_test.go +++ b/sql/plan/show_tables_test.go @@ -31,15 +31,15 @@ func TestShowTables(t *testing.T) { res, err := iter.Next() assert.Nil(err) - assert.Equal("test1", res.Fields()[0]) + assert.Equal("test1", res[0]) res, err = iter.Next() assert.Nil(err) - assert.Equal("test2", res.Fields()[0]) + assert.Equal("test2", res[0]) res, err = iter.Next() assert.Nil(err) - assert.Equal("test3", res.Fields()[0]) + assert.Equal("test3", res[0]) _, err = iter.Next() assert.Equal(io.EOF, err) diff --git a/sql/plan/sort_test.go b/sql/plan/sort_test.go index 2f91fcfd5..02e0ccade 100644 --- a/sql/plan/sort_test.go +++ b/sql/plan/sort_test.go @@ -19,9 +19,9 @@ func TestSort(t *testing.T) { } child := mem.NewTable("test", childSchema) - child.Insert("a", int32(3)) - child.Insert("b", int32(3)) - child.Insert("c", int32(1)) + child.Insert(sql.NewRow("a", int32(3))) + child.Insert(sql.NewRow("b", int32(3))) + child.Insert(sql.NewRow("c", int32(1))) sf := []SortField{ {Column: expression.NewGetField(1, sql.Integer, "col2"), Order: Ascending}, @@ -36,15 +36,15 @@ func TestSort(t *testing.T) { row, err := iter.Next() assert.Nil(err) assert.NotNil(row) - assert.Equal("c", row.Fields()[0]) + assert.Equal("c", row[0]) row, err = iter.Next() assert.Nil(err) assert.NotNil(row) - assert.Equal("b", row.Fields()[0]) + assert.Equal("b", row[0]) row, err = iter.Next() assert.Nil(err) assert.NotNil(row) - assert.Equal("a", row.Fields()[0]) + assert.Equal("a", row[0]) row, err = iter.Next() assert.Equal(io.EOF, err) assert.Nil(row) @@ -57,9 +57,9 @@ func TestSort_Ascending(t *testing.T) { } child := mem.NewTable("test", childSchema) - child.Insert("b") - child.Insert("c") - child.Insert("a") + child.Insert(sql.NewRow("b")) + child.Insert(sql.NewRow("c")) + child.Insert(sql.NewRow("a")) sf := []SortField{ {Column: expression.NewGetField(0, sql.String, "col1"), Order: Ascending}, @@ -73,15 +73,15 @@ func TestSort_Ascending(t *testing.T) { row, err := iter.Next() assert.Nil(err) assert.NotNil(row) - assert.Equal("a", row.Fields()[0]) + assert.Equal("a", row[0]) row, err = iter.Next() assert.Nil(err) assert.NotNil(row) - assert.Equal("b", row.Fields()[0]) + assert.Equal("b", row[0]) row, err = iter.Next() assert.Nil(err) assert.NotNil(row) - assert.Equal("c", row.Fields()[0]) + assert.Equal("c", row[0]) row, err = iter.Next() assert.Equal(io.EOF, err) assert.Nil(row) @@ -94,9 +94,9 @@ func TestSort_Descending(t *testing.T) { } child := mem.NewTable("test", childSchema) - child.Insert("a") - child.Insert("c") - child.Insert("b") + child.Insert(sql.NewRow("a")) + child.Insert(sql.NewRow("c")) + child.Insert(sql.NewRow("b")) sf := []SortField{ {Column: expression.NewGetField(0, sql.String, "col1"), Order: Descending}, @@ -110,15 +110,15 @@ func TestSort_Descending(t *testing.T) { row, err := iter.Next() assert.Nil(err) assert.NotNil(row) - assert.Equal("c", row.Fields()[0]) + assert.Equal("c", row[0]) row, err = iter.Next() assert.Nil(err) assert.NotNil(row) - assert.Equal("b", row.Fields()[0]) + assert.Equal("b", row[0]) row, err = iter.Next() assert.Nil(err) assert.NotNil(row) - assert.Equal("a", row.Fields()[0]) + assert.Equal("a", row[0]) row, err = iter.Next() assert.Equal(io.EOF, err) assert.Nil(row) diff --git a/sql/row.go b/sql/row.go index 8629040c9..bd413c8d2 100644 --- a/sql/row.go +++ b/sql/row.go @@ -1,23 +1,30 @@ package sql -import "io" +import ( + "io" +) -type Row interface { - Fields() []interface{} -} +type Row []Value -type RowIter interface { - Next() (Row, error) -} +func NewRow(values ...interface{}) Row { + row := make([]Value, len(values)) + for i := 0; i < len(values); i++ { + row[i] = Value(values[i]) + } -type MemoryRow []interface{} + return row +} -func NewMemoryRow(fields ...interface{}) MemoryRow { - return MemoryRow(fields) +func (r Row) Copy() Row { + crow := make([]Value, len(r)) + copy(crow, r) + return r } -func (r MemoryRow) Fields() []interface{} { - return []interface{}(r) +type Value interface{} + +type RowIter interface { + Next() (Row, error) } func RowIterToRows(i RowIter) ([]Row, error) { diff --git a/sql/type.go b/sql/type.go index ba7df9526..e59d89d95 100644 --- a/sql/type.go +++ b/sql/type.go @@ -11,15 +11,14 @@ import ( type Schema []Field func (s Schema) CheckRow(row Row) error { - fields := row.Fields() expected := len(s) - got := len(fields) + got := len(row) if expected != got { return fmt.Errorf("expected %d values, got %d", expected, got) } for idx, f := range s { - v := fields[idx] + v := row[idx] if f.Type.Check(v) { continue }