public override ODocument Response(Response response)
{
ODocument document = new ODocument();
if (response == null)
{
return document;
}
var reader = response.Reader;
if (response.Connection.ProtocolVersion > 26 && response.Connection.UseTokenBasedSession)
ReadToken(reader);
// operation specific fields
byte existByte = reader.ReadByte();
if (existByte == 0)
{
document.SetField("Exists", false);
}
else
{
document.SetField("Exists", true);
}
return document;
}
public ODocument Response(Response response)
{
ODocument document = new ODocument();
if (response == null)
{
return document;
}
var reader = response.Reader;
// operation specific fields
byte existByte = reader.ReadByte();
if (existByte == 0)
{
document.SetField("Exists", false);
}
else
{
document.SetField("Exists", true);
}
return document;
}
public ODocument Response(Response response)
{
// start from this position since standard fields (status, session ID) has been already parsed
int offset = 5;
ODocument document = new ODocument();
if (response == null)
{
return document;
}
// operation specific fields
byte existByte = BinarySerializer.ToByte(response.Data.Skip(offset).Take(1).ToArray());
offset += 1;
if (existByte == 0)
{
document.SetField("Exists", false);
}
else
{
document.SetField("Exists", true);
}
return document;
}
public void ShouldRetrieveRecordMetadata()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
database
.Create
.Class("TestClass")
.Run();
var document = new ODocument();
document.OClassName = "TestClass";
document.SetField("bar", 12345);
document.SetField("foo", "foo value 345");
var createdDocument = database
.Create
.Document(document)
.Run();
var metadata = database
.Metadata
.ORID(createdDocument.ORID)
.Run();
Assert.IsNotNull(metadata);
Assert.AreEqual(createdDocument.ORID, metadata.ORID);
Assert.AreEqual(createdDocument.OVersion, metadata.OVersion);
}
}
}
public ODocument Response(Response response)
{
// start from this position since standard fields (status, session ID) has been already parsed
int offset = 5;
ODocument document = new ODocument();
if (response == null)
{
return document;
}
// operation specific fields
document.SetField("SessionId", BinarySerializer.ToInt(response.Data.Skip(offset).Take(4).ToArray()));
offset += 4;
short clusterCount = BinarySerializer.ToShort(response.Data.Skip(offset).Take(2).ToArray());
document.SetField("ClusterCount", clusterCount);
offset += 2;
if (clusterCount > 0)
{
List<OCluster> clusters = new List<OCluster>();
for (int i = 1; i <= clusterCount; i++)
{
OCluster cluster = new OCluster();
int clusterNameLength = BinarySerializer.ToInt(response.Data.Skip(offset).Take(4).ToArray());
offset += 4;
cluster.Name = BinarySerializer.ToString(response.Data.Skip(offset).Take(clusterNameLength).ToArray());
offset += clusterNameLength;
cluster.Id = BinarySerializer.ToShort(response.Data.Skip(offset).Take(2).ToArray());
offset += 2;
int clusterTypeLength = BinarySerializer.ToInt(response.Data.Skip(offset).Take(4).ToArray());
offset += 4;
string clusterName = BinarySerializer.ToString(response.Data.Skip(offset).Take(clusterTypeLength).ToArray());
cluster.Type = (OClusterType)Enum.Parse(typeof(OClusterType), clusterName, true);
offset += clusterTypeLength;
cluster.DataSegmentID = BinarySerializer.ToShort(response.Data.Skip(offset).Take(2).ToArray());
offset += 2;
clusters.Add(cluster);
}
document.SetField("Clusters", clusters);
}
int clusterConfigLength = BinarySerializer.ToInt(response.Data.Skip(offset).Take(4).ToArray());
offset += 4;
document.SetField("ClusterConfig", response.Data.Skip(offset).Take(clusterConfigLength).ToArray());
offset += clusterConfigLength;
return document;
}
public void ShouldUpdateClassFromDocument()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
// prerequisites
database
.Create.Class("TestClass")
.Run();
ODocument document = new ODocument();
document.OClassName = "TestClass";
document
.SetField("foo", "foo string value")
.SetField("bar", 12345);
database
.Insert(document)
.Run();
database
.Insert(document)
.Run();
document
.SetField("bar", 54321)
.SetField("baz", "new baz value");
int documentsUpdated = database
.Update(document)
.Run();
Assert.AreEqual(documentsUpdated, 2);
List<ODocument> documents = database
.Select()
.From("TestClass")
.ToList();
Assert.AreEqual(documents.Count, 2);
for (int i = 0; i < documents.Count; i++)
{
Assert.IsTrue(documents[i].ORID != null);
Assert.AreEqual(documents[i].OClassName, document.OClassName);
Assert.AreEqual(documents[i].GetField<string>("foo"), document.GetField<string>("foo"));
Assert.AreEqual(documents[i].GetField<int>("bar"), document.GetField<int>("bar"));
Assert.AreEqual(documents[i].GetField<string>("baz"), document.GetField<string>("baz"));
}
}
}
}
public override ODocument Response(Response response)
{
ODocument document = new ODocument();
if (response == null)
{
return document;
}
var reader = response.Reader;
if (response.Connection.ProtocolVersion > 26 && response.Connection.UseTokenBasedSession)
ReadToken(reader);
short clusterCount = reader.ReadInt16EndianAware();
document.SetField("ClusterCount", clusterCount);
if (clusterCount > 0)
{
List<OCluster> clusters = new List<OCluster>();
for (int i = 1; i <= clusterCount; i++)
{
OCluster cluster = new OCluster();
int clusterNameLength = reader.ReadInt32EndianAware();
cluster.Name = System.Text.Encoding.Default.GetString(reader.ReadBytes(clusterNameLength));
cluster.Id = reader.ReadInt16EndianAware();
if (OClient.ProtocolVersion < 24)
{
int clusterTypeLength = reader.ReadInt32EndianAware();
string clusterType = System.Text.Encoding.Default.GetString(reader.ReadBytes(clusterTypeLength));
//cluster.Type = (OClusterType)Enum.Parse(typeof(OClusterType), clusterType, true);
if (OClient.ProtocolVersion >= 12)
cluster.DataSegmentID = reader.ReadInt16EndianAware();
else
cluster.DataSegmentID = 0;
}
clusters.Add(cluster);
}
document.SetField("Clusters", clusters);
}
return document;
}
public void CreateVertexWithHeavyEdgeTX()
{
var v1 = new ODocument { OClassName = "TestVertex" };
v1.SetField("Name", "First");
v1.SetField("Bar", 1);
var v2 = new ODocument { OClassName = "TestVertex" };
v2.SetField("Name", "Second");
v2.SetField("Bar", 2);
var e1 = new ODocument { OClassName = "TestEdge" };
e1.SetField("Weight", 1.3f);
// Add records to the transaction
_database.Transaction.Add(v1);
_database.Transaction.Add(v2);
_database.Transaction.Add(e1);
// link records
v1.SetField("in_TestEdge", e1.ORID);
v2.SetField("out_TestEdge", e1.ORID);
e1.SetField("in", v1.ORID);
e1.SetField("out", v2.ORID);
_database.Transaction.Commit();
Assert.NotNull(v1.ORID);
Assert.NotNull(v2.ORID);
Assert.NotNull(e1.ORID);
var lv1 = _database.Load.ORID(v1.ORID).Run();
var lv2 = _database.Load.ORID(v2.ORID).Run();
var le1 = _database.Load.ORID(e1.ORID).Run();
Assert.Equal(v1.GetField<string>("Name"), lv1.GetField<string>("Name"));
Assert.Equal(v1.GetField<int>("Bar"), lv1.GetField<int>("Bar"));
Assert.Equal(v2.GetField<string>("Name"), lv2.GetField<string>("Name"));
Assert.Equal(v2.GetField<int>("Bar"), lv2.GetField<int>("Bar"));
Assert.Equal(e1.GetField<float>("Weight"), le1.GetField<float>("Weight"));
Assert.Equal(e1.ORID, lv1.GetField<ORID>("in_TestEdge"));
Assert.Equal(e1.ORID, lv2.GetField<ORID>("out_TestEdge"));
Assert.Equal(v1.ORID, le1.GetField<ORID>("in"));
Assert.Equal(v2.ORID, le1.GetField<ORID>("out"));
}
public ODocument Range()
{
var document = new ODocument();
foreach (var cluster in _clusterIds)
{
var operation = new DataClusterDataRange(_connection.Database);
operation.ClusterId = cluster.Id;
var d = _connection.ExecuteOperation(operation);
if (!string.IsNullOrEmpty(cluster.Name))
document.SetField<ODocument>(cluster.Name, d.GetField<ODocument>("Content"));
else
document.SetField<ODocument>(cluster.Id.ToString(), d.GetField<ODocument>("Content"));
}
return document;
}
public override ODocument Response(Response response)
{
ODocument responseDocument = new ODocument();
var reader = response.Reader;
if (response.Connection.ProtocolVersion > 26 && response.Connection.UseTokenBasedSession)
ReadToken(reader);
var createdRecordMapping = new Dictionary<ORID, ORID>();
int recordCount = reader.ReadInt32EndianAware();
for (int i = 0; i < recordCount; i++)
{
var tempORID = ReadORID(reader);
var realORID = ReadORID(reader);
createdRecordMapping.Add(tempORID, realORID);
}
responseDocument.SetField("CreatedRecordMapping", createdRecordMapping);
int updatedCount = reader.ReadInt32EndianAware();
var updateRecordVersions = new Dictionary<ORID, int>();
for (int i = 0; i < updatedCount; i++)
{
var orid = ReadORID(reader);
var newVersion = reader.ReadInt32EndianAware();
updateRecordVersions.Add(orid, newVersion);
}
responseDocument.SetField("UpdatedRecordVersions", updateRecordVersions);
// Work around differents in storage type < version 2.0
if (_database.ProtocolVersion >= 28 || (_database.ProtocolVersion >= 20 && _database.ProtocolVersion <= 27 && !EndOfStream(reader)))
{
int collectionChanges = reader.ReadInt32EndianAware();
if (collectionChanges > 0)
throw new NotSupportedException("Processing of collection changes is not implemented. Failing rather than ignoring potentially significant data");
//for (int i = 0; i < collectionChanges; i++)
//{
// long mBitsOfId = reader.ReadInt64EndianAware();
// long lBitsOfId = reader.ReadInt64EndianAware();
// var updatedFileId = reader.ReadInt64EndianAware();
// var updatedPageIndex = reader.ReadInt64EndianAware();
// var updatedPageOffset = reader.ReadInt32EndianAware();
//}
}
return responseDocument;
}
public void ShouldFetchLinkedDocumentsFromSimpleQuery()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
database.Create.Class("Owner").Extends("V").Run();
database.Create.Class("Computer").Extends("V").Run();
var owner = new ODocument { OClassName = "Owner" };
owner.SetField<String>("name", "Shawn");
owner = database.Create.Vertex(owner).Run();
var computer = new ODocument { OClassName = "Computer" };
computer.SetField<ORID>("owner", owner.ORID);
database.Create.Vertex(computer).Run();
computer = database.Query("SELECT FROM Computer", "*:-1").FirstOrDefault();
Assert.That(database.ClientCache.ContainsKey(computer.GetField<ORID>("owner")));
var document = database.ClientCache[computer.GetField<ORID>("owner")];
Assert.That(document.GetField<string>("name"), Is.EqualTo("Shawn"));
}
}
//[Fact]
public void ShouldDeserializeWholeStructure()
{
/*
The whole record is structured in three main segments
+---------------+------------------+---------------+-------------+
| version:byte | className:string | header:byte[] | data:byte[] |
+---------------+------------------+---------------+-------------+
*/
//byte version = 0;
byte[] className = Encoding.UTF8.GetBytes("TestClass");
byte[] header = new byte[0];
byte[] data = new byte[0];
//string serString = "ABJUZXN0Q2xhc3MpAAAAEQDI/wE=";
string serString1 = "AAxQZXJzb24EaWQAAABEBwhuYW1lAAAAaQcOc3VybmFtZQAAAHAHEGJpcnRoZGF5AAAAdwYQY2hpbGRyZW4AAAB9AQBIZjk1M2VjNmMtNGYyMC00NDlhLWE2ODQtYjQ2ODkxNmU4NmM3DEJpbGx5MQxNYXllczGUlfWVo1IC/wE=";
var document = new ODocument();
document.OClassName = "TestClass";
document.SetField<DateTime>("_date", DateTime.Now);
var createdDocument = database
.Create
.Document(document)
.Run();
Assert.Equal(document.GetField<DateTime>("_date").Date, createdDocument.GetField<DateTime>("eeee"));
var serBytes1 = Convert.FromBase64String(serString1);
var doc = serializer.Deserialize(serBytes1, new ODocument());
}
public void ShouldCreateVertexFromDocument()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
// prerequisites
database
.Create.Class("TestVertexClass")
.Extends<OVertex>()
.Run();
ODocument document = new ODocument();
document.OClassName = "TestVertexClass";
document
.SetField("foo", "foo string value")
.SetField("bar", 12345);
OVertex createdVertex = database
.Create.Vertex(document)
.Run();
Assert.IsNotNull(createdVertex.ORID);
Assert.AreEqual("TestVertexClass", createdVertex.OClassName);
Assert.AreEqual(document.GetField<string>("foo"), createdVertex.GetField<string>("foo"));
Assert.AreEqual(document.GetField<int>("bar"), createdVertex.GetField<int>("bar"));
}
}
}
public void ShouldCreateDocumentClassSet()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
// prerequisites
database
.Create.Class("TestClass")
.Run();
ODocument document = new ODocument();
document.OClassName = "TestClass";
document
.SetField("foo", "foo string value")
.SetField("bar", 12345);
ODocument createdDocument = database
.Create.Document("TestClass")
.Set(document)
.Run();
Assert.NotNull(createdDocument.ORID);
Assert.Equal("TestClass", createdDocument.OClassName);
Assert.Equal(document.GetField<string>("foo"), createdDocument.GetField<string>("foo"));
Assert.Equal(document.GetField<int>("bar"), createdDocument.GetField<int>("bar"));
}
}
}
public override ODocument Response(Response response)
{
Dictionary<ORID, int> entries = new Dictionary<ORID, int>();
ODocument document = new ODocument();
if (response == null)
{
return document;
}
var reader = response.Reader;
if (response.Connection.ProtocolVersion > 26 && response.Connection.UseTokenBasedSession)
ReadToken(reader);
// (count:int)[(key:binary)(value:binary)]
var bytesLength = reader.ReadInt32EndianAware();
var count = reader.ReadInt32EndianAware();
for (int i = 0; i < count; i++)
{
// key
short clusterId = reader.ReadInt16EndianAware();
long clusterPosition = reader.ReadInt64EndianAware();
var rid = new ORID(clusterId, clusterPosition);
// value
var value = reader.ReadInt32EndianAware();
entries.Add(rid, value);
}
document.SetField<Dictionary<ORID, int>>("entries", entries);
return document;
}
private OCommandResult RunInternal()
{
try
{
if (_parameters == null)
throw new ArgumentNullException("_parameters");
var paramsDocument = new ODocument();
paramsDocument.OClassName = "";
paramsDocument.SetField(OClient.ProtocolVersion < 22 ? "params" : "parameters", _parameters);
var serializer = RecordSerializerFactory.GetSerializer(_connection.Database);
CommandPayloadCommand payload = new CommandPayloadCommand();
payload.Text = ToString();
payload.SimpleParams = serializer.Serialize(paramsDocument);
Command operation = new Command(_connection.Database);
operation.OperationMode = OperationMode.Synchronous;
operation.CommandPayload = payload;
ODocument document = _connection.ExecuteOperation(operation);
return new OCommandResult(document);
}
finally
{
_parameters = null;
}
}
public override ODocument Response(Response response)
{
ODocument document = new ODocument();
if (response == null)
{
return document;
}
var reader = response.Reader;
if (response.Connection.ProtocolVersion > 26 && response.Connection.UseTokenBasedSession)
ReadToken(reader);
short len = reader.ReadInt16EndianAware();
Dictionary<string, string> configList = new Dictionary<string, string>();
for (int i = 0; i < len; i++)
{
string key = reader.ReadInt32PrefixedString();
string value = reader.ReadInt32PrefixedString();
configList.Add(key, value);
}
document.SetField<Dictionary<string, string>>("config", configList);
return document;
}
public void ShouldInsertDocument()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
// prerequisites
database
.Create.Class("TestClass")
.Run();
ODocument document = new ODocument();
document.OClassName = "TestClass";
document
.SetField("foo", "foo string value")
.SetField("bar", 12345);
ODocument insertedDocument = database
.Insert(document)
.Run();
Assert.IsTrue(insertedDocument.ORID != null);
Assert.AreEqual(insertedDocument.OClassName, "TestClass");
Assert.AreEqual(insertedDocument.GetField<string>("foo"), document.GetField<string>("foo"));
Assert.AreEqual(insertedDocument.GetField<int>("bar"), document.GetField<int>("bar"));
}
}
}
//[Fact]
public void ShouldSerializeDocumnet()
{
//string serString = "ABJUZXN0Q2xhc3MpAAAAEQDI/wE=";
ODocument document = new ODocument();
document.OClassName = "TestClass";
document.SetField<DateTime>("eeee", new DateTime(635487552000000000));
var str = Convert.ToBase64String(serializer.Serialize(document));
}
public void ShouldUpdateOridSet()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
// prerequisites
database
.Create.Class("TestClass")
.Run();
ODocument document = new ODocument();
document.OClassName = "TestClass";
document
.SetField("foo", "foo string value")
.SetField("bar", 12345);
ODocument document1 = database
.Insert(document)
.Run();
ODocument document2 = database
.Insert(document)
.Run();
document2
.SetField("bar", 54321)
.SetField("baz", "new baz value");
int documentsUpdated = database
.Update(document2.ORID)
.Set(document2)
.Run();
Assert.AreEqual(documentsUpdated, 1);
List <ODocument> documents = database
.Select()
.From("TestClass")
.Where("bar").Equals(54321)
.ToList();
Assert.AreEqual(documents.Count, 1);
for (int i = 0; i < documents.Count; i++)
{
Assert.AreEqual(documents[i].ORID, document2.ORID);
Assert.AreEqual(documents[i].OClassName, document2.OClassName);
Assert.AreEqual(documents[i].GetField <string>("foo"), document2.GetField <string>("foo"));
Assert.AreEqual(documents[i].GetField <int>("bar"), document2.GetField <int>("bar"));
Assert.AreEqual(documents[i].GetField <string>("baz"), document2.GetField <string>("baz"));
}
}
}
}
private void ReadPrimaryResult(ODocument responseDocument, BinaryReader reader)
{
responseDocument.SetField("PayloadStatus", PayloadStatus.SingleRecord);
var contentLength = reader.ReadInt32EndianAware();
byte[] readBytes = reader.ReadBytes(contentLength);
var version = reader.ReadInt32EndianAware();
var recordType = reader.ReadByte();
string serialized = System.Text.Encoding.Default.GetString(readBytes);
var document = RecordSerializer.Deserialize(serialized);
document.ORID = _orid;
document.OVersion = version;
//document.OType = type;
//document.OClassId = classId;
responseDocument.SetField("Content", document);
}
public ODocument Range()
{
var document = new ODocument();
foreach (var cluster in _clusterIds)
{
var operation = new DataClusterDataRange(_connection.Database);
operation.ClusterId = cluster.Id;
var d = _connection.ExecuteOperation(operation);
if (!string.IsNullOrEmpty(cluster.Name))
{
document.SetField <ODocument>(cluster.Name, d.GetField <ODocument>("Content"));
}
else
{
document.SetField <ODocument>(cluster.Id.ToString(), d.GetField <ODocument>("Content"));
}
}
return(document);
}
public ODocument Response(Response response)
{
ODocument document = new ODocument();
if (response == null)
{
return document;
}
if (response.Status == ResponseStatus.OK)
{
document.SetField("IsCreated", true);
}
else
{
document.SetField("IsCreated", true);
}
return document;
}
public override ODocument Response(Response response)
{
ODocument document = new ODocument();
if (response == null)
{
return(document);
}
var reader = response.Reader;
var begin = reader.ReadInt64EndianAware();
var end = reader.ReadInt64EndianAware();
var embededDoc = new ODocument();
embededDoc.SetField("begin", begin);
embededDoc.SetField("end", end);
document.SetField <ODocument>("Content", embededDoc);
return(document);
}
public override ODocument Response(Response response)
{
ODocument document = new ODocument();
if (response == null)
{
return(document);
}
if (response.Status == ResponseStatus.OK)
{
document.SetField("IsCreated", true);
}
else
{
document.SetField("IsCreated", true);
}
return(document);
}
public override void MapToDocument(TTarget typedObject, ODocument document)
{
var source = (ODocument)(object)typedObject;
if (source != null)
{
foreach (KeyValuePair <string, object> item in source)
{
document.SetField(item.Key, item.Value);
}
}
}
public override ODocument Response(Response response)
{
ODocument document = new ODocument();
if (response == null)
{
return document;
}
var reader = response.Reader;
if (response.Connection.ProtocolVersion > 26 && response.Connection.UseTokenBasedSession)
ReadToken(reader);
var begin = reader.ReadInt64EndianAware();
var end = reader.ReadInt64EndianAware();
var embededDoc = new ODocument();
embededDoc.SetField("begin", begin);
embededDoc.SetField("end", end);
document.SetField<ODocument>("Content", embededDoc);
return document;
}
public void ShouldUpdateRecord()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GLOBAL_TEST_DATABASE_ALIAS))
{
// prerequisites
database
.Create.Class("TestClass")
.Run();
ODocument document = new ODocument();
document.OClassName = "TestClass";
document
.SetField("foo", "foo string value")
.SetField("bar", 12345);
ODocument document1 = database
.Insert(document)
.Run();
ODocument document2 = database
.Insert(document)
.Run();
ODocument docToUpdate = new ODocument()
.SetField("bar", 54321)
.SetField("baz", "new baz value");
int documentsUpdated = database
.Update(docToUpdate)
.Record(document2.ORID)
.Run();
Assert.AreEqual(documentsUpdated, 1);
List <ODocument> documents = database
.Select()
.From("TestClass")
.Where("bar").Equals(54321)
.ToList();
Assert.AreEqual(documents.Count, 1);
Assert.AreEqual(documents[0].ORID, document2.ORID);
Assert.AreEqual(documents[0].OClassName, document2.OClassName);
Assert.AreEqual(documents[0].GetField <string>("foo"), document2.GetField <string>("foo"));
Assert.AreEqual(documents[0].GetField <int>("bar"), docToUpdate.GetField <int>("bar"));
Assert.AreEqual(documents[0].GetField <string>("baz"), docToUpdate.GetField <string>("baz"));
}
}
}
public void CSVSerializerShouldSupportDecimalValues()
{
var document = new ODocument();
document.OClassName = "DemoEmployee";
document.SetField("Min", decimal.MinValue);
document.SetField("Max", decimal.MaxValue);
var createdDocument = _database.Create.Document("DemoEmployee")
.Set(document)
.Run();
var loadedDocument = _database.Load.ORID(createdDocument.ORID).Run();
Assert.NotNull(createdDocument);
Assert.Equal(createdDocument.GetField<decimal>("Min"), decimal.MinValue);
Assert.Equal(createdDocument.GetField<decimal>("Max"), decimal.MaxValue);
Assert.NotNull(loadedDocument);
Assert.Equal(loadedDocument.GetField<decimal>("Min"), decimal.MinValue);
Assert.Equal(loadedDocument.GetField<decimal>("Max"), decimal.MaxValue);
}
private void appendOridToField(ODocument document, string field, ORID orid)
{
if (document.HasField(field))
{
document.GetField <HashSet <ORID> >(field).Add(orid);
}
else
{
var orids = new HashSet <ORID>();
orids.Add(orid);
document.SetField(field, orids);
}
}
public ODocument Response(Response response)
{
// start from this position since standard fields (status, session ID) has been already parsed
//int offset = 5;
ODocument document = new ODocument();
if (response == null)
{
return(document);
}
if (response.Status == ResponseStatus.OK)
{
document.SetField("IsCreated", true);
}
else
{
document.SetField("IsCreated", true);
}
return(document);
}
public void CSVSerializerShouldSupportDecimalValues()
{
var document = new ODocument();
document.OClassName = "DemoEmployee";
document.SetField("Min", decimal.MinValue);
document.SetField("Max", decimal.MaxValue);
var createdDocument = _database.Create.Document("DemoEmployee")
.Set(document)
.Run();
var loadedDocument = _database.Load.ORID(createdDocument.ORID).Run();
Assert.That(createdDocument, Is.Not.Null);
Assert.That(createdDocument.GetField <decimal>("Min"), Is.EqualTo(decimal.MinValue));
Assert.That(createdDocument.GetField <decimal>("Max"), Is.EqualTo(decimal.MaxValue));
Assert.That(loadedDocument, Is.Not.Null);
Assert.That(loadedDocument.GetField <decimal>("Min"), Is.EqualTo(decimal.MinValue));
Assert.That(loadedDocument.GetField <decimal>("Max"), Is.EqualTo(decimal.MaxValue));
}
public ODocument Response(Response response)
{
// start from this position since standard fields (status, session ID) has been already parsed
//int offset = 5;
ODocument document = new ODocument();
if (response == null)
{
return document;
}
if (response.Status == ResponseStatus.OK)
{
document.SetField("IsCreated", true);
}
else
{
document.SetField("IsCreated", true);
}
return document;
}
public override ODocument Response(Response response)
{
ODocument document = new ODocument();
if (response == null)
{
return document;
}
var reader = response.Reader;
var sessionId = reader.ReadInt32EndianAware();
document.SetField("SessionId", sessionId);
if (response.Connection.ProtocolVersion > 26)
{
var size = reader.ReadInt32EndianAware();
var token = reader.ReadBytesRequired(size);
var t = OToken.Parse(token);
document.SetField("Token", token);
}
return document;
}
public ODocument Response(Response response)
{
ODocument document = new ODocument();
if (response == null)
{
return document;
}
BinaryReader reader = response.Reader;
string value = reader.ReadInt32PrefixedString();
document.SetField(ConfigKey, value);
return document;
}
public void ShouldSelectUntyped()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
string className = "TestVertexClass";
ODocument document1 = new ODocument();
document1
.SetField("foo", "foo string value1")
.SetField("bar", 12345);
ODocument document2 = new ODocument();
document2
.SetField("foo", "foo string value2")
.SetField("bar", 54321);
// create test class
database
.Create.Class("TestVertexClass")
.Extends("OGraphVertex")
.Run();
// load database with some testing data
database
.Create.Vertex(className)
.Set(document1)
.Run();
database
.Create.Vertex(className)
.Set(document2)
.Run();
// perform simple select
List<ORecord> result = database
.Select("foo", "bar")
.From("TestVertexClass")
.ToList();
Assert.AreEqual(result.Count, 2);
Assert.AreEqual(result[0].GetField<string>("foo"), document1.GetField<string>("foo"));
Assert.AreEqual(result[0].GetField<int>("bar"), document1.GetField<int>("bar"));
Assert.AreEqual(result[1].GetField<string>("foo"), document2.GetField<string>("foo"));
Assert.AreEqual(result[1].GetField<int>("bar"), document2.GetField<int>("bar"));
}
}
}
public override void MapToDocument(TTarget typedObject, ODocument document)
{
var targetElementType = _needsMapping ? typeof(ODocument) : _targetElementType;
var listType = typeof(List <>).MakeGenericType(targetElementType);
var targetList = (IList)Activator.CreateInstance(listType);
var sourceList = (IEnumerable)GetPropertyValue(typedObject);
foreach (var item in sourceList)
{
targetList.Add(_needsMapping ? _mapper.ToDocument(item) : item);
}
document.SetField(_fieldPath, targetList);
}
public override ODocument Response(Response response)
{
ODocument document = new ODocument();
if (response == null)
{
return document;
}
var reader = response.Reader;
if (response.Connection.ProtocolVersion > 26 && response.Connection.UseTokenBasedSession)
ReadToken(reader);
if (response.Status == ResponseStatus.OK)
{
document.SetField("IsCreated", true);
}
else
{
document.SetField("IsCreated", true);
}
return document;
}
public override ODocument Response(Response response)
{
ODocument document = new ODocument();
if (response == null)
{
return(document);
}
var reader = response.Reader;
var sessionId = reader.ReadInt32EndianAware();
document.SetField("SessionId", sessionId);
if (response.Connection.ProtocolVersion > 26)
{
var size = reader.ReadInt32EndianAware();
var token = reader.ReadBytesRequired(size);
var t = OToken.Parse(token);
document.SetField("Token", token);
}
return(document);
}
public ODocument Response(Response response)
{
ODocument document = new ODocument();
if (response == null)
{
return document;
}
var reader = response.Reader;
// operation specific fields
var sessionId = reader.ReadInt32EndianAware();
document.SetField("SessionId", sessionId);
if (OClient.ProtocolVersion > 25)
{
var len = reader.ReadInt32EndianAware();
var tokenBytes = new byte[len];
reader.Read(tokenBytes, 0, len);
document.SetField("Token", ASCIIEncoding.ASCII.GetString(tokenBytes));
}
return document;
}
public ODocument Response(Response response)
{
ODocument document = new ODocument();
if (response == null)
{
return(document);
}
BinaryReader reader = response.Reader;
string value = reader.ReadInt32PrefixedString();
document.SetField(ConfigKey, value);
return(document);
}
public ODocument Response(Response response)
{
ODocument responseDocument = new ODocument();
var reader = response.Reader;
var createdRecordMapping = new Dictionary<ORID, ORID>();
int recordCount = reader.ReadInt32EndianAware();
for (int i = 0; i < recordCount; i++)
{
var tempORID = ReadORID(reader);
var realORID = ReadORID(reader);
createdRecordMapping.Add(tempORID, realORID);
}
responseDocument.SetField("CreatedRecordMapping", createdRecordMapping);
int updatedCount = reader.ReadInt32EndianAware();
var updateRecordVersions = new Dictionary<ORID, int>();
for (int i = 0; i < updatedCount; i++)
{
var orid = ReadORID(reader);
var newVersion = reader.ReadInt32EndianAware();
updateRecordVersions.Add(orid, newVersion);
}
responseDocument.SetField("UpdatedRecordVersions", updateRecordVersions);
if (OClient.ProtocolVersion >= 20)
{
try//if (reader.BaseStream.CanRead && reader.PeekChar() != -1)
{
int collectionChangesCount = reader.ReadInt32EndianAware();
for (var i = 0; i < collectionChangesCount; i++)
{
// throw new NotImplementedException("don't understand what to do with this yet");
long mBitsOfId = reader.ReadInt64EndianAware();
long lBitsOfId = reader.ReadInt64EndianAware();
var updatedFileId = reader.ReadInt64EndianAware();
var updatedPageIndex = reader.ReadInt64EndianAware();
var updatedPageOffset = reader.ReadInt32EndianAware();
}
}
catch (Exception ex)
{
}
}
return responseDocument;
}
public override ODocument Response(Response response)
{
ODocument document = new ODocument();
if (response == null)
{
return(document);
}
var reader = response.Reader;
var clusterid = reader.ReadInt16EndianAware();
document.SetField <short>("clusterid", clusterid);
return(document);
}
public ODocument Response(Response response)
{
ODocument document = new ODocument();
if (response == null)
{
return document;
}
var reader = response.Reader;
// operation specific fields
document.SetField("SessionId", reader.ReadInt32EndianAware());
return document;
}
public override ODocument Response(Response response)
{
ODocument document = new ODocument();
if (response == null)
{
return(document);
}
var reader = response.Reader;
var size = reader.ReadInt64EndianAware();
document.SetField <long>("size", size);
return(document);
}
public override ODocument Response(Response response)
{
ODocument document = new ODocument();
if (response == null)
{
return(document);
}
var reader = response.Reader;
var b = reader.ReadByte();
var removeLocaly = b == 1 ? true : false;
document.SetField <bool>("remove_localy", removeLocaly);
return(document);
}
public ODocument Response(Response response)
{
ODocument document = new ODocument();
if (response == null)
{
return(document);
}
var reader = response.Reader;
// operation specific fields
document.SetField("SessionId", reader.ReadInt32EndianAware());
return(document);
}
public ODocument Response(Response response)
{
// start from this position since standard fields (status, session ID) has been already parsed
int offset = 5;
ODocument document = new ODocument();
if (response == null)
{
return(document);
}
// operation specific fields
document.SetField("SessionId", BinarySerializer.ToInt(response.Data.Skip(offset).Take(4).ToArray()));
offset += 4;
return(document);
}
private void ReadPrimaryResult(ODocument responseDocument, BinaryReader reader)
{
responseDocument.SetField("PayloadStatus", PayloadStatus.SingleRecord);
int contentLength;
byte[] readBytes;
int version;
ORecordType recordType;
if (OClient.ProtocolVersion < 28)
{
contentLength = reader.ReadInt32EndianAware();
readBytes = reader.ReadBytes(contentLength);
version = reader.ReadInt32EndianAware();
recordType = (ORecordType)reader.ReadByte();
}
else
{
recordType = (ORecordType)reader.ReadByte();
version = reader.ReadInt32EndianAware();
contentLength = reader.ReadInt32EndianAware();
readBytes = reader.ReadBytes(contentLength);
}
var document = new ODocument();
switch (recordType)
{
case ORecordType.Document:
document = Serializer.Deserialize(readBytes, new ODocument());
document.ORID = _orid;
document.OVersion = version;
responseDocument.SetField("Content", document);
break;
case ORecordType.RawBytes:
document.SetField("RawBytes", readBytes);
responseDocument.SetField("Content", document);
break;
case ORecordType.FlatData:
break;
}
}
public override ODocument Response(Response response)
{
ODocument document = new ODocument();
if (response == null)
{
return(document);
}
var reader = response.Reader;
// operation specific fields
document.SetField("SessionId", reader.ReadInt32EndianAware());
if (OClient.ProtocolVersion > 26)
{
var size = reader.ReadInt32EndianAware();
}
return(document);
}
public OCommandResult Run()
{
if (_simpleParams != null)
{
var paramsDocument = new ODocument();
paramsDocument.OClassName = "";
paramsDocument.SetField(OClient.ProtocolVersion < 22 ? "params" : "parameters", _simpleParams);
((CommandPayloadCommand)_payload).SimpleParams = RecordSerializerFactory.GetSerializer(_connection.Database).Serialize(paramsDocument);
}
Command operation = new Command(_connection.Database);
operation.OperationMode = OperationMode.Synchronous;
operation.CommandPayload = _payload;
ODocument document = _connection.ExecuteOperation(operation);
return(new OCommandResult(document));
}
public override void MapToDocument(TTarget typedObject, ODocument document)
{
var dictionaryType = typeof(Dictionary <,>).MakeGenericType(_keyType, _needsMapping ? typeof(ODocument) : _valueType);
var targetDictionary = (IDictionary)Activator.CreateInstance(dictionaryType);
var sourceList = (IDictionary)GetPropertyValue(typedObject);
if (sourceList != null)
{
var enumerator = sourceList.GetEnumerator();
while (enumerator.MoveNext())
{
targetDictionary.Add(enumerator.Key, _needsMapping ? _mapper.ToDocument(enumerator.Value) : enumerator.Value);
}
}
document.SetField(_fieldPath, targetDictionary);
}
public void ShouldGenerateUpdateWhereLimitQuery()
{
ODocument document = new ODocument();
document.ORID = new ORID(8, 0);
document
.SetField("foo", "foo string value")
.SetField("bar", 12345);
string generatedQuery = new OSqlUpdate()
.Update(document)
.Where("foo").Equals("whoa")
.Or("foo").NotEquals(123)
.And("foo").Lesser(1)
.And("foo").LesserEqual(2)
.And("foo").Greater(3)
.And("foo").GreaterEqual(4)
.And("foo").Like("%whoa%")
.And("foo").IsNull()
.And("foo").Contains("johny")
.And("foo").Contains("name", "johny")
.Limit(5)
.ToString();
string query =
"UPDATE #8:0 " +
"SET foo = 'foo string value', " +
"bar = 12345 " +
"WHERE foo = 'whoa' " +
"OR foo != 123 " +
"AND foo < 1 " +
"AND foo <= 2 " +
"AND foo > 3 " +
"AND foo >= 4 " +
"AND foo LIKE '%whoa%' " +
"AND foo IS NULL " +
"AND foo CONTAINS 'johny' " +
"AND foo CONTAINS (name = 'johny') " +
"LIMIT 5";
Assert.AreEqual(generatedQuery, query);
}
public void ShouldFetchDocumentsConnectedByEdges()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
// Need to set this
database.Command("alter database custom useLightweightEdges=true");
database.Create.Class("House").Extends("V").Run();
database.Create.Class("Person").Extends("V").Run();
database.Create.Class("Owns").Extends("E").Run();
var house = new ODocument {
OClassName = "House"
};
database.Create.Vertex(house).Run();
var person = new ODocument {
OClassName = "Person"
};
person.SetField("name", "Shawn");
database.Create.Vertex(person).Run();
var person1 = new ODocument {
OClassName = "Person"
};
person1.SetField("name", "Roman");
database.Create.Vertex(person1).Run();
database.Create.Edge("Owns").From(person).To(house).Run();
database.Create.Edge("Owns").From(person1).To(house).Run();
house = database.Query("select from House", "*:-1").FirstOrDefault();
Assert.True(house != null);
Assert.Equal(database.ClientCache.Count(), 2); // client cache should contain two records;
}
}
}
public override ODocument GetDocument()
{
ODocument doc = new ODocument();
doc.OClassName = "RedditModel";
doc.SetField("_id", _id);
doc.SetField("Message", Message);
doc.SetField("Date", Date);
doc.SetField("CreatedBy", CreatedBy);
doc.SetField("Upvotes", Upvotes);
doc.SetField("OP", new ODocument()
.SetField("Name", Op.Name)
.SetField("Age", Op.Age));
doc.SetField("Ids", Ids);
return(doc);
}
public void ShouldGenerateUpdateClassFromDocumentQuery()
{
ODocument document = new ODocument();
document.OClassName = "TestVertexClass";
document
.SetField("foo", "foo string value")
.SetField("bar", 12345);
string generatedQuery = new OSqlUpdate()
.Update(document)
.ToString();
string query =
"UPDATE TestVertexClass " +
"SET foo = 'foo string value', " +
"bar = 12345";
Assert.Equal(generatedQuery, query);
}
public void ShouldGenerateUpdateRecordFromDocumentQuery()
{
ODocument document = new ODocument();
document.ORID = new ORID(8, 0);
document
.SetField("foo", "foo string value")
.SetField("bar", 12345);
string generatedQuery = new OSqlUpdate()
.Update(document)
.ToString();
string query =
"UPDATE #8:0 " +
"SET foo = 'foo string value', " +
"bar = 12345";
Assert.AreEqual(generatedQuery, query);
}
public void ShouldGenerateCreateVertexFromDocumentQuery()
{
ODocument document = new ODocument();
document.OClassName = "TestVertexClass";
document
.SetField("foo", "foo string value")
.SetField("bar", 12345);
string generatedQuery = new OSqlCreateVertex()
.Vertex(document)
.ToString();
string query =
"CREATE VERTEX TestVertexClass " +
"SET foo = 'foo string value', " +
"bar = 12345";
Assert.AreEqual(generatedQuery, query);
}
public void ShouldGenerateInsertDocumentQuery()
{
ODocument document = new ODocument();
document.OClassName = "TestClass";
document
.SetField("foo", "foo string value")
.SetField("bar", 12345);
string generatedQuery = new OSqlInsert()
.Insert(document)
.ToString();
string query =
"INSERT INTO TestClass " +
"SET foo = 'foo string value', " +
"bar = 12345";
Assert.Equal(generatedQuery, query);
}
private void appendOridToField(ODocument document, string field, ORID orid)
{
if (document.HasField(field))
{
var oridCollection = document[field] as ICollection <ORID>;
if (oridCollection != null)
{
oridCollection.Add(orid);
}
else
{
((ICollection <object>)document[field]).Add(orid);
}
}
else
{
var orids = new HashSet <object>();
orids.Add(orid);
document.SetField(field, orids);
}
}
