//
// DropCluster drops a cluster to the current database. It is a
// database-level operation, so OpenDatabase must have already
// been called first in order to start a session with the database.
// If nil is returned, then the action succeeded.
//
func DropCluster(dbc *DBClient, clusterName string) 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 DropClusterById(dbc, clusterID)
return fmt.Errorf("No cluster with name %s is known in database %s\n", clusterName, dbc.currDB.Name)
}
err := writeCommandAndSessionId(dbc, REQUEST_DATACLUSTER_DROP)
if err != nil {
return oerror.NewTrace(err)
}
err = rw.WriteShort(dbc.buf, clusterID)
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)
}
delStatus, err := rw.ReadByte(dbc.conx)
if err != nil {
return oerror.NewTrace(err)
}
if delStatus != byte(1) {
return fmt.Errorf("Drop cluster action failed. Return code from server was not '1', but %d",
delStatus)
}
return 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
}
//
// AddCluster adds a cluster to the current database. It is a
// database-level operation, so OpenDatabase must have already
// been called first in order to start a session with the database.
// The clusterID is returned if the command is successful.
//
func AddCluster(dbc *DBClient, clusterName string) (clusterID int16, err error) {
dbc.buf.Reset()
err = writeCommandAndSessionId(dbc, REQUEST_DATACLUSTER_ADD)
if err != nil {
return int16(0), oerror.NewTrace(err)
}
cname := strings.ToLower(clusterName)
err = rw.WriteString(dbc.buf, cname)
if err != nil {
return int16(0), oerror.NewTrace(err)
}
err = rw.WriteShort(dbc.buf, -1) // -1 means generate new cluster id
if err != nil {
return int16(0), oerror.NewTrace(err)
}
// send to the OrientDB server
_, err = dbc.conx.Write(dbc.buf.Bytes())
if err != nil {
return int16(0), oerror.NewTrace(err)
}
/* ---[ Read Response ]--- */
err = readStatusCodeAndSessionId(dbc)
if err != nil {
return int16(0), oerror.NewTrace(err)
}
clusterID, err = rw.ReadShort(dbc.conx)
if err != nil {
return clusterID, oerror.NewTrace(err)
}
dbc.currDB.Clusters = append(dbc.currDB.Clusters, OCluster{cname, clusterID})
return clusterID, err
}
//
// 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
}
//
// FetchRecordByRID takes an ORID and reads that record from the database.
// NOTE: for now I'm assuming all records are Documents (they can also be "raw bytes" or "flat data")
// and for some reason I don't understand, multiple records can be returned, so I'm returning
// a slice of ODocument
//
// TODO: may also want to expose options: ignoreCache, loadTombstones bool
// TODO: need to properly handle fetchPlan
func FetchRecordByRID(dbc *DBClient, orid oschema.ORID, fetchPlan string) ([]*oschema.ODocument, error) {
dbc.buf.Reset()
err := writeCommandAndSessionId(dbc, REQUEST_RECORD_LOAD)
if err != nil {
return nil, oerror.NewTrace(err)
}
err = rw.WriteShort(dbc.buf, orid.ClusterID)
if err != nil {
return nil, oerror.NewTrace(err)
}
err = rw.WriteLong(dbc.buf, orid.ClusterPos)
if err != nil {
return nil, oerror.NewTrace(err)
}
err = rw.WriteString(dbc.buf, fetchPlan)
if err != nil {
return nil, oerror.NewTrace(err)
}
ignoreCache := true // hardcoding for now
err = rw.WriteBool(dbc.buf, ignoreCache)
if err != nil {
return nil, oerror.NewTrace(err)
}
loadTombstones := false // hardcoding for now
err = rw.WriteBool(dbc.buf, loadTombstones)
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)
}
// this query can return multiple records (though I don't understand why)
// so must do this in a loop
docs := make([]*oschema.ODocument, 0, 1)
for {
payloadStatus, err := rw.ReadByte(dbc.conx)
if err != nil {
return nil, oerror.NewTrace(err)
}
if payloadStatus == byte(0) {
break
}
rectype, err := rw.ReadByte(dbc.conx)
if err != nil {
return nil, oerror.NewTrace(err)
}
recversion, err := rw.ReadInt(dbc.conx)
if err != nil {
return nil, oerror.NewTrace(err)
}
databytes, err := rw.ReadBytes(dbc.conx)
if err != nil {
return nil, oerror.NewTrace(err)
}
ogl.Debugf("rectype:%v, recversion:%v, len(databytes):%v\n", rectype, recversion, len(databytes))
if rectype == 'd' {
// we don't know the classname so set empty value
doc := oschema.NewDocument("")
doc.RID = orid
doc.Version = recversion
// the first byte specifies record serialization version
// use it to look up serializer
serde := dbc.RecordSerDes[int(databytes[0])]
// then strip off the version byte and send the data to the serde
err = serde.Deserialize(dbc, doc, obuf.NewReadBuffer(databytes[1:]))
if err != nil {
return nil, fmt.Errorf("ERROR in Deserialize for rid %v: %v\n", orid, err)
}
docs = append(docs, doc)
} else {
return nil,
fmt.Errorf("Only `document` records are currently supported by the client. Record returned was type: %v", rectype)
}
}
return docs, 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
}
//
// loadConfigRecord loads record #0:0 for the current database, caching
// some of the information returned into OStorageConfiguration
//
func loadConfigRecord(dbc *DBClient) (schemaRID string, err error) {
// The config record comes back as type 'b' (raw bytes), which should
// just be converted to a string then tokenized by the pipe char
dbc.buf.Reset()
var (
clusterId int16
clusterPos int64
)
err = writeCommandAndSessionId(dbc, REQUEST_RECORD_LOAD)
if err != nil {
return schemaRID, err
}
clusterId = 0
err = rw.WriteShort(dbc.buf, clusterId)
if err != nil {
return schemaRID, err
}
clusterPos = 0
err = rw.WriteLong(dbc.buf, clusterPos)
if err != nil {
return schemaRID, err
}
fetchPlan := "*:-1 index:0"
err = rw.WriteString(dbc.buf, fetchPlan)
if err != nil {
return schemaRID, err
}
ignoreCache := true
err = rw.WriteBool(dbc.buf, ignoreCache)
if err != nil {
return schemaRID, err
}
loadTombstones := true // based on Java client code
err = rw.WriteBool(dbc.buf, loadTombstones)
if err != nil {
return schemaRID, err
}
// send to the OrientDB server
_, err = dbc.conx.Write(dbc.buf.Bytes())
if err != nil {
return schemaRID, err
}
/* ---[ Read Response ]--- */
err = readStatusCodeAndSessionId(dbc)
if err != nil {
return schemaRID, err
}
payloadStatus, err := rw.ReadByte(dbc.conx)
if err != nil {
return schemaRID, err
}
if payloadStatus == byte(0) {
return schemaRID, errors.New("Payload status for #0:0 load was 0. No config data returned.")
}
rectype, err := rw.ReadByte(dbc.conx)
if err != nil {
return schemaRID, err
}
// this is the record version - don't see a reason to check or cache it right now
_, err = rw.ReadInt(dbc.conx)
if err != nil {
return schemaRID, err
}
databytes, err := rw.ReadBytes(dbc.conx)
if err != nil {
return schemaRID, err
}
if rectype != 'b' {
if err != nil {
return schemaRID, fmt.Errorf("Expected rectype %d, but was: %d", 'b', rectype)
}
}
payloadStatus, err = rw.ReadByte(dbc.conx)
if err != nil {
return schemaRID, err
}
if payloadStatus != byte(0) {
return schemaRID,
errors.New("Second Payload status for #0:0 load was not 0. More than one record returned unexpectedly")
}
err = parseConfigRecord(dbc.currDB, string(databytes))
if err != nil {
return schemaRID, err
}
schemaRID = dbc.currDB.StorageCfg.schemaRID
return schemaRID, err
}
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
}
//
// 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
}