//
// readEmbeddedMap handles the EMBEDDEDMAP type. Currently, OrientDB only uses string
// types for the map keys, so that is an assumption of this method as well.
//
// TODO: change return type to (*oschema.OEmbeddedMap, error) { ???
func (serde ORecordSerializerV0) readEmbeddedMap(buf *obuf.ReadBuf) (map[string]interface{}, error) {
numRecs, err := varint.ReadVarIntAndDecode32(buf)
if err != nil {
return nil, oerror.NewTrace(err)
}
nrecs := int(numRecs)
m := make(map[string]interface{}) // final map to be returned
// data structures for reading the map header section, which gives key names and
// value types (and value ptrs, but I don't need those for the way I parse the data)
keynames := make([]string, nrecs)
valtypes := make([]oschema.ODataType, nrecs)
// read map headers
for i := 0; i < nrecs; i++ {
keytype, err := rw.ReadByte(buf)
if err != nil {
return nil, oerror.NewTrace(err)
}
if keytype != byte(oschema.STRING) {
panic(fmt.Sprintf("ReadEmbeddedMap got a key datatype %v - but it should be 7 (string)", keytype))
}
keynames[i], err = varint.ReadString(buf)
if err != nil {
return nil, oerror.NewTrace(err)
}
_, err = rw.ReadInt(buf) // pointer - throwing away
if err != nil {
return nil, oerror.NewTrace(err)
}
b, err := rw.ReadByte(buf)
if err != nil {
return nil, oerror.NewTrace(err)
}
valtypes[i] = oschema.ODataType(b)
}
// read map values
for i := 0; i < nrecs; i++ {
val, err := serde.readDataValue(buf, valtypes[i])
if err != nil {
return nil, oerror.NewTrace(err)
}
m[keynames[i]] = val
}
return m, nil
}
//
// readEmbeddedCollection handles both EMBEDDEDLIST and EMBEDDEDSET types.
// Java client API:
// Collection<?> readEmbeddedCollection(BytesContainer bytes, Collection<Object> found, ODocument document) {
// `found`` gets added to during the recursive iterations
//
func (serde ORecordSerializerV0) readEmbeddedCollection(buf *obuf.ReadBuf) ([]interface{}, error) {
nrecs, err := varint.ReadVarIntAndDecode32(buf)
if err != nil {
return nil, oerror.NewTrace(err)
}
datatype, err := rw.ReadByte(buf)
if err != nil {
return nil, oerror.NewTrace(err)
}
if datatype != byte(oschema.ANY) { // OrientDB server always returns ANY
// NOTE: currently the Java client doesn't handle this case either, so safe for now
panic(fmt.Sprintf("ReadEmbeddedList got a datatype %v - currently that datatype is not supported", datatype))
}
ary := make([]interface{}, int(nrecs))
// loop over all recs
for i := range ary {
// if type is ANY (unknown), then the next byte specifies the type of record to follow
b, err := rw.ReadByte(buf)
if err != nil {
return nil, oerror.NewTrace(err)
}
itemtype := oschema.ODataType(b)
if itemtype == oschema.ANY {
ary[i] = nil // this is what the Java client does
continue
}
val, err := serde.readDataValue(buf, itemtype)
if err != nil {
return nil, oerror.NewTrace(err)
}
ary[i] = val
}
return ary, nil
}
func readHeader(buf io.Reader) (header, error) {
hdr := header{
properties: make([]headerProperty, 0, 8),
dataPtrs: make([]int32, 0, 8),
}
for {
decoded, err := varint.ReadVarIntAndDecode32(buf)
if err != nil {
_, _, line, _ := runtime.Caller(0)
return header{}, fmt.Errorf("Error in binserde.readHeader (line %d): %v", line-2, err)
}
if decoded == 0 { // 0 marks end of header
break
} else if decoded > 0 {
// have a property, not a document, so the number is a zigzag encoded length
// for a string (property name)
// read property name
data := make([]byte, int(decoded))
n, err := buf.Read(data)
if err != nil {
return header{}, oerror.NewTrace(err)
}
if len(data) != n {
return header{}, oerror.IncorrectNetworkRead{Expected: len(data), Actual: n}
}
// hdr.propertyNames = append(hdr.propertyNames, string(data))
// read data pointer
ptr, err := rw.ReadInt(buf)
if err != nil {
return header{}, oerror.NewTrace(err)
}
// read data type
bsDataType := make([]byte, 1)
n, err = buf.Read(bsDataType)
if err != nil {
return header{}, oerror.NewTrace(err)
}
if n != 1 {
return header{}, oerror.IncorrectNetworkRead{Expected: 1, Actual: n}
}
hdrProp := headerProperty{name: data, typ: oschema.ODataType(bsDataType[0])}
hdr.properties = append(hdr.properties, hdrProp)
hdr.dataPtrs = append(hdr.dataPtrs, ptr)
} else {
// have a document, not a property, so the number is an encoded property id,
// convert to (positive) property-id
propertyID := decodeFieldIDInHeader(decoded)
ptr, err := rw.ReadInt(buf)
if err != nil {
return header{}, oerror.NewTrace(err)
}
hdrProp := headerProperty{id: propertyID}
hdr.properties = append(hdr.properties, hdrProp)
hdr.dataPtrs = append(hdr.dataPtrs, ptr)
}
}
return hdr, nil
}
