//
// DatabaseExists is a server-level command, so must be preceded by calling
// ConnectToServer, otherwise an authorization error will be returned.
// The storageType param must be either PersistentStorageType or VolatileStorageType.
//
func DatabaseExists(dbc *DBClient, dbname string, storageType constants.StorageType) (bool, error) {
dbc.buf.Reset()
if dbc.sessionId == NoSessionID {
return false, oerror.SessionNotInitialized{}
}
// cmd
err := rw.WriteByte(dbc.buf, REQUEST_DB_EXIST)
if err != nil {
return false, err
}
// session id
err = rw.WriteInt(dbc.buf, dbc.sessionId)
if err != nil {
return false, err
}
// database name, storage-type
err = rw.WriteStrings(dbc.buf, dbname, string(storageType))
if err != nil {
return false, err
}
// send to the OrientDB server
_, err = dbc.conx.Write(dbc.buf.Bytes())
if err != nil {
return false, err
}
/* ---[ Read Response From Server ]--- */
status, err := rw.ReadByte(dbc.conx)
if err != nil {
return false, err
}
err = readAndValidateSessionId(dbc.conx, dbc.sessionId)
if err != nil {
return false, err
}
if status == RESPONSE_STATUS_ERROR {
serverExceptions, err := rw.ReadErrorResponse(dbc.conx)
if err != nil {
return false, err
}
return false, fmt.Errorf("Server Error(s): %v", serverExceptions)
}
// the answer to the query
dbexists, err := rw.ReadBool(dbc.conx)
if err != nil {
return false, err
}
return dbexists, nil
}
//
// CreateDatabase will create a `remote` database of the type and storageType specified.
// dbType must be type DocumentDBType or GraphDBType.
// storageType must type PersistentStorageType or VolatileStorageType.
//
func CreateDatabase(dbc *DBClient, dbname string, dbtype constants.DatabaseType, storageType constants.StorageType) error {
dbc.buf.Reset()
/* ---[ precondition checks ]--- */
// TODO: may need to change this to serverSessionid (can the "sessionId" be used for both server connections and db conx?)
if dbc.sessionId == NoSessionID {
return oerror.SessionNotInitialized{}
}
/* ---[ build request and send to server ]--- */
// cmd
err := rw.WriteByte(dbc.buf, REQUEST_DB_CREATE)
if err != nil {
return err
}
// session id
err = rw.WriteInt(dbc.buf, dbc.sessionId)
if err != nil {
return err
}
err = rw.WriteStrings(dbc.buf, dbname, string(dbtype), string(storageType))
if err != nil {
return err
}
// send to the OrientDB server
_, err = dbc.conx.Write(dbc.buf.Bytes())
if err != nil {
return err
}
/* ---[ read response from server ]--- */
status, err := rw.ReadByte(dbc.conx)
if err != nil {
return err
}
err = readAndValidateSessionId(dbc.conx, dbc.sessionId)
if err != nil {
return err
}
if status == RESPONSE_STATUS_ERROR {
serverExceptions, err := rw.ReadErrorResponse(dbc.conx)
if err != nil {
return err
}
return fmt.Errorf("Server Error(s): %v", serverExceptions)
}
return nil
}
//
// writeEmbeddedMap serializes the EMBEDDEDMAP type. Currently, OrientDB only uses string
// types for the map keys, so that is an assumption of this method as well.
//
func (serde ORecordSerializerV0) writeEmbeddedMap(buf *obuf.WriteBuf, m oschema.OEmbeddedMap) error {
// number of entries in the map
err := varint.EncodeAndWriteVarInt32(buf, int32(m.Len()))
if err != nil {
return oerror.NewTrace(err)
}
ptrPos := make([]int, 0, m.Len()) // position in buf where data ptr int needs to be written
// TODO: do the map entries have to be written in any particular order? I will assume no for now
keys, vals, types := m.All()
/* ---[ write embedded map header ]--- */
for i, k := range keys {
// key type
err = rw.WriteByte(buf, byte(oschema.STRING))
if err != nil {
return oerror.NewTrace(err)
}
// write the key value
err = varint.WriteString(buf, k)
if err != nil {
return oerror.NewTrace(err)
}
ptrPos = append(ptrPos, buf.Len())
buf.Skip(4) // placeholder integer for data ptr
dataType := types[i]
if dataType == oschema.UNKNOWN {
dataType = getDataType(vals[i]) // TODO: not sure this is necessary
}
// write data type of the data
err = rw.WriteByte(buf, byte(dataType))
if err != nil {
return oerror.NewTrace(err)
}
}
/* ---[ write embedded map data values ]--- */
for i := 0; i < len(vals); i++ {
currPos := buf.Len()
buf.Seek(uint(ptrPos[i]))
err = rw.WriteInt(buf, int32(currPos))
if err != nil {
return oerror.NewTrace(err)
}
buf.Seek(uint(currPos))
err = serde.writeDataValue(buf, vals[i], types[i])
if err != nil {
return oerror.NewTrace(err)
}
}
return nil
}
//
// DropDatabase drops the specified database. The caller must provide
// both the name and the type of the database. The type should either:
//
// obinary.DocumentDBType
// obinary.GraphDBType
//
// This is a "server" command, so you must have already called
// ConnectToServer before calling this function.
//
func DropDatabase(dbc *DBClient, dbname string, dbtype constants.DatabaseType) error {
dbc.buf.Reset()
if dbc.sessionId == NoSessionID {
return oerror.SessionNotInitialized{}
}
// cmd
err := rw.WriteByte(dbc.buf, REQUEST_DB_DROP)
if err != nil {
return err
}
// session id
err = rw.WriteInt(dbc.buf, dbc.sessionId)
if err != nil {
return err
}
// database name, storage-type
err = rw.WriteStrings(dbc.buf, dbname, string(dbtype))
if err != nil {
return err
}
// send to the OrientDB server
_, err = dbc.conx.Write(dbc.buf.Bytes())
if err != nil {
return err
}
/* ---[ read response from server ]--- */
status, err := rw.ReadByte(dbc.conx)
if err != nil {
return err
}
err = readAndValidateSessionId(dbc.conx, dbc.sessionId)
if err != nil {
return err
}
if status == RESPONSE_STATUS_ERROR {
serverExceptions, err := rw.ReadErrorResponse(dbc.conx)
if err != nil {
return err
}
return fmt.Errorf("Server Error(s): %v", serverExceptions)
}
return nil
}
func writeLinkBagCollectionPointer(buf *bytes.Buffer, linkBag *oschema.OLinkBag) error {
// (treePointer:collectionPointer)(changes)
// where collectionPtr = (fileId:long)(pageIndex:long)(pageOffset:int)
err := rw.WriteLong(buf, linkBag.GetFileID())
if err != nil {
return oerror.NewTrace(err)
}
err = rw.WriteLong(buf, linkBag.GetPageIndex())
if err != nil {
return oerror.NewTrace(err)
}
return rw.WriteInt(buf, linkBag.GetPageOffset())
}
func writeCommandAndSessionId(dbc *DBClient, cmd byte) error {
if dbc.sessionId == NoSessionID {
return oerror.SessionNotInitialized{}
}
err := rw.WriteByte(dbc.buf, cmd)
if err != nil {
return oerror.NewTrace(err)
}
err = rw.WriteInt(dbc.buf, dbc.sessionId)
if err != nil {
return oerror.NewTrace(err)
}
return nil
}
//
// SQLQuery
//
// TODO: right now I return the entire resultSet as an array, thus all loaded into memory
// it would be better to have obinary.dbCommands provide an iterator based model
// that only needs to read a "row" (ODocument) at a time
// Perhaps SQLQuery() -> iterator/cursor
// SQLQueryGetAll() -> []*ODocument ??
//
func SQLQuery(dbc *DBClient, sql string, fetchPlan string, params ...string) ([]*oschema.ODocument, 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)
err = rw.WriteStrings(commandBuf, "q", sql) // q for query
if err != nil {
return nil, oerror.NewTrace(err)
}
// non-text-limit (-1 = use limit from query text)
err = rw.WriteInt(commandBuf, -1)
if err != nil {
return nil, oerror.NewTrace(err)
}
// fetch plan
err = rw.WriteString(commandBuf, fetchPlan)
if err != nil {
return nil, oerror.NewTrace(err)
}
serializedParams, err := serializeSimpleSQLParams(dbc, params)
if err != nil {
return nil, oerror.NewTrace(err)
}
if serializedParams != nil {
rw.WriteBytes(commandBuf, serializedParams)
}
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
finalBytes := dbc.buf.Bytes()
_, err = dbc.conx.Write(finalBytes)
if err != nil {
return nil, oerror.NewTrace(err)
}
/* ---[ Read Response ]--- */
err = readStatusCodeAndSessionId(dbc)
if err != nil {
return nil, oerror.NewTrace(err)
}
resType, err := rw.ReadByte(dbc.conx)
if err != nil {
return nil, oerror.NewTrace(err)
}
resultType := int32(resType)
var docs []*oschema.ODocument
if resultType == 'n' {
// NOTE: OStorageRemote in Java client just sets result to null and moves on
ogl.Warn("Result type in SQLQuery is 'n' -> what to do? nothing ???") // DEBUG
} else if resultType == 'r' {
ogl.Warn("NOTE NOTE NOTE: this path has NOT YET BEEN TESTED") // DEBUG
doc, err := readSingleRecord(dbc)
if err != nil {
return nil, oerror.NewTrace(err)
}
docs = append(docs, doc)
} else if resultType == 'l' {
docs, err = readResultSet(dbc)
if err != nil {
return nil, oerror.NewTrace(err)
}
} else {
// TODO: I've not yet tested this route of code -> how do so?
ogl.Warn(">> Not yet supported")
ogl.Fatal(fmt.Sprintf("NOTE NOTE NOTE: testing the resultType == '%v' (else) route of code -- "+
"remove this note and test it!!", string(resultType)))
}
// any additional records are "supplementary" - from the fetchPlan these
// need to be hydrated into ODocuments and then put into the primary Docs
if dbc.binaryProtocolVersion >= int16(17) { // copied from the OrientDB 2.x Java client
end, err := rw.ReadByte(dbc.conx)
if err != nil {
return nil, oerror.NewTrace(err)
}
if end != byte(0) {
mapRIDToDoc, err := readSupplementaryRecords(dbc)
if err != nil {
return nil, oerror.NewTrace(err)
}
addSupplementaryRecsToPrimaryRecs(docs, mapRIDToDoc)
}
}
return docs, nil
}
//
// UpdateRecord should be used update an existing record in the OrientDB database.
// It does the REQUEST_RECORD_UPDATE OrientDB cmd (network binary protocol)
//
func UpdateRecord(dbc *DBClient, doc *oschema.ODocument) error {
dbc.buf.Reset()
err := writeCommandAndSessionId(dbc, REQUEST_RECORD_UPDATE)
if err != nil {
return oerror.NewTrace(err)
}
if doc.RID.ClusterID < 0 || doc.RID.ClusterPos < 0 {
return errors.New("Document is not updateable - has negative RID values")
}
err = rw.WriteShort(dbc.buf, doc.RID.ClusterID)
if err != nil {
return oerror.NewTrace(err)
}
err = rw.WriteLong(dbc.buf, doc.RID.ClusterPos)
if err != nil {
return oerror.NewTrace(err)
}
// update-content flag
err = rw.WriteBool(dbc.buf, true)
if err != nil {
return oerror.NewTrace(err)
}
// serialized-doc
serde := dbc.RecordSerDes[int(dbc.serializationVersion)]
// this writes the serialized record to dbc.buf
serializedBytes, err := serde.Serialize(dbc, doc)
if err != nil {
return oerror.NewTrace(err)
}
err = rw.WriteBytes(dbc.buf, serializedBytes)
if err != nil {
return oerror.NewTrace(err)
}
// record version
err = rw.WriteInt(dbc.buf, doc.Version)
if err != nil {
return oerror.NewTrace(err)
}
// record-type: document
err = rw.WriteByte(dbc.buf, byte('d')) // TODO: how support 'b' (raw bytes) & 'f' (flat data)?
if err != nil {
return oerror.NewTrace(err)
}
// mode: synchronous
err = rw.WriteByte(dbc.buf, 0x0)
if err != nil {
return oerror.NewTrace(err)
}
// 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)
}
doc.Version, err = rw.ReadInt(dbc.conx)
if err != nil {
return oerror.NewTrace(err)
}
nCollChanges, err := rw.ReadInt(dbc.conx)
if err != nil {
return oerror.NewTrace(err)
}
if nCollChanges != 0 {
// if > 0, then have to deal with RidBag mgmt:
// [(uuid-most-sig-bits:long)(uuid-least-sig-bits:long)(updated-file-id:long)(updated-page-index:long)(updated-page-offset:int)]
panic("CreateRecord: Found case where number-collection-changes is not zero -> log case and impl code to handle")
}
return nil
}
//
// 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
}
func deleteByRID(dbc *DBClient, rid string, recVersion int32, async bool) error {
dbc.buf.Reset()
orid := oschema.NewORIDFromString(rid)
err := writeCommandAndSessionId(dbc, REQUEST_RECORD_DELETE)
if err != nil {
return err
}
err = rw.WriteShort(dbc.buf, orid.ClusterID)
if err != nil {
return err
}
err = rw.WriteLong(dbc.buf, orid.ClusterPos)
if err != nil {
return err
}
err = rw.WriteInt(dbc.buf, recVersion)
if err != nil {
return err
}
// sync mode ; 0 = synchronous; 1 = asynchronous
var syncMode byte
if async {
syncMode = byte(1)
}
err = rw.WriteByte(dbc.buf, syncMode)
if err != nil {
return err
}
// send to the OrientDB server
_, err = dbc.conx.Write(dbc.buf.Bytes())
if err != nil {
return err
}
/* ---[ Read Response ]--- */
err = readStatusCodeAndSessionId(dbc)
if err != nil {
return err
}
payloadStatus, err := rw.ReadByte(dbc.conx)
if err != nil {
return err
}
// status 1 means record was deleted;
// status 0 means record was not deleted (either failed or didn't exist)
if payloadStatus == byte(0) {
return fmt.Errorf("Server reports record %s was not deleted. Either failed or did not exist.",
rid)
}
return nil
}
//
// OpenDatabase sends the REQUEST_DB_OPEN command to the OrientDB server to
// open the db in read/write mode. The database name and type are required, plus
// username and password. Database type should be one of the obinary constants:
// DocumentDBType or GraphDBType.
//
func OpenDatabase(dbc *DBClient, dbname string, dbtype constants.DatabaseType, username, passw string) error {
buf := dbc.buf
buf.Reset()
// first byte specifies request type
err := rw.WriteByte(buf, REQUEST_DB_OPEN)
if err != nil {
return oerror.NewTrace(err)
}
// session-id - send a negative number to create a new server-side conx
err = rw.WriteInt(buf, RequestNewSession)
if err != nil {
return oerror.NewTrace(err)
}
err = rw.WriteStrings(buf, DriverName, DriverVersion)
if err != nil {
return oerror.NewTrace(err)
}
err = rw.WriteShort(buf, dbc.binaryProtocolVersion)
if err != nil {
return oerror.NewTrace(err)
}
// dbclient id - send as null, but cannot be null if clustered config
// TODO: change to use dbc.clusteredConfig once that is added
err = rw.WriteNull(buf)
if err != nil {
return oerror.NewTrace(err)
}
// serialization-impl
err = rw.WriteString(buf, dbc.serializationType)
if err != nil {
return oerror.NewTrace(err)
}
// token-session // TODO: hardcoded as false for now -> change later based on ClientOptions settings
err = rw.WriteBool(buf, false)
if err != nil {
return oerror.NewTrace(err)
}
// dbname, dbtype, username, password
err = rw.WriteStrings(buf, dbname, string(dbtype), username, passw)
if err != nil {
return oerror.NewTrace(err)
}
// now send to the OrientDB server
_, err = dbc.conx.Write(buf.Bytes())
if err != nil {
return oerror.NewTrace(err)
}
/* ---[ read back response ]--- */
// first byte indicates success/error
status, err := rw.ReadByte(dbc.conx)
if err != nil {
return oerror.NewTrace(err)
}
dbc.currDB = NewDatabase(dbname, dbtype)
// the first int returned is the session id sent - which was the `RequestNewSession` sentinel
sessionValSent, err := rw.ReadInt(dbc.conx)
if err != nil {
return oerror.NewTrace(err)
}
if sessionValSent != RequestNewSession {
return errors.New("Unexpected Error: Server did not return expected session-request-val that was sent")
}
// if status returned was ERROR, then the rest of server data is the exception info
if status != RESPONSE_STATUS_OK {
exceptions, err := rw.ReadErrorResponse(dbc.conx)
if err != nil {
return oerror.NewTrace(err)
}
return fmt.Errorf("Server Error(s): %v", exceptions)
}
// for the REQUEST_DB_OPEN case, another int is returned which is the new sessionId
sessionId, err := rw.ReadInt(dbc.conx)
if err != nil {
return oerror.NewTrace(err)
}
dbc.sessionId = sessionId
// next is the token, which may be null
tokenBytes, err := rw.ReadBytes(dbc.conx)
if err != nil {
return oerror.NewTrace(err)
}
dbc.token = tokenBytes
// array of cluster info in this db // TODO: do we need to retain all this in memory?
numClusters, err := rw.ReadShort(dbc.conx)
if err != nil {
return oerror.NewTrace(err)
}
clusters := make([]OCluster, 0, numClusters)
for i := 0; i < int(numClusters); i++ {
clusterName, err := rw.ReadString(dbc.conx)
if err != nil {
return oerror.NewTrace(err)
}
clusterId, err := rw.ReadShort(dbc.conx)
if err != nil {
return oerror.NewTrace(err)
}
clusters = append(clusters, OCluster{Name: clusterName, Id: clusterId})
}
dbc.currDB.Clusters = clusters
// cluster-config - bytes - null unless running server in clustered config
// TODO: treating this as an opaque blob for now
clusterCfg, err := rw.ReadBytes(dbc.conx)
if err != nil {
return oerror.NewTrace(err)
}
dbc.currDB.ClustCfg = clusterCfg
// orientdb server release - throwing away for now // TODO: need this?
_, err = rw.ReadString(dbc.conx)
if err != nil {
return oerror.NewTrace(err)
}
//
/* ---[ load #0:0 - config record ]--- */
schemaRIDStr, err := loadConfigRecord(dbc)
if err != nil {
return oerror.NewTrace(err)
}
clusterID, clusterPos, err := parseRid(schemaRIDStr)
if err != nil {
return oerror.NewTrace(err)
}
//
/* ---[ load #0:1 - schema record ]--- */
err = loadSchema(dbc, oschema.ORID{ClusterID: clusterID, ClusterPos: clusterPos})
if err != nil {
return oerror.NewTrace(err)
}
return nil
}
//
// RequestDBList works like the "list databases" command from the OrientDB client.
// The result is put into a map, where the key of the map is the name of the
// database and the value is the type concatenated with the path, like so:
//
// key: cars
// val: plocal:/path/to/orientdb-community-2.0.1/databases/cars
//
func RequestDBList(dbc *DBClient) (map[string]string, error) {
dbc.buf.Reset()
if dbc.sessionId == NoSessionID {
return nil, oerror.SessionNotInitialized{}
}
// cmd
err := rw.WriteByte(dbc.buf, REQUEST_DB_LIST)
if err != nil {
return nil, oerror.NewTrace(err)
}
// session id
err = rw.WriteInt(dbc.buf, dbc.sessionId)
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)
}
status, err := rw.ReadByte(dbc.conx)
if err != nil {
return nil, oerror.NewTrace(err)
}
err = readAndValidateSessionId(dbc.conx, dbc.sessionId)
if err != nil {
return nil, oerror.NewTrace(err)
}
if status == RESPONSE_STATUS_ERROR {
serverExceptions, err := rw.ReadErrorResponse(dbc.conx)
if err != nil {
return nil, oerror.NewTrace(err)
}
return nil, fmt.Errorf("Server Error(s): %v", serverExceptions)
}
// the bytes returned as a serialized EMBEDDEDMAP, so send it to the SerDe
responseBytes, err := rw.ReadBytes(dbc.conx)
if err != nil {
return nil, oerror.NewTrace(err)
}
serde := dbc.RecordSerDes[int(responseBytes[0])]
buf := obuf.NewReadBuffer(responseBytes[1:])
doc := oschema.NewDocument("")
err = serde.Deserialize(dbc, doc, buf)
if err != nil {
return nil, oerror.NewTrace(err)
}
m := make(map[string]string)
fldMap := doc.GetField("databases").Value.(map[string]interface{})
for k, v := range fldMap {
m[k] = v.(string)
}
return m, nil
}
//
// ConnectToServer logs into the OrientDB server with the appropriate
// admin privileges in order to execute server-level commands (as opposed
// to database-level commands). This must be called to establish a server
// session before any other server-level commands. The username and password
// required are for the server (admin) not any particular database.
//
func ConnectToServer(dbc *DBClient, adminUser, adminPassw string) error {
buf := dbc.buf
buf.Reset()
// first byte specifies request type
err := rw.WriteByte(buf, REQUEST_CONNECT)
if err != nil {
return err
}
// session-id - send a negative number to create a new server-side conx
err = rw.WriteInt(buf, RequestNewSession)
if err != nil {
return err
}
err = rw.WriteStrings(buf, DriverName, DriverVersion)
if err != nil {
return err
}
err = rw.WriteShort(buf, dbc.binaryProtocolVersion)
if err != nil {
return err
}
// dbclient id - send as null, but cannot be null if clustered config
// TODO: change to use dbc.clusteredConfig once that is added
err = rw.WriteNull(buf)
if err != nil {
return err
}
// serialization-impl
err = rw.WriteString(buf, dbc.serializationType)
if err != nil {
return err
}
// token-session // TODO: hardcoded as false for now -> change later based on ClientOptions settings
err = rw.WriteBool(buf, false)
if err != nil {
return err
}
// admin username, password
err = rw.WriteStrings(buf, adminUser, adminPassw)
if err != nil {
return err
}
// send to OrientDB server
_, err = dbc.conx.Write(buf.Bytes())
if err != nil {
return err
}
/* ---[ Read Server Response ]--- */
// first byte indicates success/error
status, err := rw.ReadByte(dbc.conx)
if err != nil {
return err
}
// the first int returned is the session id sent - which was the `RequestNewSession` sentinel
sessionValSent, err := rw.ReadInt(dbc.conx)
if err != nil {
return err
}
if sessionValSent != RequestNewSession {
return errors.New("Unexpected Error: Server did not return expected session-request-val that was sent")
}
// if status returned was ERROR, then the rest of server data is the exception info
if status != RESPONSE_STATUS_OK {
exceptions, err := rw.ReadErrorResponse(dbc.conx)
if err != nil {
return err
}
return fmt.Errorf("Server Error(s): %v", exceptions)
}
// for the REQUEST_CONNECT case, another int is returned which is the new sessionId
sessionId, err := rw.ReadInt(dbc.conx)
if err != nil {
return err
}
// TODO: this assumes you can only have one sessionId - but perhaps can have a server sessionid
// and one or more database sessions open at the same time ?????
dbc.sessionId = sessionId
tokenBytes, err := rw.ReadBytes(dbc.conx)
if err != nil {
return err
}
dbc.token = tokenBytes
return nil
}
//
// In Progress attempt to rewrite writeSerializedRecord and related fns
// using a seekable/skipping WriteBuf
//
func (serde ORecordSerializerV0) writeSerializedRecord(wbuf *obuf.WriteBuf, doc *oschema.ODocument) (err error) {
nfields := len(doc.FieldNames())
ptrPos := make([]int, 0, nfields) // position in buf where data ptr int needs to be written
currDB := serde.dbc.GetCurrDB()
oclass, ok := currDB.Classes[doc.Classname]
docFields := doc.GetFields()
for _, fld := range docFields {
var oprop *oschema.OProperty
if ok {
oprop = oclass.Properties[fld.Name]
}
// FROM THE JAVA CLIENT:
// if (properties[i] != null) {
// OVarIntSerializer.write(bytes, (properties[i].getId() + 1) * -1);
// if (properties[i].getType() != OType.ANY)
// pos[i] = bytes.alloc(OIntegerSerializer.INT_SIZE);
// else
// pos[i] = bytes.alloc(OIntegerSerializer.INT_SIZE + 1); // TODO: why does ANY required an additional byte?
// } else {
// writeString(bytes, entry.getKey());
// pos[i] = bytes.alloc(OIntegerSerializer.INT_SIZE + 1);
if oprop != nil {
// if property is known in the global properties, then
// just write its encoded id
varint.EncodeAndWriteVarInt32(wbuf, encodeFieldIDForHeader(oprop.ID))
ptrPos = append(ptrPos, wbuf.Len())
wbuf.Skip(4)
// Note: no need to write property type when writing property ID
} else {
// property Name
err = varint.WriteString(wbuf, fld.Name)
if err != nil {
return oerror.NewTrace(err)
}
ptrPos = append(ptrPos, wbuf.Len())
wbuf.Skip(4)
// property Type
err = rw.WriteByte(wbuf, byte(fld.Type))
if err != nil {
return oerror.NewTrace(err)
}
}
}
wbuf.WriteByte(0) // End of Header sentinel
// now write out the data values
for i, fld := range docFields {
currPos := wbuf.Len()
wbuf.Seek(uint(ptrPos[i]))
err = rw.WriteInt(wbuf, int32(currPos))
if err != nil {
return oerror.NewTrace(err)
}
wbuf.Seek(uint(currPos))
err = serde.writeDataValue(wbuf, fld.Value, fld.Type)
if err != nil {
return oerror.NewTrace(err)
}
}
return nil
}