//
// ResolveLinks iterates over all the OLinks passed in and does a
// FetchRecordByRID for each one that has a null Record.
// TODO: maybe include a fetchplan here?
//
func ResolveLinks(dbc *DBClient, links []*oschema.OLink) error {
fetchPlan := ""
for i := 0; i < len(links); i++ {
if links[i].Record == nil {
docs, err := FetchRecordByRID(dbc, links[i].RID, fetchPlan)
if err != nil {
return oerror.NewTrace(err)
}
// DEBUG
if len(docs) > 1 {
ogl.Warnf("DEBUG: More than one record returned from FetchRecordByRID. Please report this use case to the ogonori author!!")
}
// END DEBUG
links[i].Record = docs[0]
}
}
return nil
}
//
// TODO: need example from server to know how to handle this
//
func readRawBytesRecord(dbc *DBClient) (*oschema.ODocument, error) {
ogl.Warnf("raw bytes ('b') record type -> haven't seen that before. Send to Deserializer?")
return nil, errors.New("raw bytes ('b') record type -> haven't seen that before. Send to Deserializer?")
}
//
// TODO: need example from server to know how to handle this
//
func readFlatDataRecord(dbc *DBClient) (*oschema.ODocument, error) {
ogl.Warnf("flat record ('f') record type -> haven't seen that before. What is it?")
return nil, errors.New("flat record ('f') record type -> haven't seen that before. What is it?")
}
//
// SQLCommand executes SQL commands that are not queries. Any SQL statement
// that does not being with "SELECT" should be sent here. All SELECT
// statements should go to the SQLQuery function.
//
// Commands can be optionally paramterized using ?, such as:
//
// INSERT INTO Foo VALUES(a, b, c) (?, ?, ?)
//
// The values for the placeholders (currently) must be provided as strings.
//
// Constraints (for now):
// 1. cmds with only simple positional parameters allowed
// 2. cmds with lists of parameters ("complex") NOT allowed
// 3. parameter types allowed: string only for now
//
// SQL commands in OrientDB tend to return one of two types - a string return value or
// one or more documents. The meaning are specific to the type of query.
//
// ----------------
// For example:
// ----------------
// for a DELETE statement:
// retval = number of rows deleted (as a string)
// docs = empty list
//
// for an INSERT statement:
// n = ?
// docs = ?
//
// for an CREATE CLASS statement:
// retval = cluster id of the class (TODO: or it might be number of classes in cluster)
// docs = empty list
//
// for an DROP CLASS statement:
// retval = "true" if successful, "" if class didn't exist (technically it returns null)
// docs = empty list
//
func SQLCommand(dbc *DBClient, sql string, params ...string) (retval string, docs []*oschema.ODocument, err error) {
dbc.buf.Reset()
err = writeCommandAndSessionId(dbc, REQUEST_COMMAND)
if err != nil {
return "", nil, oerror.NewTrace(err)
}
mode := byte('s') // synchronous only supported for now
err = rw.WriteByte(dbc.buf, mode)
if err != nil {
return "", nil, oerror.NewTrace(err)
}
// need a separate buffer to write the command-payload to, so
// we can calculate its length before writing it to main dbc.buf
commandBuf := new(bytes.Buffer)
// "classname" (command-type, really) and the sql command
err = rw.WriteStrings(commandBuf, "c", sql) // c for command(non-idempotent)
if err != nil {
return "", nil, oerror.NewTrace(err)
}
// SQLCommand
// (text:string)
// (has-simple-parameters:boolean)
// (simple-paremeters:bytes[]) -> serialized Map (EMBEDDEDMAP??)
// (has-complex-parameters:boolean)
// (complex-parameters:bytes[]) -> serialized Map (EMBEDDEDMAP??)
serializedParams, err := serializeSimpleSQLParams(dbc, params)
if err != nil {
return "", nil, oerror.NewTrace(err)
}
// has-simple-parameters
err = rw.WriteBool(commandBuf, serializedParams != nil)
if err != nil {
return "", nil, oerror.NewTrace(err)
}
if serializedParams != nil {
rw.WriteBytes(commandBuf, serializedParams)
}
// FIXME: no complex parameters yet since I don't understand what they are
// has-complex-paramters => HARDCODING FALSE FOR NOW
err = rw.WriteBool(commandBuf, false)
if err != nil {
return "", nil, oerror.NewTrace(err)
}
serializedCmd := commandBuf.Bytes()
// command-payload-length and command-payload
err = rw.WriteBytes(dbc.buf, serializedCmd)
if err != nil {
return "", nil, oerror.NewTrace(err)
}
// send to the OrientDB server
_, err = dbc.conx.Write(dbc.buf.Bytes())
if err != nil {
return "", nil, oerror.NewTrace(err)
}
/* ---[ Read Response ]--- */
err = readStatusCodeAndSessionId(dbc)
if err != nil {
return "", nil, oerror.NewTrace(err)
}
// for synchronous commands the remaining content is an array of form:
// [(synch-result-type:byte)[(synch-result-content:?)]]+
// so the final value will by byte(0) to indicate the end of the array
// and we must use a loop here
for {
resType, err := rw.ReadByte(dbc.conx)
if err != nil {
return "", nil, oerror.NewTrace(err)
}
// This implementation assumes that SQLCommand can never have "supplementary records"
// from an extended fetchPlan
if resType == byte(0) {
break
}
resultType := rune(resType)
ogl.Debugf("resultType for SQLCommand: %v (%s)\n", resultType, string(rune(resultType)))
if resultType == 'n' { // null result
// do nothing - anything need to be done here?
} else if resultType == 'r' { // single record
doc, err := readSingleRecord(dbc)
if err != nil {
return "", nil, oerror.NewTrace(err)
}
ogl.Debugf("r>doc = %v\n", doc) // DEBUG
if doc != nil {
docs = make([]*oschema.ODocument, 1)
docs[0] = doc
}
} else if resultType == 'l' { // collection of records
ogl.Debugln("... resultType l")
collectionDocs, err := readResultSet(dbc)
if err != nil {
return "", nil, oerror.NewTrace(err)
}
if docs == nil {
docs = collectionDocs
} else {
docs = append(docs, collectionDocs...)
}
} else if resultType == 'a' { // serialized type
serializedRec, err := rw.ReadBytes(dbc.conx)
if err != nil {
return "", nil, oerror.NewTrace(err)
}
// TODO: for now I'm going to assume that this always just returns a string
// need a use case that violates this assumption
retval = string(serializedRec)
if err != nil {
return "", nil, oerror.NewTrace(err)
}
} else {
_, file, line, _ := runtime.Caller(0)
// TODO: I've not yet tested this route of code -> how do so?
ogl.Warnf(">> Got back resultType %v (%v): Not yet supported: line:%d; file:%s\n",
resultType, string(rune(resultType)), line, file)
// TODO: returning here is NOT the correct long-term behavior
return "", nil, fmt.Errorf("Got back resultType %v (%v): Not yet supported: line:%d; file:%s\n",
resultType, string(rune(resultType)), line, file)
}
}
return retval, docs, err
}
//
// FetchEntriesOfRemoteLinkBag fills in the links of an OLinkBag that is remote
// (tree-based) rather than embedded. This function will fill in the links
// of the passed in OLinkBag, rather than returning the new links. The Links
// will have RIDs only, not full Records (ODocuments). If you then want the
// Records filled in, call the ResolveLinks function.
//
func FetchEntriesOfRemoteLinkBag(dbc *DBClient, linkBag *oschema.OLinkBag, inclusive bool) error {
var (
firstLink *oschema.OLink
linkSerde binserde.OBinaryTypeSerializer
err error
)
firstLink, err = FetchFirstKeyOfRemoteLinkBag(dbc, linkBag)
if err != nil {
return oerror.NewTrace(err)
}
dbc.buf.Reset()
err = writeCommandAndSessionId(dbc, REQUEST_SBTREE_BONSAI_GET_ENTRIES_MAJOR)
if err != nil {
return oerror.NewTrace(err)
}
err = writeLinkBagCollectionPointer(dbc.buf, linkBag)
if err != nil {
return oerror.NewTrace(err)
}
typeByte := byte(9)
linkSerde = binserde.TypeSerializers[typeByte] // the OLinkSerializer
linkBytes, err := linkSerde.Serialize(firstLink)
if err != nil {
return oerror.NewTrace(err)
}
err = rw.WriteBytes(dbc.buf, linkBytes)
if err != nil {
return oerror.NewTrace(err)
}
err = rw.WriteBool(dbc.buf, inclusive)
if err != nil {
return oerror.NewTrace(err)
}
// copied from Java client OSBTreeBonsaiRemote#fetchEntriesMajor
if dbc.binaryProtocolVersion >= 21 {
err = rw.WriteInt(dbc.buf, 128)
}
// send to the OrientDB server
_, err = dbc.conx.Write(dbc.buf.Bytes())
if err != nil {
return oerror.NewTrace(err)
}
/* ---[ Read Response ]--- */
err = readStatusCodeAndSessionId(dbc)
if err != nil {
return oerror.NewTrace(err)
}
linkEntryBytes, err := rw.ReadBytes(dbc.conx)
if err != nil {
return oerror.NewTrace(err)
}
// all the rest of the response from the server in in this byte slice so
// we can reset the dbc.buf and reuse it to deserialize the serialized links
dbc.buf.Reset()
// ignoring error since doc says this method panics rather than return
// non-nil error
n, _ := dbc.buf.Write(linkEntryBytes)
if n != len(linkEntryBytes) {
return fmt.Errorf("Unexpected error when writing bytes to bytes.Buffer")
}
nrecs, err := rw.ReadInt(dbc.buf)
if err != nil {
return oerror.NewTrace(err)
}
var result interface{}
nr := int(nrecs)
// loop over all the serialized links
for i := 0; i < nr; i++ {
result, err = linkSerde.Deserialize(dbc.buf)
if err != nil {
return oerror.NewTrace(err)
}
linkBag.AddLink(result.(*oschema.OLink))
// FIXME: for some reason the server returns a serialized link
// followed by an integer (so far always a 1 in my expts).
// Not sure what to do with this int, so ignore for now
intval, err := rw.ReadInt(dbc.buf)
if err != nil {
return oerror.NewTrace(err)
}
if intval != int32(1) {
ogl.Warnf("DEBUG: Found a use case where the val pair of a link was not 1: %d\n", intval)
}
}
return nil
}