func TestValues(t *testing.T) {
p := planner{}
vInt := int64(5)
vNum := 3.14159
vStr := "two furs one cub"
vBool := true
unsupp := &parser.RangeCond{}
asRow := func(datums ...parser.Datum) []parser.DTuple {
return []parser.DTuple{datums}
}
testCases := []struct {
stmt parser.Values
rows []parser.DTuple
ok bool
}{
{
parser.Values{{parser.IntVal(vInt)}},
asRow(parser.DInt(vInt)),
true,
},
{
parser.Values{{parser.IntVal(vInt), parser.IntVal(vInt)}},
asRow(parser.DInt(vInt), parser.DInt(vInt)),
true,
},
{
parser.Values{{parser.NumVal(fmt.Sprintf("%0.5f", vNum))}},
asRow(parser.DFloat(vNum)),
true,
},
{
parser.Values{{parser.StrVal(vStr)}},
asRow(parser.DString(vStr)),
true,
},
{
parser.Values{{parser.BytesVal(vStr)}},
asRow(parser.DString(vStr)),
true,
},
{
parser.Values{{parser.BoolVal(vBool)}},
asRow(parser.DBool(vBool)),
true,
},
{
parser.Values{{unsupp}},
nil,
false,
},
}
for i, tc := range testCases {
plan, err := p.Values(tc.stmt)
if err == nil != tc.ok {
t.Errorf("%d: error_expected=%t, but got error %v", i, tc.ok, err)
}
if plan != nil {
var rows []parser.DTuple
for plan.Next() {
rows = append(rows, plan.Values())
}
if !reflect.DeepEqual(rows, tc.rows) {
t.Errorf("%d: expected rows:\n%+v\nactual rows:\n%+v", i, tc.rows, rows)
}
}
}
}
func TestValues(t *testing.T) {
defer leaktest.AfterTest(t)
p := planner{}
vInt := int64(5)
vNum := 3.14159
vStr := "two furs one cub"
vBool := true
unsupp := &parser.RangeCond{}
intVal := func(v int64) *parser.IntVal {
return &parser.IntVal{Val: v}
}
asRow := func(datums ...parser.Datum) []parser.DTuple {
return []parser.DTuple{datums}
}
testCases := []struct {
stmt parser.Values
rows []parser.DTuple
ok bool
}{
{
parser.Values{{intVal(vInt)}},
asRow(parser.DInt(vInt)),
true,
},
{
parser.Values{{intVal(vInt), intVal(vInt)}},
asRow(parser.DInt(vInt), parser.DInt(vInt)),
true,
},
{
parser.Values{{parser.NumVal(fmt.Sprintf("%0.5f", vNum))}},
asRow(parser.DFloat(vNum)),
true,
},
{
parser.Values{{parser.DString(vStr)}},
asRow(parser.DString(vStr)),
true,
},
{
parser.Values{{parser.DBytes(vStr)}},
asRow(parser.DBytes(vStr)),
true,
},
{
parser.Values{{parser.DBool(vBool)}},
asRow(parser.DBool(vBool)),
true,
},
{
parser.Values{{unsupp}},
nil,
false,
},
}
for i, tc := range testCases {
plan, pErr := func() (_ planNode, pErr *roachpb.Error) {
defer func() {
if r := recover(); r != nil {
pErr = roachpb.NewErrorf("%v", r)
}
}()
return p.Values(tc.stmt)
}()
if pErr == nil != tc.ok {
t.Errorf("%d: error_expected=%t, but got error %v", i, tc.ok, pErr)
}
if plan != nil {
var rows []parser.DTuple
for plan.Next() {
rows = append(rows, plan.Values())
}
if !reflect.DeepEqual(rows, tc.rows) {
t.Errorf("%d: expected rows:\n%+v\nactual rows:\n%+v", i, tc.rows, rows)
}
}
}
}
func TestProcessSelect(t *testing.T) {
s := (*Server)(nil) // enough for now
vInt := int64(5)
vNum := "3.14159"
vStr := "two furs one cub"
vBool := true
dInt := driver.Datum{IntVal: &vInt}
dFloat := func() driver.Datum {
tmp, err := strconv.ParseFloat(vNum, 64)
if err != nil {
panic(err)
}
return driver.Datum{FloatVal: &tmp}
}()
dStr := driver.Datum{StringVal: &vStr}
dBool := driver.Datum{BoolVal: &vBool}
unsupp := &parser.RangeCond{}
asRow := func(datums ...driver.Datum) []driver.Result_Row {
return []driver.Result_Row{
{Values: datums},
}
}
testCases := []struct {
stmt parser.SelectStatement
rows []driver.Result_Row
ok bool
}{
{
parser.Values{{parser.IntVal(vInt)}},
asRow(dInt),
true,
},
{
parser.Values{{parser.IntVal(vInt), parser.IntVal(vInt)}},
asRow(dInt, dInt),
true,
},
{
parser.Values{{parser.NumVal(vNum)}},
asRow(dFloat),
true,
},
{
parser.Values{{parser.StrVal(vStr)}},
asRow(dStr),
true,
},
{
parser.Values{{parser.BytesVal(vStr)}},
asRow(dStr), // string, not bytes, returned!
true,
},
{
parser.Values{{parser.BoolVal(vBool)}},
asRow(dBool),
true,
},
{
parser.Values{{unsupp}},
nil,
false,
},
}
for i, tc := range testCases {
rows, err := s.processSelect(tc.stmt)
if err == nil != tc.ok {
t.Errorf("%d: error_expected=%t, but got error %v", i, tc.ok, err)
}
if !reflect.DeepEqual(rows, tc.rows) {
t.Errorf("%d: expected rows:\n%+v\nactual rows:\n%+v", i, tc.rows, rows)
}
}
}