本文整理汇总了Golang中github.com/pingcap/tidb/rset/rsets.Recordset类的典型用法代码示例。如果您正苦于以下问题:Golang Recordset类的具体用法?Golang Recordset怎么用?Golang Recordset使用的例子?那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了Recordset类的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: TestHaving
func (t *testHavingPlan) TestHaving(c *C) {
tblPlan := &testTablePlan{groupByTestData, []string{"id", "name"}, 0}
havingPlan := &plans.HavingPlan{
Src: tblPlan,
Expr: &expression.BinaryOperation{
Op: opcode.GE,
L: &expression.Ident{
CIStr: model.NewCIStr("id"),
},
R: &expression.Value{
Val: 20,
},
},
}
// having's behavior just like where
cnt := 0
rset := rsets.Recordset{
Plan: havingPlan,
Ctx: mock.NewContext(),
}
rset.Do(func(data []interface{}) (bool, error) {
cnt++
return true, nil
})
c.Assert(cnt, Equals, 2)
}
示例2: TestDistinct
func (t *testDistinctSuit) TestDistinct(c *C) {
tblPlan := &testTablePlan{distinctTestData, []string{"id", "name"}, 0}
p := plans.DistinctDefaultPlan{
SelectList: &plans.SelectList{
HiddenFieldOffset: len(tblPlan.GetFields()),
},
Src: tblPlan,
}
rset := rsets.Recordset{
Plan: &p,
}
r := map[int][]interface{}{}
err := rset.Do(func(data []interface{}) (bool, error) {
r[data[0].(int)] = data
return true, nil
})
c.Assert(err, IsNil)
expected := map[int][]interface{}{
10: {10, "hello"},
40: {40, "hello"},
60: {60, "hello"},
}
c.Assert(reflect.DeepEqual(r, expected), Equals, true)
}
示例3: TestOrderBy
func (t *testOrderBySuit) TestOrderBy(c *C) {
tblPlan := &testTablePlan{t.data, []string{"id", "name"}, 0}
pln := &plans.OrderByDefaultPlan{
SelectList: &plans.SelectList{
HiddenFieldOffset: len(tblPlan.GetFields()),
ResultFields: tblPlan.GetFields(),
},
Src: tblPlan,
By: []expression.Expression{
&expression.Ident{
CIStr: model.NewCIStr("id"),
},
},
Ascs: []bool{false},
}
prev := 10000
rset := rsets.Recordset{
Plan: pln,
Ctx: mock.NewContext(),
}
err := rset.Do(func(data []interface{}) (bool, error) {
// DESC
if data[0].(int) > prev {
c.Error("should no be here", data[0], prev)
}
prev = data[0].(int)
return true, nil
})
if err != nil {
log.Error(err)
}
}
示例4: TestWhere
func (t *testWhereSuit) TestWhere(c *C) {
tblPlan := &testTablePlan{t.data, []string{"id", "name"}, 0}
pln := &plans.FilterDefaultPlan{
Plan: tblPlan,
Expr: &expression.BinaryOperation{
Op: opcode.GE,
L: &expression.Ident{
CIStr: model.NewCIStr("id"),
ReferScope: expression.IdentReferFromTable,
ReferIndex: 0,
},
R: expression.Value{
Val: 30,
},
},
}
cnt := 0
rset := rsets.Recordset{Plan: pln,
Ctx: mock.NewContext()}
rset.Do(func(data []interface{}) (bool, error) {
cnt++
return true, nil
})
c.Assert(cnt, Equals, 2)
}
示例5: TestShowCollation
func (p *testShowSuit) TestShowCollation(c *C) {
pln := &plans.ShowPlan{}
pln.Target = stmt.ShowCollation
fls := pln.GetFields()
c.Assert(fls, HasLen, 6)
c.Assert(fls[2].Col.Tp, Equals, mysql.TypeLonglong)
pln.Pattern = &expression.PatternLike{
Pattern: &expression.Value{
Val: "utf8%",
},
}
rset := rsets.Recordset{
Ctx: p.ctx,
Plan: pln,
}
rows, err := rset.Rows(-1, 0)
c.Assert(err, IsNil)
c.Assert(len(rows), Greater, 0)
pln.Close()
pln.Pattern = nil
tblWhere := []struct {
Key string
Value interface{}
}{
{"Collation", "utf8_bin"},
{"Charset", "utf8"},
{"Id", 83},
{"Default", "Yes"},
{"Compiled", "Yes"},
{"Sortlen", 1},
}
for _, w := range tblWhere {
pln.Where = &expression.BinaryOperation{
L: &expression.Ident{CIStr: model.NewCIStr(w.Key)},
R: expression.Value{Val: w.Value},
Op: opcode.EQ,
}
row, err := rset.FirstRow()
c.Assert(err, IsNil)
c.Assert(row, HasLen, 6)
pln.Close()
}
}
示例6: TestUnion
func (t *testUnionSuit) TestUnion(c *C) {
tblPlan := &testTablePlan{t.data, []string{"id", "name"}, 0}
tblPlan2 := &testTablePlan{t.data2, []string{"id", "name"}, 0}
cols := []*column.Col{
{
ColumnInfo: model.ColumnInfo{
ID: 0,
Name: model.NewCIStr("id"),
Offset: 0,
DefaultValue: 0,
FieldType: *types.NewFieldType(mysql.TypeLonglong),
},
},
{
ColumnInfo: model.ColumnInfo{
ID: 1,
Name: model.NewCIStr("name"),
Offset: 1,
DefaultValue: nil,
FieldType: *types.NewFieldType(mysql.TypeVarchar),
},
},
}
// Set Flen explicitly here, because following ColToResultField will change Flen to zero.
// TODO: remove this if ColToResultField update.
cols[1].FieldType.Flen = 100
pln := &plans.UnionPlan{
Srcs: []plan.Plan{
tblPlan,
tblPlan2,
},
Distincts: []bool{true},
RFields: []*field.ResultField{
field.ColToResultField(cols[0], "t"),
field.ColToResultField(cols[1], "t"),
},
}
rset := rsets.Recordset{
Plan: pln,
Ctx: mock.NewContext()}
cnt := 0
rset.Do(func(data []interface{}) (bool, error) {
cnt++
return true, nil
})
c.Assert(cnt, Equals, 6)
}
示例7: TestTableNilPlan
func (p *testIndexSuit) TestTableNilPlan(c *C) {
nilPlan := &plans.TableNilPlan{
T: p.tbl,
}
var ids []int
id := 0
rset := rsets.Recordset{Plan: nilPlan, Ctx: p.ctx}
err := rset.Do(func(data []interface{}) (bool, error) {
id++
ids = append(ids, id)
return true, nil
})
c.Assert(err, IsNil)
c.Assert(ids, DeepEquals, []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
}
示例8: TestSelectExprPlan
func (s *testFieldsSuit) TestSelectExprPlan(c *C) {
pln := &plans.SelectEmptyFieldListPlan{
Fields: []*field.Field{
{
Expr: &expressions.Value{
Val: "data",
},
},
},
}
fields := pln.GetFields()
c.Assert(fields, HasLen, 1)
rset := rsets.Recordset{Plan: pln}
rset.Do(func(data []interface{}) (bool, error) {
return true, nil
})
}
示例9: TestLimit
func (t *testLimitSuit) TestLimit(c *C) {
tblPlan := &testTablePlan{t.data, []string{"id", "name"}, 0}
pln := &plans.LimitDefaultPlan{
Count: 2,
Src: tblPlan,
Fields: []*field.ResultField{},
}
rset := rsets.Recordset{
Ctx: t.sess.(context.Context),
Plan: pln,
}
rset.Do(func(data []interface{}) (bool, error) {
// TODO check result
return true, nil
})
}
示例10: TestTableNilPlan
func (p *testFromSuit) TestTableNilPlan(c *C) {
nilPlan := &plans.TableNilPlan{
T: p.tbl,
}
var ids []int64
rset := rsets.Recordset{
Plan: nilPlan,
Ctx: p,
}
var id int64
rset.Do(func(data []interface{}) (bool, error) {
id++
ids = append(ids, id)
return true, nil
})
c.Assert(reflect.DeepEqual(ids, []int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}), Equals, true)
}
示例11: TestUnion
func (t *testUnionSuit) TestUnion(c *C) {
tblPlan := &testTablePlan{t.data, []string{"id", "name"}, 0}
tblPlan2 := &testTablePlan{t.data2, []string{"id", "name"}, 0}
cols := []*column.Col{
{
ColumnInfo: model.ColumnInfo{
ID: 0,
Name: model.NewCIStr("id"),
Offset: 0,
DefaultValue: 0,
FieldType: *types.NewFieldType(mysql.TypeLonglong),
},
},
{
ColumnInfo: model.ColumnInfo{
ID: 1,
Name: model.NewCIStr("name"),
Offset: 1,
DefaultValue: nil,
FieldType: *types.NewFieldType(mysql.TypeVarchar),
},
},
}
pln := &plans.UnionPlan{
Srcs: []plan.Plan{
tblPlan,
tblPlan2,
},
Distincts: []bool{true},
RFields: []*field.ResultField{
field.ColToResultField(cols[0], "t"),
field.ColToResultField(cols[1], "t"),
},
}
rset := rsets.Recordset{Plan: pln}
cnt := 0
rset.Do(func(data []interface{}) (bool, error) {
cnt++
return true, nil
})
c.Assert(cnt, Equals, 6)
}
示例12: TestRowStackFromPlan
func (s *testOuterQuerySuite) TestRowStackFromPlan(c *C) {
var data = []*testRowData{
{1, []interface{}{10, "hello"}},
}
pln := &testTablePlan{data, []string{"id", "name"}, 0}
p := &plans.RowStackFromPlan{
Src: pln,
}
fields := p.GetFields()
c.Assert(fields, HasLen, 2)
rset := rsets.Recordset{
Plan: p,
Ctx: mock.NewContext()}
_, err := rset.Rows(-1, 0)
c.Assert(err, IsNil)
}
示例13: TestShowVariables
func (p *testShowSuit) TestShowVariables(c *C) {
pln := &plans.ShowPlan{
Target: stmt.ShowVariables,
GlobalScope: true,
Pattern: &expressions.PatternLike{
Pattern: &expressions.Value{
Val: "character_set_results",
},
},
}
fls := pln.GetFields()
c.Assert(fls, HasLen, 2)
c.Assert(fls[0].Name, Equals, "Variable_name")
c.Assert(fls[1].Name, Equals, "Value")
sessionVars := variable.GetSessionVars(p)
ret := map[string]string{}
rset := rsets.Recordset{
Ctx: p,
Plan: pln,
}
rset.Do(func(data []interface{}) (bool, error) {
ret[data[0].(string)] = data[1].(string)
return true, nil
})
c.Assert(ret, HasLen, 1)
v, ok := ret["character_set_results"]
c.Assert(ok, IsTrue)
c.Assert(v, Equals, "latin1")
// Set session variable to utf8
sessionVars.Systems["character_set_results"] = "utf8"
pln.Close()
rset.Do(func(data []interface{}) (bool, error) {
ret[data[0].(string)] = data[1].(string)
return true, nil
})
c.Assert(ret, HasLen, 1)
v, ok = ret["character_set_results"]
c.Assert(ok, IsTrue)
// Show global varibale get latin1
c.Assert(v, Equals, "latin1")
pln.GlobalScope = false
pln.Close()
rset.Do(func(data []interface{}) (bool, error) {
ret[data[0].(string)] = data[1].(string)
return true, nil
})
c.Assert(ret, HasLen, 1)
v, ok = ret["character_set_results"]
c.Assert(ok, IsTrue)
// Show session varibale get utf8
c.Assert(v, Equals, "utf8")
}
示例14: TestShowStatusVariables
func (p *testShowSuit) TestShowStatusVariables(c *C) {
pln := &plans.ShowPlan{
Target: stmt.ShowStatus,
GlobalScope: true,
Pattern: &expression.PatternLike{
Pattern: &expression.Value{
Val: "tc_log_page_size",
},
},
}
fls := pln.GetFields()
c.Assert(fls, HasLen, 2)
c.Assert(fls[0].Name, Equals, "Variable_name")
c.Assert(fls[1].Name, Equals, "Value")
c.Assert(fls[0].Col.Tp, Equals, mysql.TypeVarchar)
c.Assert(fls[1].Col.Tp, Equals, mysql.TypeVarchar)
sessionVars := variable.GetSessionVars(p.ctx)
ret := map[string]string{}
rset := rsets.Recordset{
Ctx: p.ctx,
Plan: pln,
}
rset.Do(func(data []interface{}) (bool, error) {
ret[data[0].(string)] = data[1].(string)
return true, nil
})
c.Assert(ret, HasLen, 1)
v, ok := ret["tc_log_page_size"]
c.Assert(ok, IsTrue)
c.Assert(v, Equals, "0")
pln.Close()
sessionVars.StatusVars["tc_log_page_size"] = "1024"
pln.GlobalScope = false
rset.Do(func(data []interface{}) (bool, error) {
ret[data[0].(string)] = data[1].(string)
return true, nil
})
c.Assert(ret, HasLen, 1)
v, ok = ret["tc_log_page_size"]
c.Assert(ok, IsTrue)
c.Assert(v, Equals, "1024")
pln.Close()
pln.Pattern = &expression.PatternLike{
Pattern: &expression.Value{
Val: "compression",
},
}
sessionVars.StatusVars["compression"] = "on"
pln.GlobalScope = true
ret = map[string]string{}
rset.Do(func(data []interface{}) (bool, error) {
ret[data[0].(string)] = data[1].(string)
return true, nil
})
c.Assert(ret, HasLen, 0)
pln.GlobalScope = false
rset.Do(func(data []interface{}) (bool, error) {
ret[data[0].(string)] = data[1].(string)
return true, nil
})
c.Assert(ret, HasLen, 1)
v, ok = ret["compression"]
c.Assert(ok, IsTrue)
c.Assert(v, Equals, "on")
pln.Close()
pln.Pattern = nil
pln.Where = &expression.BinaryOperation{
L: &expression.Ident{CIStr: model.NewCIStr("Variable_name")},
R: expression.Value{Val: "aborted_clients"},
Op: opcode.EQ,
}
ret = map[string]string{}
sessionVars.StatusVars["aborted_clients"] = "0"
rset.Do(func(data []interface{}) (bool, error) {
ret[data[0].(string)] = data[1].(string)
return true, nil
})
c.Assert(ret, HasLen, 1)
v, ok = ret["aborted_clients"]
c.Assert(ok, IsTrue)
c.Assert(v, Equals, "0")
}
示例15: TestIndexPlan
func (p *testIndexSuit) TestIndexPlan(c *C) {
pln := &plans.TableDefaultPlan{
T: p.tbl,
Fields: []*field.ResultField{
field.ColToResultField(p.tbl.Cols()[0], "t"),
field.ColToResultField(p.tbl.Cols()[1], "t"),
},
}
// expr: id > 0
expr := &expression.BinaryOperation{
Op: opcode.GE,
L: &expression.Ident{
CIStr: model.NewCIStr("id"),
},
R: expression.Value{
Val: 50,
},
}
expr2 := &expression.BinaryOperation{
Op: opcode.LT,
L: &expression.Ident{
CIStr: model.NewCIStr("id"),
},
R: expression.Value{
Val: 100,
},
}
expr3 := &expression.BinaryOperation{
Op: opcode.LE,
L: &expression.Ident{
CIStr: model.NewCIStr("id"),
},
R: expression.Value{
Val: 100,
},
}
expr4 := &expression.BinaryOperation{
Op: opcode.GE,
L: &expression.Ident{
CIStr: model.NewCIStr("id"),
},
R: expression.Value{
Val: 60,
},
}
expr5 := &expression.Ident{
CIStr: model.NewCIStr("id"),
}
np, _, err := pln.Filter(p.ctx, expr)
c.Assert(err, IsNil)
c.Assert(np, NotNil)
np, _, err = np.Filter(p.ctx, expr2)
c.Assert(err, IsNil)
c.Assert(np, NotNil)
np, _, err = np.Filter(p.ctx, expr3)
c.Assert(err, IsNil)
c.Assert(np, NotNil)
np, _, err = np.Filter(p.ctx, expr4)
c.Assert(err, IsNil)
c.Assert(np, NotNil)
np, _, err = np.Filter(p.ctx, expr5)
c.Assert(err, IsNil)
c.Assert(np, NotNil)
ret := map[int64][]byte{}
rset := rsets.Recordset{
Plan: np,
Ctx: p.ctx,
}
rset.Do(func(data []interface{}) (bool, error) {
ret[data[0].(int64)] = data[1].([]byte)
return true, nil
})
excepted := map[int64][]byte{}
for i := 6; i < 10; i++ {
excepted[int64(i*10)] = []byte("hello")
}
expr6 := &expression.UnaryOperation{
Op: '!',
V: &expression.Ident{
CIStr: model.NewCIStr("id"),
},
}
np, _, err = np.Filter(p.ctx, expr6)
c.Assert(err, IsNil)
c.Assert(np, NotNil)
c.Assert(ret, DeepEquals, excepted)
}