func TestRead(t *testing.T) {
assert := assert.New(t)
ds := datas.NewDataStore(chunks.NewMemoryStore())
dataString := `a,1,true
b,2,false
`
r := NewCSVReader(bytes.NewBufferString(dataString), ',')
headers := []string{"A", "B", "C"}
kinds := KindSlice{types.StringKind, types.Int8Kind, types.BoolKind}
l, typeRef, typeDef := Read(r, "test", headers, kinds, ds)
assert.Equal(uint64(2), l.Len())
assert.True(typeRef.IsUnresolved())
desc, ok := typeDef.Desc.(types.StructDesc)
assert.True(ok)
assert.Len(desc.Fields, 3)
assert.Equal("A", desc.Fields[0].Name)
assert.Equal("B", desc.Fields[1].Name)
assert.Equal("C", desc.Fields[2].Name)
assert.True(l.Get(0).(types.Struct).Get("A").Equals(types.NewString("a")))
assert.True(l.Get(1).(types.Struct).Get("A").Equals(types.NewString("b")))
assert.True(l.Get(0).(types.Struct).Get("B").Equals(types.Int8(1)))
assert.True(l.Get(1).(types.Struct).Get("B").Equals(types.Int8(2)))
assert.True(l.Get(0).(types.Struct).Get("C").Equals(types.Bool(true)))
assert.True(l.Get(1).(types.Struct).Get("C").Equals(types.Bool(false)))
}
// StringToType takes a piece of data as a string and attempts to convert it to a types.Value of the appropriate types.NomsKind.
func StringToType(s string, k types.NomsKind) types.Value {
switch k {
case types.Uint8Kind:
ival, err := strconv.ParseUint(s, 10, 8)
d.Chk.NoError(err)
return types.Uint8(ival)
case types.Uint16Kind:
ival, err := strconv.ParseUint(s, 10, 16)
d.Chk.NoError(err)
return types.Uint16(ival)
case types.Uint32Kind:
ival, err := strconv.ParseUint(s, 10, 32)
d.Chk.NoError(err)
return types.Uint32(ival)
case types.Uint64Kind:
ival, err := strconv.ParseUint(s, 10, 64)
d.Chk.NoError(err)
return types.Uint64(ival)
case types.Int8Kind:
ival, err := strconv.ParseInt(s, 10, 8)
d.Chk.NoError(err)
return types.Int8(ival)
case types.Int16Kind:
ival, err := strconv.ParseInt(s, 10, 16)
d.Chk.NoError(err)
return types.Int16(ival)
case types.Int32Kind:
ival, err := strconv.ParseInt(s, 10, 32)
d.Chk.NoError(err)
return types.Int32(ival)
case types.Int64Kind:
ival, err := strconv.ParseInt(s, 10, 64)
d.Chk.NoError(err)
return types.Int64(ival)
case types.Float32Kind:
fval, err := strconv.ParseFloat(s, 32)
d.Chk.NoError(err)
return types.Float32(fval)
case types.Float64Kind:
fval, err := strconv.ParseFloat(s, 64)
d.Chk.NoError(err)
return types.Float64(fval)
case types.BoolKind:
bval, err := strconv.ParseBool(s)
d.Chk.NoError(err)
return types.Bool(bval)
case types.StringKind:
return types.NewString(s)
default:
d.Exp.Fail("Invalid column type kind:", k)
}
panic("not reached")
}
func (s StructPrimitives) ChildValues() (ret []types.Value) {
ret = append(ret, types.Uint64(s._uint64))
ret = append(ret, types.Uint32(s._uint32))
ret = append(ret, types.Uint16(s._uint16))
ret = append(ret, types.Uint8(s._uint8))
ret = append(ret, types.Int64(s._int64))
ret = append(ret, types.Int32(s._int32))
ret = append(ret, types.Int16(s._int16))
ret = append(ret, types.Int8(s._int8))
ret = append(ret, types.Float64(s._float64))
ret = append(ret, types.Float32(s._float32))
ret = append(ret, types.Bool(s._bool))
ret = append(ret, types.NewString(s._string))
ret = append(ret, s._blob)
ret = append(ret, s._value)
return
}
func readerForStructPrimitives(v types.Value) []types.Value {
values := []types.Value{}
s := v.(StructPrimitives)
values = append(values, types.Uint64(s._uint64))
values = append(values, types.Uint32(s._uint32))
values = append(values, types.Uint16(s._uint16))
values = append(values, types.Uint8(s._uint8))
values = append(values, types.Int64(s._int64))
values = append(values, types.Int32(s._int32))
values = append(values, types.Int16(s._int16))
values = append(values, types.Int8(s._int8))
values = append(values, types.Float64(s._float64))
values = append(values, types.Float32(s._float32))
values = append(values, types.Bool(s._bool))
values = append(values, types.NewString(s._string))
values = append(values, s._blob)
values = append(values, s._value)
return values
}