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"));
}
}
public void ShouldSerializeSingleAndSetOfOrids()
{
string recordString = "Something@single:#10:12345,set:<#11:123,#22:1234,#33:1234567>,singleSet:<#44:44>";
var rawRecord = Encoding.UTF8.GetBytes(recordString);
ODocument document = serializer.Deserialize(rawRecord, new ODocument());
// check for fields existence
Assert.Equal(document.HasField("single"), true);
Assert.Equal(document.HasField("set"), true);
// check for fields values
Assert.Equal(document.GetField <ORID>("single"), new ORID(10, 12345));
HashSet <ORID> collection = document.GetField <HashSet <ORID> >("set");
Assert.Equal(collection.Count, 3);
Assert.True(collection.Contains(new ORID(11, 123)));
Assert.True(collection.Contains(new ORID(22, 1234)));
Assert.True(collection.Contains(new ORID(33, 1234567)));
HashSet <ORID> singleSet = document.GetField <HashSet <ORID> >("singleSet");
Assert.Equal(singleSet.Count, 1);
Assert.True(singleSet.Contains(new ORID(44, 44)));
var serialized = Encoding.UTF8.GetString(serializer.Serialize(document));
Assert.Equal(recordString, serialized);
}
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.IsTrue(createdVertex.ORID != null);
Assert.AreEqual(createdVertex.OClassName, "TestVertexClass");
Assert.AreEqual(createdVertex.GetField <string>("foo"), document.GetField <string>("foo"));
Assert.AreEqual(createdVertex.GetField <int>("bar"), document.GetField <int>("bar"));
}
}
}
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 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.True(database.ClientCache.ContainsKey(computer.GetField <ORID>("owner")));
var document = database.ClientCache[computer.GetField <ORID>("owner")];
Assert.Equal(document.GetField <string>("name"), "Shawn");
}
}
private void checkUpdateContentAssertions(ODocument document)
{
Assert.IsNotNull(document);
Assert.IsNotNull(document.ORID);
Assert.AreEqual(document.OClassName, "TestClass");
Assert.AreEqual("TestStringUpdated", document.GetField <string>("simpleString"));
Assert.IsFalse(document.HasField("embeddedObject"));
ODocument embeddedObject = document.GetField <ODocument>("embeddedObjectUpdated");
Assert.IsNotNull(embeddedObject);
Assert.IsTrue(embeddedObject.HasField("embeddedArrayOfObjects"));
List <ODocument> arrayOfObjects = embeddedObject.GetField <List <ODocument> >("embeddedArrayOfObjects");
Assert.AreEqual(3, arrayOfObjects.Count);
Assert.AreEqual("ValueA1Updated", arrayOfObjects[0].GetField <string>("stringPropertyUpdated"));
Assert.AreEqual(2, arrayOfObjects[1].GetField <int>("numericPropertyUpdated"));
Assert.AreEqual(true, arrayOfObjects[2].GetField <bool>("booleanPropertyUpdated"));
}
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"));
}
}
}
public void ShouldInsertObjectIntoUsingContentKeyword()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.ConnectionOptions))
{
// prerequisites
database
.Create.Class("TestClass")
.Run();
ODocument document = new ODocument()
.SetField("foo", "foo string value")
.SetField("bar", 12345);
ODocument insertedDocument = database
.Insert()
.Into("TestClass")
.Content("{\"bar\": 12345, \"foo\":\"foo string value\"}")
.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"));
}
}
}
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.IsNotNull(createdDocument.ORID);
Assert.AreEqual("TestClass", createdDocument.OClassName);
Assert.AreEqual(document.GetField <string>("foo"), createdDocument.GetField <string>("foo"));
Assert.AreEqual(document.GetField <int>("bar"), createdDocument.GetField <int>("bar"));
}
}
}
public void ShouldUpdateCluster()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GLOBAL_TEST_DATABASE_ALIAS))
{
// prerequisites
database
.Create.Class("TestClass")
.Run();
database
.Create.Cluster("TestCluster", OClusterType.Physical)
.Run();
ODocument document = new ODocument();
document.OClassName = "TestClass";
document
.SetField("foo", "foo string value")
.SetField("bar", 12345);
database
.Insert(document)
.Cluster("TestCluster")
.Run();
database
.Insert(document)
.Cluster("TestCluster")
.Run();
document
.SetField("bar", 54321)
.SetField("baz", "new baz value");
int documentsUpdated = database
.Update(document)
.Cluster("TestCluster")
.Run();
Assert.AreEqual(documentsUpdated, 2);
List <ODocument> documents = database
.Select()
.From("cluster:TestCluster")
.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 void ShouldInsertDocumentInto()
{
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()
.SetField("foo", "foo string value")
.SetField("bar", 12345);
ODocument insertedDocument = database
.Insert(document)
.Into("TestClass")
.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"));
}
}
}
public void ShouldDeserializeDateTime()
{
string recordString = "datetime:1296279468000t,date:1306281600000a,embedded:(datetime:1296279468000t,date:1306281600000a),array:[1296279468000t,1306281600000a]";
ODocument document = ODocument.Deserialize(recordString);
// check for fields existence
Assert.AreEqual(document.HasField("datetime"), true);
Assert.AreEqual(document.HasField("date"), true);
Assert.AreEqual(document.HasField("embedded.datetime"), true);
Assert.AreEqual(document.HasField("embedded.date"), true);
Assert.AreEqual(document.HasField("array"), true);
// check for fields values
Assert.AreEqual(document.GetField <DateTime>("datetime"), new DateTime(2011, 1, 29, 5, 37, 48));
Assert.AreEqual(document.GetField <DateTime>("date"), new DateTime(2011, 5, 25, 0, 0, 0));
Assert.AreEqual(document.GetField <DateTime>("embedded.datetime"), new DateTime(2011, 1, 29, 5, 37, 48));
Assert.AreEqual(document.GetField <DateTime>("embedded.date"), new DateTime(2011, 5, 25, 0, 0, 0));
List <DateTime> array = document.GetField <List <DateTime> >("array");
Assert.AreEqual(array.Count, 2);
Assert.AreEqual(array[0], new DateTime(2011, 1, 29, 5, 37, 48));
Assert.AreEqual(array[1], new DateTime(2011, 5, 25, 0, 0, 0));
}
public void TestLoadWithFetchPlanNoLinks()
{
using (var testContext = new TestDatabaseContext())
using (var database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
// prerequisites
database
.Create.Class("TestClass")
.Run();
ODocument document = new ODocument()
.SetField("foo", "foo string value")
.SetField("bar", 12345);
ODocument insertedDocument = database
.Insert(document)
.Into("TestClass")
.Run();
var loaded = database.Load.ORID(insertedDocument.ORID).FetchPlan("*:1").Run();
Assert.AreEqual("TestClass", loaded.OClassName);
Assert.AreEqual(document.GetField<string>("foo"), loaded.GetField<string>("foo"));
Assert.AreEqual(document.GetField<int>("bar"), loaded.GetField<int>("bar"));
Assert.AreEqual(insertedDocument.ORID, loaded.ORID);
}
}
public void ShouldDeserializeSingleAndSetOfOrids()
{
string recordString = "single:#10:12345,set:<#11:123,#22:1234,#33:1234567>,singleSet:<#44:44>";
ODocument document = ODocument.Deserialize(recordString);
// check for fields existence
Assert.AreEqual(document.HasField("single"), true);
Assert.AreEqual(document.HasField("set"), true);
// check for fields values
Assert.AreEqual(document.GetField <ORID>("single"), new ORID(10, 12345));
HashSet <ORID> collection = document.GetField <HashSet <ORID> >("set");
Assert.AreEqual(collection.Count, 3);
Assert.IsTrue(collection.Contains(new ORID(11, 123)));
Assert.IsTrue(collection.Contains(new ORID(22, 1234)));
Assert.IsTrue(collection.Contains(new ORID(33, 1234567)));
HashSet <ORID> singleSet = document.GetField <HashSet <ORID> >("singleSet");
Assert.AreEqual(singleSet.Count, 1);
Assert.IsTrue(singleSet.Contains(new ORID(44, 44)));
}
public void ShouldDeserializeBoolean()
{
string recordString = "singleT:true,singleF:false,embedded:(singleT:true,singleF:false),array:[true,false]";
ODocument document = ODocument.Deserialize(recordString);
// check for fields existence
Assert.AreEqual(document.HasField("singleT"), true);
Assert.AreEqual(document.HasField("singleF"), true);
Assert.AreEqual(document.HasField("embedded.singleT"), true);
Assert.AreEqual(document.HasField("embedded.singleF"), true);
Assert.AreEqual(document.HasField("array"), true);
// check for fields values
Assert.AreEqual(document.GetField <bool>("singleT"), true);
Assert.AreEqual(document.GetField <bool>("singleF"), false);
Assert.AreEqual(document.GetField <bool>("embedded.singleT"), true);
Assert.AreEqual(document.GetField <bool>("embedded.singleF"), false);
List <bool> array = document.GetField <List <bool> >("array");
Assert.AreEqual(array.Count, 2);
Assert.AreEqual(array[0], true);
Assert.AreEqual(array[1], false);
}
public void TestLoadNoFetchPlan()
{
using (var testContext = new TestDatabaseContext())
{
using (var database = new ODatabase(TestConnection.ConnectionOptions))
{
// prerequisites
database
.Create.Class("TestClass")
.Run();
ODocument document = new ODocument()
.SetField("foo", "foo string value")
.SetField("bar", 12345);
ODocument insertedDocument = database
.Insert(document)
.Into("TestClass")
.Run();
var loaded = database.Load.ORID(insertedDocument.ORID).Run();
Assert.AreEqual(loaded.OClassName, "TestClass");
Assert.AreEqual(loaded.GetField <string>("foo"), document.GetField <string>("foo"));
Assert.AreEqual(loaded.GetField <int>("bar"), document.GetField <int>("bar"));
Assert.AreEqual(insertedDocument.ORID, loaded.ORID);
}
}
}
public void ShouldCreateDocumentFromDocument()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.ConnectionOptions))
{
// 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(document)
.Run();
Assert.IsTrue(createdDocument.ORID != null);
Assert.AreEqual(createdDocument.OClassName, "TestClass");
Assert.AreEqual(createdDocument.GetField <string>("foo"), document.GetField <string>("foo"));
Assert.AreEqual(createdDocument.GetField <int>("bar"), document.GetField <int>("bar"));
}
}
}
public void ShouldInsertDocumentIntoCluster()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
// prerequisites
database
.Create.Class("TestClass")
.Run();
database
.Create.Cluster("TestCluster", OClusterType.Physical)
.Run();
ODocument document = new ODocument()
.SetField("foo", "foo string value")
.SetField("bar", 12345);
ODocument insertedDocument = database
.Insert(document)
.Into("TestClass")
.Cluster("TestCluster")
.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"));
}
}
}
public void TestLoadWithFetchPlanNoLinks()
{
using (var testContext = new TestDatabaseContext())
using (var database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
// prerequisites
database
.Create.Class("TestClass")
.Run();
ODocument document = new ODocument()
.SetField("foo", "foo string value")
.SetField("bar", 12345);
ODocument insertedDocument = database
.Insert(document)
.Into("TestClass")
.Run();
var loaded = database.Load.ORID(insertedDocument.ORID).FetchPlan("*:1").Run();
Assert.Equal("TestClass", loaded.OClassName);
Assert.Equal(document.GetField <string>("foo"), loaded.GetField <string>("foo"));
Assert.Equal(document.GetField <int>("bar"), loaded.GetField <int>("bar"));
Assert.Equal(insertedDocument.ORID, loaded.ORID);
}
}
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 void ShouldUpdateOridSet()
{
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();
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"));
}
}
}
}
public void ShouldUpdateClass()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
// prerequisites
database
.Create.Class("TestClass")
.Run();
ODocument document = new ODocument();
document
.SetField("foo", "foo string value")
.SetField("bar", 12345);
database
.Insert(document)
.Into("TestClass")
.Run();
database
.Insert(document)
.Into("TestClass")
.Run();
document
.SetField("bar", 54321)
.SetField("baz", "new baz value");
int documentsUpdated = database
.Update(document)
.Class("TestClass")
.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, "TestClass");
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 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 void ShouldUpdateRecord()
{
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();
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 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 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"));
}
private void InitializeDatabaseConnection(string databaseName, ODatabaseType databaseType, string userName, string userPassword)
{
_readBuffer = new byte[OClient.BufferLenght];
// initiate socket connection
try
{
_socket = new TcpClient(Hostname, Port);
_socket.ReceiveTimeout = RECIVE_TIMEOUT;
}
catch (SocketException ex)
{
throw new OException(OExceptionType.Connection, ex.Message, ex.InnerException);
}
_networkStream = new BufferedStream(_socket.GetStream());
_networkStream.Read(_readBuffer, 0, 2);
OClient.ProtocolVersion = ProtocolVersion = BinarySerializer.ToShort(_readBuffer.Take(2).ToArray());
// execute db_open operation
DbOpen operation = new DbOpen(null);
operation.DatabaseName = databaseName;
operation.DatabaseType = databaseType;
operation.UserName = userName;
operation.UserPassword = userPassword;
Document = ExecuteOperation(operation);
SessionId = Document.GetField <int>("SessionId");
}
//[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 TestGermanFloatCulture()
{
var floatValue = "108,4";
float @float;
#if DNX451
float.TryParse(floatValue, NumberStyles.Any, CultureInfo.GetCultureInfo("de-DE"), out @float);
#elif DNXCORE50
CultureInfo germanCulture = new CultureInfo("de-DE");
float.TryParse(floatValue, NumberStyles.Any, germanCulture, out @float);
#else
float = 0f;
#error No implementation for the target DNX
#endif
var doc = new ODocument {
OClassName = "TestVertex"
}
.SetField("floatField", @float);
var insertedDoc = _database.Insert(doc).Run();
Assert.NotNull(insertedDoc.ORID);
Assert.Equal(doc.GetField <float>("@float"), insertedDoc.GetField <float>("@float"));
}
private void InitializeServerConnection(string userName, string userPassword)
{
_readBuffer = new byte[OClient.BufferLenght];
// initiate socket connection
try
{
_socket = new TcpClient(Hostname, Port);
}
catch (SocketException ex)
{
throw new OException(OExceptionType.Connection, ex.Message, ex.InnerException);
}
_networkStream = _socket.GetStream();
_networkStream.Read(_readBuffer, 0, 2);
ProtocolVersion = BinarySerializer.ToShort(_readBuffer.Take(2).ToArray());
// execute connect operation
Connect operation = new Connect();
operation.UserName = userName;
operation.UserPassword = userPassword;
Document = ExecuteOperation <Connect>(operation);
SessionId = Document.GetField <int>("SessionId");
}
public void ShouldDeserializeComplexEmbeddedrecordsArray()
{
string recordString = "array:[(zak1:(nick:[(joe1:\"js1\"),(joe2:\"js2\"),(joe3:\"js3\")])),(zak2:(nick:[(joe4:\"js4\"),(joe5:\"js5\"),(joe6:\"js6\")]))]";
ODocument document = ODocument.Deserialize(recordString);
// check for fields existence
Assert.AreEqual(document.HasField("array"), true);
// check for fields values
List <ODocument> arrayOfZaks = document.GetField <List <ODocument> >("array");
Assert.AreEqual(arrayOfZaks.Count, 2);
List <ODocument> arrayOfJoes1 = arrayOfZaks[0].GetField <List <ODocument> >("zak1.nick");
Assert.AreEqual(arrayOfJoes1.Count, 3);
Assert.AreEqual(arrayOfJoes1[0].GetField <string>("joe1"), "js1");
Assert.AreEqual(arrayOfJoes1[1].GetField <string>("joe2"), "js2");
Assert.AreEqual(arrayOfJoes1[2].GetField <string>("joe3"), "js3");
List <ODocument> arrayOfJoes2 = arrayOfZaks[1].GetField <List <ODocument> >("zak2.nick");
Assert.AreEqual(arrayOfJoes2.Count, 3);
Assert.AreEqual(arrayOfJoes2[0].GetField <string>("joe4"), "js4");
Assert.AreEqual(arrayOfJoes2[1].GetField <string>("joe5"), "js5");
Assert.AreEqual(arrayOfJoes2[2].GetField <string>("joe6"), "js6");
}
//[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());
}
protected override void MapToNamedField(ODocument document, TTarget typedObject)
{
object sourcePropertyValue = document.GetField <object>(_fieldPath);
IList collection = sourcePropertyValue as IList;
if (collection == null) // if we only have one item currently stored (but scope for more) we create a temporary list and put our single item in it.
{
collection = new ArrayList();
if (sourcePropertyValue != null)
{
collection.Add(sourcePropertyValue);
}
}
// create instance of property type
IList collectionInstance = CreateListInstance(collection.Count);
for (int i = 0; i < collection.Count; i++)
{
var t = collection[i];
object oMapped = t;
if (_needsMapping)
{
object element = _elementFactory();
_mapper.ToObject((ODocument)t, element);
oMapped = element;
}
AddItemToList(collectionInstance, i, oMapped);
}
SetPropertyValue(typedObject, collectionInstance);
}
public override void MapToObject(ODocument document, TTarget typedObject)
{
TProperty result = new TProperty();
TypeMapper <TProperty> .Instance.ToObject(document.GetField <ODocument>(_fieldPath), result);
SetPropertyValue(typedObject, result);
}
internal static string Serialize(ODocument document)
{
if (!document.HasField("@ClassName"))
{
throw new OException(OExceptionType.Serialization, "Document doesn't contain @ClassName field which is required for serialization.");
}
return document.GetField<string>("@ClassName") + "@" + SerializeDocument(document);
}
public void ShouldDeserializeString()
{
string recordString = "simple:\"whoa this is awesome\",singleQuoted:\"a" + "\\" + "\"\",doubleQuoted:\"" + "\\" + "\"adsf" + "\\" + "\"\",twoBackslashes:\"" + "\\a" + "\\a" + "\"";
ODocument document = ODocument.Deserialize(recordString);
// check for fields existence
Assert.AreEqual(document.HasField("simple"), true);
Assert.AreEqual(document.HasField("singleQuoted"), true);
Assert.AreEqual(document.HasField("doubleQuoted"), true);
Assert.AreEqual(document.HasField("twoBackslashes"), true);
// check for fields values
Assert.AreEqual(document.GetField <string>("simple"), "whoa this is awesome");
Assert.AreEqual(document.GetField <string>("singleQuoted"), "a\"");
Assert.AreEqual(document.GetField <string>("doubleQuoted"), "\"adsf\"");
Assert.AreEqual(document.GetField <string>("twoBackslashes"), "\\a\\a");
}
internal static string Serialize(ODocument document)
{
if (!document.HasField("@ClassName"))
{
throw new OException(OExceptionType.Serialization, "Document doesn't contain @ClassName field which is required for serialization.");
}
return(document.GetField <string>("@ClassName") + "@" + SerializeDocument(document));
}
public byte[] Serialize(ODocument document)
{
if (!document.HasField("@OClassName"))
{
throw new OException(OExceptionType.Serialization, "Document doesn't contain @OClassName field which is required for serialization.");
}
return Encoding.UTF8.GetBytes(document.GetField<string>("@OClassName") + "@" + SerializeDocument(document));
}
public byte[] Serialize(ODocument document)
{
if (!document.HasField("@OClassName"))
{
throw new OException(OExceptionType.Serialization, "Document doesn't contain @OClassName field which is required for serialization.");
}
return(Encoding.UTF8.GetBytes(document.GetField <string>("@OClassName") + "@" + SerializeDocument(document)));
}
protected override void MapToNamedField(ODocument document, TTarget typedObject)
{
ODocument sourcePropertyValue = document.GetField <ODocument>(_fieldPath);
var collection = CreateCollectionInstance(sourcePropertyValue.Count);
AddItemToCollection(collection, 0, sourcePropertyValue);
SetPropertyValue(typedObject, collection);
}
public void ShouldInsertValuesWithNewLines()
{
_database
.Create.Class("TestClass")
.Run();
ODocument document = new ODocument();
document.OClassName = "TestClass";
document
.SetField("foo", "foo string value \r\n test te5435ttrtr")
.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"));
}
public void ShouldInsertAndReadValuesWithTrailingBackslash()
{
_database
.Create.Class("TestClass")
.Run();
ODocument document = new ODocument();
document.OClassName = "TestClass";
document
.SetField("foo", "foo string value \\ test \\")
.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"));
List<ODocument> documents = _database
.Select()
.From(insertedDocument)
.ToList();
Assert.AreEqual(documents.Count, 1);
for (int i = 0; i < documents.Count; i++)
{
Assert.AreEqual(documents[i].ORID, insertedDocument.ORID);
Assert.AreEqual(documents[i].OClassName, insertedDocument.OClassName);
Assert.AreEqual(documents[i].GetField<string>("foo"), insertedDocument.GetField<string>("foo"));
Assert.AreEqual(documents[i].GetField<int>("bar"), insertedDocument.GetField<int>("bar"));
}
}
public void TestGermanFloatCulture()
{
var floatValue = "108,4";
float @float;
float.TryParse(floatValue, NumberStyles.Any, CultureInfo.GetCultureInfo("de-DE"), out @float);
var doc = new ODocument { OClassName = "TestVertex" }
.SetField("floatField", @float);
var insertedDoc = _database.Insert(doc).Run();
Assert.NotNull(insertedDoc.ORID);
Assert.Equal(doc.GetField<float>("@float"), insertedDoc.GetField<float>("@float"));
}
private void InitializeServerConnection(string userName, string userPassword)
{
_readBuffer = new byte[OClient.BufferLenght];
// initiate socket connection
try
{
_socket = new TcpClient(Hostname, Port);
}
catch (SocketException ex)
{
throw new OException(OExceptionType.Connection, ex.Message, ex.InnerException);
}
_networkStream = new BufferedStream(_socket.GetStream());
_networkStream.Read(_readBuffer, 0, 2);
OClient.ProtocolVersion = ProtocolVersion = BinarySerializer.ToShort(_readBuffer.Take(2).ToArray());
// execute connect operation
Connect operation = new Connect();
operation.UserName = userName;
operation.UserPassword = userPassword;
Document = ExecuteOperation(operation);
SessionId = Document.GetField<int>("SessionId");
}
private void validateMetadata(ODocument metadata, OType expectedType)
{
Assert.IsNotNull(metadata);
Assert.AreEqual(expectedType, (OType)metadata.GetField<int>("type"));
}
public void ShouldCreateEdgeUntyped()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
ODocument document = new ODocument();
document.SetField("foo", "foo string value");
document.SetField("bar", 12345);
// create test class for edges
database
.Create.Class("TestEdgeClass")
.Extends("OGraphEdge")
.Run();
// create test vertices which will be connected by edge
ORecord vertex1 = database
.Create.Vertex("OGraphVertex")
.Set(document)
.Run();
ORecord vertex2 = database
.Create.Vertex("OGraphVertex")
.Set(document)
.Run();
// connect previous vertices with edge
ORecord edge1 = database
.Create.Edge("TestEdgeClass")
.From(vertex1.ORID)
.To(vertex2.ORID)
.Set(document)
.Run();
Assert.AreEqual(edge1.HasField("in"), true);
Assert.AreEqual(edge1.HasField("out"), true);
Assert.AreEqual(edge1.HasField("foo"), true);
Assert.AreEqual(edge1.HasField("bar"), true);
Assert.AreEqual(edge1.GetField<ORID>("out"), vertex1.ORID);
Assert.AreEqual(edge1.GetField<ORID>("in"), vertex2.ORID);
Assert.AreEqual(edge1.GetField<string>("foo"), document.GetField<string>("foo"));
Assert.AreEqual(edge1.GetField<int>("bar"), document.GetField<int>("bar"));
// connect previous vertices with another edge using multiple set statements
ORecord edge2 = database
.Create.Edge("TestEdgeClass")
.From(vertex2.ORID)
.To(vertex1.ORID)
.Set("foo", "foo string value2")
.Also("bar", 54321)
.Run();
Assert.AreEqual(edge2.HasField("in"), true);
Assert.AreEqual(edge2.HasField("out"), true);
Assert.AreEqual(edge2.HasField("foo"), true);
Assert.AreEqual(edge2.HasField("bar"), true);
Assert.AreEqual(edge2.GetField<ORID>("out"), vertex2.ORID);
Assert.AreEqual(edge2.GetField<ORID>("in"), vertex1.ORID);
Assert.AreEqual(edge2.GetField<string>("foo"), "foo string value2");
Assert.AreEqual(edge2.GetField<int>("bar"), 54321);
}
}
}
public void ShouldCreateVertexUntyped()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
ODocument document = new ODocument();
document.SetField("foo", "foo string value");
document.SetField("bar", 12345);
List<string> options = new List<string>();
options.Add("option1");
options.Add("option2");
document.SetField("options", options);
// create test class for vertex
database
.Create.Class("TestVertexClass")
.Extends("OGraphVertex")
.Run();
// create test vertex from previously created class
ORecord loadedVertex1 = database
.Create.Vertex("TestVertexClass")
.Set(document)
.Run();
Assert.AreEqual(loadedVertex1.HasField("foo"), true);
Assert.AreEqual(loadedVertex1.HasField("bar"), true);
Assert.AreEqual(loadedVertex1.HasField("options"), true);
Assert.AreEqual(loadedVertex1.GetField<string>("foo"), document.GetField<string>("foo"));
Assert.AreEqual(loadedVertex1.GetField<int>("bar"), document.GetField<int>("bar"));
List<string> loadedOptions = loadedVertex1.GetField<List<string>>("options");
Assert.AreEqual(loadedOptions.Count, options.Count);
Assert.AreEqual(loadedOptions[0], options[0]);
Assert.AreEqual(loadedOptions[1], options[1]);
// create test vertex using multiple set statements
ORecord loadedVertex2 = database
.Create.Vertex("TestVertexClass")
.Set("foo", "foo string value2")
.Also("bar", 54321)
.Run();
Assert.AreEqual(loadedVertex2.HasField("foo"), true);
Assert.AreEqual(loadedVertex2.HasField("bar"), true);
Assert.AreEqual(loadedVertex2.GetField<string>("foo"), "foo string value2");
Assert.AreEqual(loadedVertex2.GetField<int>("bar"), 54321);
}
}
}
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"));
}
}
}
private void readOType(BinaryReader reader, string fieldName, ODocument document, OType type)
{
switch (type)
{
case OType.Integer:
document.SetField<int>(fieldName, readAsInteger(reader));
break;
case OType.Long:
document.SetField<long>(fieldName, readAsLong(reader));
break;
case OType.Short:
document.SetField<short>(fieldName, readAsShort(reader));
break;
case OType.String:
document.SetField<string>(fieldName, readString(reader));
break;
case OType.Double:
document.SetField<double>(fieldName, BitConverter.Int64BitsToDouble(readLong(reader)));
break;
case OType.Float:
document.SetField<float>(fieldName, readFloat(reader));
break;
case OType.Decimal:
var scale = reader.ReadInt32EndianAware();
var valueSize = reader.ReadInt32EndianAware();
// read Fine the value
var valuex = reader.ReadBytesRequired(valueSize);
Int64 x1 = 0;
if ((valuex[0] & 0x80) == 0x80)
x1 = (sbyte)valuex[0];
else
x1 = valuex[0];
for (int i = 1; i < valuex.Length; i++)
{
x1 = (x1 << 8) | valuex[i];
}
try
{
document.SetField(fieldName, new Decimal(x1 * Math.Pow(10, (-1) * scale)));
}
catch (OverflowException)
{
document.SetField(fieldName, x1 * Math.Pow(10, (-1) * scale));
}
break;
case OType.Byte:
document.SetField<byte>(fieldName, reader.ReadByte());
break;
case OType.Boolean:
document.SetField<bool>(fieldName, reader.ReadByte() == 1 ? true : false);
break;
case OType.DateTime:
document.SetField<DateTime>(fieldName, readDateTime(reader));
break;
case OType.Date:
document.SetField<DateTime>(fieldName, readDate(reader));
break;
case OType.EmbeddedList:
var listLength = readAsInteger(reader);
OType embeddedListRecorType = (OType)reader.ReadByte();
List<Object> embeddedList = new List<Object>();
for (int i = 0; i < listLength; i++)
{
var d = new ODocument();
OType dataType = (OType)reader.ReadByte();
readOType(reader, i.ToString(), d, dataType);
embeddedList.AddRange(d.Values);
}
document.SetField(fieldName, embeddedList);
break;
case OType.EmbeddedSet:
var embeddedSetLen = readAsInteger(reader);
OType embeddedSetRecorType = (OType)reader.ReadByte();
HashSet<ODocument> embeddedSet = new HashSet<ODocument>();
for (int i = 0; i < embeddedSetLen; i++)
{
var d = new ODocument();
OType dataType = (OType)reader.ReadByte();
readOType(reader, "", d, dataType);
embeddedSet.Add(d);
}
document.SetField(fieldName, embeddedSet);
break;
case OType.EmbeddedMap:
/*
* header:headerStructure | values:valueStructure
* headerStructure
* ===============
* keyType:byte | keyValue:byte[]
*
* valueStructure
* ==============
* valueType:byte | value:byte[]
*/
var size = readAsInteger(reader);
var fd = new FieldDefinition[size];
Dictionary<string, Object> map = new Dictionary<string, object>();
for (int i = 0; i < size; i++)
{
fd[i] = new FieldDefinition();
var d = new ODocument();
var keyType = (OType)reader.ReadByte();
if (keyType != OType.String)
throw new NotImplementedException("key type " + keyType + " not implemented for EmbededMap");
readOType(reader, "key", d, keyType);
fd[i].FieldName = d.GetField<string>("key");
fd[i].Pointer = reader.ReadInt32EndianAware();
fd[i].DataType = (OType)reader.ReadByte();
}
for (int i = 0; i < size; i++)
{
var d = new ODocument();
if (fd[i].Pointer > 0)
{
readOType(reader, "value", d, fd[i].DataType);
map.Add(fd[i].FieldName, d.GetField<object>("value"));
}
else
{
map.Add(fd[i].FieldName, null);
}
}
document.SetField<Dictionary<string, Object>>(fieldName, map);
break;
case OType.Embedded:
var version = reader.ReadByte();
parseDocument(reader, document);
break;
case OType.Link:
var claster = readAsLong(reader);
var record = readAsLong(reader);
document.SetField(fieldName, new ORID((short)claster, record));
break;
case OType.LinkBag:
var rids = new HashSet<ORID>();
var config = reader.ReadByte();
if ((config & 2) == 2)
{
// uuid parsing is not implemented
config += 16;
}
if ((config & 1) == 1) // 1 - embedded,0 - tree-based
{
var entriesSize = reader.ReadInt32EndianAware();
for (int j = 0; j < entriesSize; j++)
{
var clusterid = reader.ReadInt16EndianAware();
var clusterposition = reader.ReadInt64EndianAware();
rids.Add(new ORID(clusterid, clusterposition));
}
}
else
{
throw new NotImplementedException("tree based ridbag");
}
document.SetField(fieldName, rids);
break;
case OType.LinkList:
var linkList = readLinkCollection(reader);
document.SetField(fieldName, linkList);
break;
case OType.LinkSet:
var linkSet = new HashSet<ORID>(readLinkCollection(reader));
document.SetField(fieldName, linkSet);
break;
case OType.Any:
break;
default:
throw new OException(OExceptionType.Deserialization, "The field type: " + type.ToString() + "not implemented");
}
}
public void TestLoadWithFetchPlanWithLinks()
{
using (var testContext = new TestDatabaseContext())
using (var database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
// prerequisites
database
.Create.Class("TestClass")
.Extends("V")
.Run();
ODocument document = new ODocument()
.SetField("foo", "foo string value")
.SetField("bar", 12345);
ODocument insertedDocument = database
.Insert(document)
.Into("TestClass")
.Run();
for (int i = 0; i < 2; i++)
{
ODocument document2 = new ODocument()
.SetField("foo", "bar string value")
.SetField("bar", 23456);
ODocument insertedDocument2 = database
.Insert(document2)
.Into("TestClass")
.Run();
database.Create.Edge("E").From(insertedDocument).To(insertedDocument2).Run();
}
var loaded = database.Load.ORID(insertedDocument.ORID).FetchPlan("*:1").Run();
Assert.Equal("TestClass", loaded.OClassName);
Assert.Equal(document.GetField<string>("foo"), loaded.GetField<string>("foo"));
Assert.Equal(document.GetField<int>("bar"), loaded.GetField<int>("bar"));
Assert.Equal(insertedDocument.ORID, loaded.ORID);
}
}
public byte[] Serialize(ODocument document)
{
var buffer = new BinaryBuffer();
ODocument schema = null; // Until Implementing schema this is null class
// Version
buffer.Add((byte)SERIALIZER_VERSION);
// Class Name
if (!String.IsNullOrEmpty(document.OClassName))
{
buffer.WriteVariant(document.OClassName.Length);
var className = BinarySerializer.ToArray(document.OClassName);
buffer.AddRange(className);
}
else
{
var length = BinarySerializer.ToArray((int)0);
buffer.AddRange(length);
}
// Header
var propNames = document.Keys.Where(k => !k.StartsWith("@")).ToArray();
var pos = new int[propNames.Length];
var val = new KeyValuePair<string, Object>[propNames.Length];
for (var i = 0; i < propNames.Length; i++)
{
var prop = propNames[i];
if (schema != null)
{
}
else
{
buffer.WriteVariant(prop.Length);
var propName = BinarySerializer.ToArray(prop);
buffer.AddRange(propName);
pos[i] = buffer.Allocate(sizeof(int) + 1);
}
val[i] = new KeyValuePair<string, object>(prop, document.GetField<object>(prop));
}
buffer.WriteVariant(0); // Header stop byte
// Data
for (int i = 0; i < val.Length; i++)
{
int pointer = 0;
var value = val[i].Value;
if (value != null)
{
var valueType = TypeConverter.TypeToDbName(value.GetType());
pointer = writeOType(buffer, value, valueType, getLinkedType(valueType, val[i].Key));
buffer.Write(pos[i], pointer);
if (schema == null)
{
buffer.Write((pos[i] + sizeof(int)), (byte)valueType);
}
}
}
return buffer.ToArray();
}
public void ShouldInsertDocumentIntoCluster()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
// prerequisites
database
.Create.Class("TestClass")
.Run();
database
.Create.Cluster("TestCluster", OClusterType.Physical)
.Run();
database.Command("alter class TestClass addcluster TestCluster");
ODocument document = new ODocument()
.SetField("foo", "foo string value")
.SetField("bar", 12345);
ODocument insertedDocument = database
.Insert(document)
.Into("TestClass")
.Cluster("TestCluster")
.Run();
Assert.True(insertedDocument.ORID != null);
Assert.Equal(insertedDocument.OClassName, "TestClass");
Assert.Equal(insertedDocument.GetField<string>("foo"), document.GetField<string>("foo"));
Assert.Equal(insertedDocument.GetField<int>("bar"), document.GetField<int>("bar"));
}
}
}
public void ShouldUpdateRecord()
{
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();
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"));
}
}
}