//
// Example data section for tree-based LinkBag
//
// ( --------------------- collectionPointer ----------------------- ) (---size:int--) (-changes-)
// (----- fileId:long ----) ( ---pageIndex:long--- ) (pageOffset:int)
// TREEBASED 30 0 2048 -1 0
// 0, 0, 0, 0, 0, 0, 0, 0, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, -1, -1, -1, -1, 0, 0, 0, 0,
//
func readTreeBasedLinkBag(buf io.Reader) (*oschema.OLinkBag, error) {
fileID, err := rw.ReadLong(buf)
if err != nil {
return nil, oerror.NewTrace(err)
}
pageIdx, err := rw.ReadLong(buf)
if err != nil {
return nil, oerror.NewTrace(err)
}
pageOffset, err := rw.ReadInt(buf)
if err != nil {
return nil, oerror.NewTrace(err)
}
// TODO: need to know how to handle the size and changes stuff => advanced feature not needed yet
size, err := rw.ReadInt(buf)
if err != nil {
return nil, oerror.NewTrace(err)
}
_, err = rw.ReadInt(buf) // changes // TODO: is changes always an int32?
if err != nil {
return nil, oerror.NewTrace(err)
}
return oschema.NewTreeOLinkBag(fileID, pageIdx, pageOffset, size), nil
}
//
// readSingleDocument is called by readSingleRecord when it has determined that the server
// has sent a docuemnt ('d'), not flat data ('f') or raw bytes ('b').
// It should be called *after* the single byte below on the first line has been already
// read and determined to be 'd'. The rest the stream (NOT including the EOT byte) will
// be read. The serialized document will be turned into an oschema.ODocument.
//
// Writing byte (1 byte): 100 [OChannelBinaryServer] <- 'd'=document ('f'=flat data, 'b'=raw bytes)
// Writing short (2 bytes): 11 [OChannelBinaryServer] <- cluster-id (RID part 1)
// Writing long (8 bytes): 0 [OChannelBinaryServer] <- cluster-pos (RID part 2)
// Writing int (4 bytes): 1 [OChannelBinaryServer] <- version
// Writing bytes (4+26=30 bytes): [0, 14, 80, 97, 116, ... , 110, 107, 1] <- serialized record
//
func readSingleDocument(dbc *DBClient) (*oschema.ODocument, error) {
clusterId, err := rw.ReadShort(dbc.conx)
if err != nil {
return nil, oerror.NewTrace(err)
}
clusterPos, err := rw.ReadLong(dbc.conx)
if err != nil {
return nil, oerror.NewTrace(err)
}
recVersion, err := rw.ReadInt(dbc.conx)
if err != nil {
return nil, oerror.NewTrace(err)
}
recBytes, err := rw.ReadBytes(dbc.conx)
if err != nil {
return nil, oerror.NewTrace(err)
}
rid := oschema.ORID{ClusterID: clusterId, ClusterPos: clusterPos}
doc, err := createDocumentFromBytes(rid, recVersion, recBytes, dbc)
ogl.Debugf("::single record doc:::::: %v\n", doc)
return doc, err
}
func getLongFromDB(dbc *DBClient, cmd byte) (int64, error) {
dbc.buf.Reset()
err := writeCommandAndSessionId(dbc, cmd)
if err != nil {
return int64(-1), oerror.NewTrace(err)
}
// send to the OrientDB server
_, err = dbc.conx.Write(dbc.buf.Bytes())
if err != nil {
return int64(-1), oerror.NewTrace(err)
}
/* ---[ Read Response ]--- */
err = readStatusCodeAndSessionId(dbc)
if err != nil {
return int64(-1), oerror.NewTrace(err)
}
// the answer to the query
longFromDB, err := rw.ReadLong(dbc.conx)
if err != nil {
return int64(-1), oerror.NewTrace(err)
}
return longFromDB, nil
}
func readEmbeddedLinkBag(rdr io.Reader) (*oschema.OLinkBag, error) {
bs := make([]byte, 1)
n, err := rdr.Read(bs)
if err != nil {
return nil, oerror.NewTrace(err)
}
if n != 1 {
return nil, oerror.IncorrectNetworkRead{Expected: 1, Actual: n}
}
if bs[0] == 1 {
uuid, err := readLinkBagUUID(rdr)
if err != nil {
return nil, oerror.NewTrace(err)
}
ogl.Debugf("read uuid %v - now what?\n", uuid)
} else {
// if b wasn't zero, then there's no UUID and b was the first byte of an int32
// specifying the size of the embedded bag collection
// TODO: I'm not sure this is the right thing - the OrientDB is pretty hazy on how this works
switch rdr.(type) {
case *bytes.Buffer:
buf := rdr.(*bytes.Buffer)
buf.UnreadByte()
case *obuf.ReadBuf:
buf := rdr.(*obuf.ReadBuf)
buf.UnreadByte()
default:
panic("Unknown type of buffer in binserde#readEmbeddedLinkBag")
}
}
bagsz, err := rw.ReadInt(rdr)
if err != nil {
return nil, oerror.NewTrace(err)
}
links := make([]*oschema.OLink, bagsz)
for i := int32(0); i < bagsz; i++ {
clusterID, err := rw.ReadShort(rdr)
if err != nil {
return nil, oerror.NewTrace(err)
}
clusterPos, err := rw.ReadLong(rdr)
if err != nil {
return nil, oerror.NewTrace(err)
}
orid := oschema.ORID{ClusterID: clusterID, ClusterPos: clusterPos}
links[i] = &oschema.OLink{RID: orid}
}
return oschema.NewOLinkBag(links), nil
}
//
// FetchClusterDataRange returns the range of record ids for a cluster
//
func FetchClusterDataRange(dbc *DBClient, clusterName string) (begin, end int64, err error) {
dbc.buf.Reset()
clusterID := findClusterWithName(dbc.currDB.Clusters, strings.ToLower(clusterName))
if clusterID < 0 {
// TODO: This is problematic - someone else may add the cluster not through this
// driver session and then this would fail - so options:
// 1) do a lookup of all clusters on the DB
// 2) provide a FetchClusterRangeById(dbc, clusterID)
return begin, end,
fmt.Errorf("No cluster with name %s is known in database %s\n", clusterName, dbc.currDB.Name)
}
err = writeCommandAndSessionId(dbc, REQUEST_DATACLUSTER_DATARANGE)
if err != nil {
return begin, end, oerror.NewTrace(err)
}
err = rw.WriteShort(dbc.buf, clusterID)
if err != nil {
return begin, end, oerror.NewTrace(err)
}
// send to the OrientDB server
_, err = dbc.conx.Write(dbc.buf.Bytes())
if err != nil {
return begin, end, oerror.NewTrace(err)
}
/* ---[ Read Response ]--- */
err = readStatusCodeAndSessionId(dbc)
if err != nil {
return begin, end, oerror.NewTrace(err)
}
begin, err = rw.ReadLong(dbc.conx)
if err != nil {
return begin, end, oerror.NewTrace(err)
}
end, err = rw.ReadLong(dbc.conx)
return begin, end, err
}
func (ols OLinkSerializer) Deserialize(buf *bytes.Buffer) (interface{}, error) {
clusterID, err := rw.ReadShort(buf)
if err != nil {
return nil, oerror.NewTrace(err)
}
clusterPos, err := rw.ReadLong(buf)
if err != nil {
return nil, oerror.NewTrace(err)
}
rid := oschema.ORID{ClusterID: clusterID, ClusterPos: clusterPos}
return &oschema.OLink{RID: rid}, nil
}
//
// readRID should be called when a single record (as opposed to a collection of
// records) is returned from a db query/command (REQUEST_COMMAND only ???).
// That is when the server sends back:
// 1) Writing byte (1 byte): 0 [OChannelBinaryServer] -> SUCCESS
// 2) Writing int (4 bytes): 192 [OChannelBinaryServer] -> session-id
// 3) Writing byte (1 byte): 114 [OChannelBinaryServer] -> 'r' (single record)
// 4) Writing short (2 bytes): 0 [OChannelBinaryServer] -> full record (not null, not RID only)
// Line 3 can be 'l' or possibly other things. For 'l' call readResultSet.
// Line 4 can be 0=full-record, -2=null, -3=RID only. For -3, call readRID. For 0, call this readSingleDocument.
//
func readRID(dbc *DBClient) (oschema.ORID, error) {
// svr response: (-3:short)(cluster-id:short)(cluster-position:long)
// TODO: impl me -> in the future this may need to call loadRecord for the RID and return the ODocument
clusterID, err := rw.ReadShort(dbc.conx)
if err != nil {
return oschema.NewORID(), oerror.NewTrace(err)
}
clusterPos, err := rw.ReadLong(dbc.conx)
if err != nil {
return oschema.NewORID(), oerror.NewTrace(err)
}
return oschema.ORID{ClusterID: clusterID, ClusterPos: clusterPos}, nil
}
//
// readResultSet should be called for collections (resultType = 'l')
// from a SQLQuery call.
//
func readResultSet(dbc *DBClient) ([]*oschema.ODocument, error) {
// for Collection
// next val is: (collection-size:int)
// and then each record is serialized according to format:
// (0:short)(record-type:byte)(cluster-id:short)(cluster-position:long)(record-version:int)(record-content:bytes)
resultSetSize, err := rw.ReadInt(dbc.conx)
if err != nil {
return nil, oerror.NewTrace(err)
}
rsize := int(resultSetSize)
docs := make([]*oschema.ODocument, rsize)
for i := 0; i < rsize; i++ {
// TODO: move code below to readRecordInResultSet
// this apparently should always be zero for serialized records -> not sure it's meaning
zero, err := rw.ReadShort(dbc.conx)
if err != nil {
return nil, oerror.NewTrace(err)
}
if zero != int16(0) {
return nil, fmt.Errorf("ERROR: readResultSet: expected short value of 0 but is %d", zero)
}
recType, err := rw.ReadByte(dbc.conx)
if err != nil {
return nil, oerror.NewTrace(err)
}
// TODO: may need to check recType here => not sure that clusterId, clusterPos and version follow next if
// type is 'b' (raw bytes) or 'f' (flat record)
// see the readSingleDocument method (and probably call that one instead?)
clusterId, err := rw.ReadShort(dbc.conx)
if err != nil {
return nil, oerror.NewTrace(err)
}
clusterPos, err := rw.ReadLong(dbc.conx)
if err != nil {
return nil, oerror.NewTrace(err)
}
recVersion, err := rw.ReadInt(dbc.conx)
if err != nil {
return nil, oerror.NewTrace(err)
}
if recType == byte('d') { // Document
var doc *oschema.ODocument
rid := oschema.ORID{ClusterID: clusterId, ClusterPos: clusterPos}
recBytes, err := rw.ReadBytes(dbc.conx)
if err != nil {
return nil, oerror.NewTrace(err)
}
doc, err = createDocumentFromBytes(rid, recVersion, recBytes, dbc)
if err != nil {
return nil, oerror.NewTrace(err)
}
docs[i] = doc
} else {
_, file, line, _ := runtime.Caller(0)
return nil, fmt.Errorf("%v: %v: Record type %v is not yet supported", file, line+1, recType)
}
} // end for loop
// end, err := rw.ReadByte(dbc.conx)
// if err != nil {
// return nil, oerror.NewTrace(err)
// }
// if end != byte(0) {
// return nil, fmt.Errorf("Final Byte read from collection result set was not 0, but was: %v", end)
// }
return docs, nil
}
func getClusterCount(dbc *DBClient, countTombstones bool, clusterNames []string) (count int64, err error) {
dbc.buf.Reset()
clusterIDs := make([]int16, len(clusterNames))
for i, name := range clusterNames {
clusterID := findClusterWithName(dbc.currDB.Clusters, strings.ToLower(name))
if clusterID < 0 {
// TODO: This is problematic - someone else may add the cluster not through this
// driver session and then this would fail - so options:
// 1) do a lookup of all clusters on the DB
// 2) provide a FetchClusterCountById(dbc, clusterID)
return int64(0),
fmt.Errorf("No cluster with name %s is known in database %s\n",
name, dbc.currDB.Name)
}
clusterIDs[i] = clusterID
}
err = writeCommandAndSessionId(dbc, REQUEST_DATACLUSTER_COUNT)
if err != nil {
return int64(0), oerror.NewTrace(err)
}
// specify number of clusterIDs being sent and then write the clusterIDs
err = rw.WriteShort(dbc.buf, int16(len(clusterIDs)))
if err != nil {
return int64(0), oerror.NewTrace(err)
}
for _, cid := range clusterIDs {
err = rw.WriteShort(dbc.buf, cid)
if err != nil {
return int64(0), oerror.NewTrace(err)
}
}
// count-tombstones
var ct byte
if countTombstones {
ct = byte(1)
}
err = rw.WriteByte(dbc.buf, ct) // presuming that 0 means "false"
if err != nil {
return int64(0), oerror.NewTrace(err)
}
// send to the OrientDB server
_, err = dbc.conx.Write(dbc.buf.Bytes())
if err != nil {
return int64(0), oerror.NewTrace(err)
}
/* ---[ Read Response ]--- */
err = readStatusCodeAndSessionId(dbc)
if err != nil {
return int64(0), oerror.NewTrace(err)
}
nrecs, err := rw.ReadLong(dbc.conx)
if err != nil {
return int64(0), oerror.NewTrace(err)
}
return nrecs, err
}