public void ShouldCreateVertexFromOVertex()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
OVertex vertex = new OVertex();
vertex
.SetField("foo", "foo string value")
.SetField("bar", 12345);
OVertex createdVertex = database
.Create.Vertex(vertex)
.Run();
Assert.IsTrue(createdVertex.ORID != null);
Assert.AreEqual(createdVertex.OClassName, "V");
Assert.AreEqual(createdVertex.GetField <string>("foo"), vertex.GetField <string>("foo"));
Assert.AreEqual(createdVertex.GetField <int>("bar"), vertex.GetField <int>("bar"));
}
}
}
public void ShouldCreateEdgeClusterFromTo()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
// prerequisites
database
.Create.Class("TestEdgeClass")
.Extends <OEdge>()
.Run();
database
.Create.Cluster("TestCluster", OClusterType.Physical)
.Run();
OVertex vertex1 = database
.Create.Vertex <OVertex>()
.Run();
OVertex vertex2 = database
.Create.Vertex <OVertex>()
.Run();
OEdge createdEdge = database
.Create.Edge("TestEdgeClass")
.Cluster("TestCluster")
.From(vertex1.ORID)
.To(vertex2.ORID)
.Run();
Assert.IsTrue(!string.IsNullOrEmpty(createdEdge.ORID.ToString()));
Assert.AreEqual(createdEdge.Label, "TestEdgeClass");
Assert.AreEqual(createdEdge.OClassName, "TestEdgeClass");
Assert.AreEqual(createdEdge.InV, vertex2.ORID);
Assert.AreEqual(createdEdge.OutV, vertex1.ORID);
}
}
}
public void ShouldCreateEdgeFromToSet()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GLOBAL_TEST_DATABASE_ALIAS))
{
// prerequisites
database
.Create.Class("TestEdgeClass")
.Extends <OEdge>()
.Run();
OVertex vertex1 = database
.Create.Vertex <OVertex>()
.Run();
OVertex vertex2 = database
.Create.Vertex <OVertex>()
.Run();
OEdge createdEdge = database
.Create.Edge("TestEdgeClass")
.From(vertex1.ORID)
.To(vertex2.ORID)
.Set("foo", "foo string value")
.Set("bar", 12345)
.Run();
Assert.IsTrue(!string.IsNullOrEmpty(createdEdge.ORID.ToString()));
Assert.AreEqual(createdEdge.Label, "TestEdgeClass");
Assert.AreEqual(createdEdge.OClassName, "TestEdgeClass");
Assert.AreEqual(createdEdge.InV, vertex2.ORID);
Assert.AreEqual(createdEdge.OutV, vertex1.ORID);
Assert.AreEqual(createdEdge.GetField <string>("foo"), "foo string value");
Assert.AreEqual(createdEdge.GetField <int>("bar"), 12345);
}
}
}
public void ShouldCreateEdgeFromToSet()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
// prerequisites
database
.Create.Class("TestEdgeClass")
.Extends <OEdge>()
.Run();
OVertex vertex1 = database
.Create.Vertex <OVertex>()
.Run();
OVertex vertex2 = database
.Create.Vertex <OVertex>()
.Run();
OEdge createdEdge = database
.Create.Edge("TestEdgeClass")
.From(vertex1.ORID)
.To(vertex2.ORID)
.Set("foo", "foo string value")
.Set("bar", 12345)
.Run();
Assert.NotNull(createdEdge.ORID);
Assert.Equal("TestEdgeClass", createdEdge.Label);
Assert.Equal("TestEdgeClass", createdEdge.OClassName);
Assert.Equal(vertex2.ORID, createdEdge.InV);
Assert.Equal(vertex1.ORID, createdEdge.OutV);
Assert.Equal("foo string value", createdEdge.GetField <string>("foo"));
Assert.Equal(12345, createdEdge.GetField <int>("bar"));
}
}
}
static void Main(string[] args)
{
_server = new OServer(_hostname, _port, _rootUserName, _rootUserPassword);
//If the DB already exists I delete it
if (_server.DatabaseExist(_DBname, OStorageType.PLocal))
{
_server.DropDatabase("TestDatabaseName", OStorageType.PLocal);
Console.WriteLine("Database " + _DBname + " deleted");
}
//Creating the new DB
_server.CreateDatabase(_DBname, ODatabaseType.Graph, OStorageType.PLocal);
Console.WriteLine("Database " + _DBname + " created");
//Connect to the DB and populate it
OClient.CreateDatabasePool(
"127.0.0.1",
2424,
_DBname,
ODatabaseType.Graph,
_username,
_password,
10,
"myTestDatabaseAlias"
);
Console.WriteLine("Connected to the DB " + _DBname);
using (ODatabase database = new ODatabase("myTestDatabaseAlias"))
{
database
.Create.Class("TestClass")
.Extends <OVertex>()
.Run();
OVertex createdVertex = database
.Create.Vertex("TestClass")
.Set("name", "LucaS")
.Run();
Console.WriteLine("Created vertex with @rid " + createdVertex.ORID);
}
}
public void ShouldCreateEdgeObjectFromObjectToObject()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GLOBAL_TEST_DATABASE_ALIAS))
{
// prerequisites
database
.Create.Class <TestProfileClass>()
.Extends <OEdge>()
.Run();
OVertex vertex1 = database
.Create.Vertex <OVertex>()
.Run <OVertex>();
OVertex vertex2 = database
.Create.Vertex <OVertex>()
.Run <OVertex>();
TestProfileClass profile = new TestProfileClass();
profile.Name = "Johny";
profile.Surname = "Bravo";
TestProfileClass createdEdge = database
.Create.Edge(profile)
.From(vertex1)
.To(vertex2)
.Run <TestProfileClass>();
Assert.IsTrue(createdEdge.ORID != null);
Assert.AreEqual(createdEdge.Name, profile.Name);
Assert.AreEqual(createdEdge.Surname, profile.Surname);
}
}
}
public void ShouldCreateEdgeObjectFromObjectToObject()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
// prerequisites
database
.Create.Class <TestProfileClass>()
.Extends <OEdge>()
.Run();
OVertex vertex1 = database
.Create.Vertex <OVertex>()
.Run <OVertex>();
OVertex vertex2 = database
.Create.Vertex <OVertex>()
.Run <OVertex>();
TestProfileClass profile = new TestProfileClass();
profile.Name = "Johny";
profile.Surname = "Bravo";
TestProfileClass createdEdge = database
.Create.Edge(profile)
.From(vertex1)
.To(vertex2)
.Run <TestProfileClass>();
Assert.NotNull(createdEdge.ORID);
Assert.Equal(profile.Name, createdEdge.Name);
Assert.Equal(profile.Surname, createdEdge.Surname);
}
}
}
public void ShouldCreateVerticesWithEdge()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
OVertex vertex1 = database
.Create.Vertex <OVertex>()
.Set("Foo", "foo string value1")
.Set("Bar", 12345)
.Run <OVertex>();
Assert.True(!string.IsNullOrEmpty(vertex1.ORID.ToString()));
Assert.Equal("V", vertex1.OClassName);
Assert.Equal("foo string value1", vertex1.GetField <string>("Foo"));
Assert.Equal(12345, vertex1.GetField <int>("Bar"));
OVertex vertex2 = database
.Create.Vertex <OVertex>()
.Set("Foo", "foo string value2")
.Set("Bar", 54321)
.Run <OVertex>();
Assert.True(!string.IsNullOrEmpty(vertex2.ORID.ToString()));
Assert.Equal("V", vertex2.OClassName);
Assert.Equal("foo string value2", vertex2.GetField <string>("Foo"));
Assert.Equal(54321, vertex2.GetField <int>("Bar"));
OVertex vertex3 = database
.Create.Vertex <OVertex>()
.Set("Foo", "foo string value3")
.Set("Bar", 347899)
.Run <OVertex>();
Assert.True(!string.IsNullOrEmpty(vertex3.ORID.ToString()));
Assert.Equal("V", vertex3.OClassName);
Assert.Equal("foo string value3", vertex3.GetField <string>("Foo"));
Assert.Equal(347899, vertex3.GetField <int>("Bar"));
OEdge edge1 = database
.Create.Edge <OEdge>()
.From(vertex1)
.To(vertex2)
.Set("Foo", "foo string value3")
.Set("Bar", 123)
.Run <OEdge>();
Assert.True(!string.IsNullOrEmpty(edge1.ORID.ToString()));
Assert.Equal("E", edge1.Label);
Assert.Equal("E", edge1.OClassName);
Assert.Equal(vertex2.ORID, edge1.InV);
Assert.Equal(vertex1.ORID, edge1.OutV);
Assert.Equal("foo string value3", edge1.GetField <string>("Foo"));
Assert.Equal(123, edge1.GetField <int>("Bar"));
OEdge edge2 = database
.Create.Edge <OEdge>()
.From(vertex1)
.To(vertex3)
.Set("Foo", "foo string value4")
.Set("Bar", 245)
.Run <OEdge>();
Assert.True(!string.IsNullOrEmpty(edge2.ORID.ToString()));
Assert.Equal("E", edge2.Label);
Assert.Equal("E", edge2.OClassName);
Assert.Equal(vertex3.ORID, edge2.InV);
Assert.Equal(vertex1.ORID, edge2.OutV);
Assert.Equal("foo string value4", edge2.GetField <string>("Foo"));
Assert.Equal(245, edge2.GetField <int>("Bar"));
OVertex loadedVertex1 = database
.Select()
.From(vertex1)
.ToList <OVertex>().First();
Assert.True(!string.IsNullOrEmpty(loadedVertex1.ORID.ToString()));
Assert.Equal("V", loadedVertex1.OClassName);
Assert.Equal(0, loadedVertex1.InE.Count);
Assert.Equal(2, loadedVertex1.OutE.Count);
Assert.True(loadedVertex1.OutE.Contains(edge1.ORID));
Assert.True(loadedVertex1.OutE.Contains(edge2.ORID));
Assert.Equal(vertex1.GetField <string>("Foo"), loadedVertex1.GetField <string>("Foo"));
Assert.Equal(vertex1.GetField <int>("Bar"), loadedVertex1.GetField <int>("Bar"));
OVertex loadedVertex2 = database
.Select()
.From(vertex2)
.ToList <OVertex>().First();
Assert.True(!string.IsNullOrEmpty(loadedVertex2.ORID.ToString()));
Assert.Equal("V", loadedVertex2.OClassName);
Assert.Equal(0, loadedVertex2.OutE.Count);
Assert.Equal(1, loadedVertex2.InE.Count);
Assert.True(loadedVertex2.InE.Contains(edge1.ORID));
Assert.Equal(vertex2.GetField <string>("Foo"), loadedVertex2.GetField <string>("Foo"));
Assert.Equal(vertex2.GetField <int>("Bar"), loadedVertex2.GetField <int>("Bar"));
}
}
}
public void TestCreateVertex()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
// prerequisites
database
.Create.Class("TestVertexClass")
.Extends <OVertex>()
.Run();
OVertex testVertex = new OVertex();
testVertex.OClassName = "TestVertexClass";
testVertex.SetField("foo", "foo string value");
testVertex.SetField("bar", 12345);
Assert.AreEqual(null, testVertex.ORID);
database.Transaction.Add(testVertex);
Assert.IsNotNull(testVertex.ORID);
Assert.IsTrue(testVertex.ORID.ClusterPosition < 0);
Assert.AreEqual(-2, testVertex.ORID.ClusterPosition);
database.Transaction.Commit();
Assert.IsNotNull(testVertex.ORID);
Assert.AreEqual(database.GetClusterIdFor("TestVertexClass"), testVertex.ORID.ClusterId);
var createdVertex = database.Load.ORID(testVertex.ORID).Run().To <OVertex>();
Assert.IsTrue(createdVertex.ORID != null);
Assert.AreEqual("TestVertexClass", createdVertex.OClassName);
Assert.AreEqual("foo string value", createdVertex.GetField <string>("foo"));
Assert.AreEqual(12345, createdVertex.GetField <int>("bar"));
}
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
OVertex testVertex = new OVertex();
testVertex.OClassName = "TestVertexClass";
testVertex.SetField("foo", "foo string value");
testVertex.SetField("bar", 12345);
Assert.AreEqual(null, testVertex.ORID);
database.Transaction.Add(testVertex);
Assert.IsNotNull(testVertex.ORID);
Assert.IsTrue(testVertex.ORID.ClusterPosition < 0);
Assert.AreEqual(-2, testVertex.ORID.ClusterPosition);
database.Transaction.Commit();
Assert.IsNotNull(testVertex.ORID);
Assert.AreEqual(database.GetClusterIdFor("TestVertexClass"), testVertex.ORID.ClusterId);
Assert.AreNotEqual(-2, testVertex.ORID.ClusterPosition);
var createdVertex = database.Load.ORID(testVertex.ORID).Run().To <OVertex>();
Assert.IsTrue(createdVertex.ORID != null);
Assert.AreEqual(createdVertex.OClassName, "TestVertexClass");
Assert.AreEqual(createdVertex.GetField <string>("foo"), "foo string value");
Assert.AreEqual(createdVertex.GetField <int>("bar"), 12345);
}
}
}
static void Main(string[] args)
{
_server = new OServer(_hostname, _port, _rootUserName, _rootUserPassword);
if (!_server.DatabaseExist(_DBname, OStorageType.PLocal))
{
_server.CreateDatabase(_DBname, ODatabaseType.Graph, OStorageType.PLocal);
Console.WriteLine("Database " + _DBname + " created");
//Connect to the DB
OClient.CreateDatabasePool(
_hostname,
_port,
_DBname,
ODatabaseType.Graph,
_username,
_password,
10,
_aliasDB
);
Console.WriteLine("Connected to the DB " + _DBname);
using (ODatabase database = new ODatabase(_aliasDB))
{
//Classes and properties creation
database
.Create
.Class("Users")
.Extends <OVertex>()
.Run();
database
.Create
.Property("userID", OType.Integer)
.Class("users")
.Run();
//Populate the DB
OVertex vertexUser = new OVertex();
vertexUser.OClassName = "Users";
vertexUser
.SetField("userID", 1);
OVertex createVertexUser = database
.Create.Vertex(vertexUser)
.Run();
Console.WriteLine("Created vertex " + createVertexUser.OClassName + " with @rid " + createVertexUser.ORID + " and userID " + createVertexUser.GetField <int>("userID"));
}
}
else
{
//Connection
OClient.CreateDatabasePool(
_hostname,
_port,
_DBname,
ODatabaseType.Graph,
_username,
_password,
10,
_aliasDB
);
Console.WriteLine("Connected to the DB " + _DBname);
using (ODatabase database = new ODatabase(_aliasDB))
{
database
.Update()
.Class("Users")
.Set("userID", 2)
.Upsert()
.Where("userID")
.Equals(2)
.Run();
Console.WriteLine("Operation executed");
}
}
}
private void FillVertex(IBusinessObject businessObject, OVertex vertex)
{
var props = (from prop in businessObject.GetType().GetProperties()
let attr = prop.GetCustomAttribute <DocumentPropertyAttribute>()
where attr != null
select new { Prop = prop, Attr = attr }).ToList();
foreach (var propertyInfo in props)
{
var value = propertyInfo.Prop.GetValue(businessObject);
if (propertyInfo.Attr.Required && (value == null || value is string && string.IsNullOrEmpty(value.ToString())))
{
throw new Exception($"The property '{nameof(propertyInfo.Attr.Key)}' is required");
}
if (vertex.ContainsKey(propertyInfo.Attr.Key))
{
vertex[propertyInfo.Attr.Key] = value;
}
else
{
vertex.Add(propertyInfo.Attr.Key, value);
}
}
var children = (from prop in businessObject.GetType().GetProperties()
let attr = prop.GetCustomAttribute <ChildAttribute>()
where attr != null
select new { Prop = prop, Attr = attr }).ToList();
foreach (var referenceList in children)
{
var child = (IBusinessObject)referenceList.Prop.GetValue(businessObject);
if (string.IsNullOrEmpty(child.Id))
{
transactionItems.Add(new TransactionItem(ETransaction.Create, child));
transactionEdges.Add(new TransactionEdge(businessObject, child, referenceList.Attr.EdgeClassName, ETransaction.Create));
}
else
{
transactionItems.Add(new TransactionItem(ETransaction.Update, child));
}
}
var referenceLists = (from prop in businessObject.GetType().GetProperties()
let attr = prop.GetCustomAttribute <ReferenceListAttribute>()
where attr != null
select new { Prop = prop, Attr = attr }).ToList();
foreach (var referenceList in referenceLists)
{
var list = (IList)referenceList.Prop.GetValue(businessObject);
foreach (var referenceBo in list.OfType <IBusinessObject>())
{
if (!string.IsNullOrEmpty(referenceBo.Id))
{
transactionEdges.Add(new TransactionEdge(businessObject, referenceBo, referenceList.Attr.EdgeClassName, ETransaction.Create));
}
}
}
}
public void ShouldCreateVerticesWithEdge()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GLOBAL_TEST_DATABASE_ALIAS))
{
OVertex vertex1 = database
.Create.Vertex <OVertex>()
.Set("Foo", "foo string value1")
.Set("Bar", 12345)
.Run <OVertex>();
Assert.IsTrue(!string.IsNullOrEmpty(vertex1.ORID.ToString()));
Assert.AreEqual(vertex1.OClassName, "V");
Assert.AreEqual(vertex1.GetField <string>("Foo"), "foo string value1");
Assert.AreEqual(vertex1.GetField <int>("Bar"), 12345);
OVertex vertex2 = database
.Create.Vertex <OVertex>()
.Set("Foo", "foo string value2")
.Set("Bar", 54321)
.Run <OVertex>();
Assert.IsTrue(!string.IsNullOrEmpty(vertex2.ORID.ToString()));
Assert.AreEqual(vertex2.OClassName, "V");
Assert.AreEqual(vertex2.GetField <string>("Foo"), "foo string value2");
Assert.AreEqual(vertex2.GetField <int>("Bar"), 54321);
OVertex vertex3 = database
.Create.Vertex <OVertex>()
.Set("Foo", "foo string value3")
.Set("Bar", 347899)
.Run <OVertex>();
Assert.IsTrue(!string.IsNullOrEmpty(vertex3.ORID.ToString()));
Assert.AreEqual(vertex3.OClassName, "V");
Assert.AreEqual(vertex3.GetField <string>("Foo"), "foo string value3");
Assert.AreEqual(vertex3.GetField <int>("Bar"), 347899);
OEdge edge1 = database
.Create.Edge <OEdge>()
.From(vertex1)
.To(vertex2)
.Set("Foo", "foo string value3")
.Set("Bar", 123)
.Run <OEdge>();
Assert.IsTrue(!string.IsNullOrEmpty(edge1.ORID.ToString()));
Assert.AreEqual(edge1.Label, "E");
Assert.AreEqual(edge1.OClassName, "E");
Assert.AreEqual(edge1.InV, vertex2.ORID);
Assert.AreEqual(edge1.OutV, vertex1.ORID);
Assert.AreEqual(edge1.GetField <string>("Foo"), "foo string value3");
Assert.AreEqual(edge1.GetField <int>("Bar"), 123);
OEdge edge2 = database
.Create.Edge <OEdge>()
.From(vertex1)
.To(vertex3)
.Set("Foo", "foo string value4")
.Set("Bar", 245)
.Run <OEdge>();
Assert.IsTrue(!string.IsNullOrEmpty(edge2.ORID.ToString()));
Assert.AreEqual(edge2.Label, "E");
Assert.AreEqual(edge2.OClassName, "E");
Assert.AreEqual(edge2.InV, vertex3.ORID);
Assert.AreEqual(edge2.OutV, vertex1.ORID);
Assert.AreEqual(edge2.GetField <string>("Foo"), "foo string value4");
Assert.AreEqual(edge2.GetField <int>("Bar"), 245);
OVertex loadedVertex1 = database
.Select()
.From(vertex1)
.ToList <OVertex>().First();
Assert.IsTrue(!string.IsNullOrEmpty(loadedVertex1.ORID.ToString()));
Assert.AreEqual(loadedVertex1.OClassName, "V");
Assert.AreEqual(loadedVertex1.InE.Count, 0);
Assert.AreEqual(loadedVertex1.OutE.Count, 2);
Assert.IsTrue(loadedVertex1.OutE.Contains(edge1.ORID));
Assert.IsTrue(loadedVertex1.OutE.Contains(edge2.ORID));
Assert.AreEqual(loadedVertex1.GetField <string>("Foo"), vertex1.GetField <string>("Foo"));
Assert.AreEqual(loadedVertex1.GetField <int>("Bar"), vertex1.GetField <int>("Bar"));
OVertex loadedVertex2 = database
.Select()
.From(vertex2)
.ToList <OVertex>().First();
Assert.IsTrue(!string.IsNullOrEmpty(loadedVertex2.ORID.ToString()));
Assert.AreEqual(loadedVertex2.OClassName, "V");
Assert.AreEqual(loadedVertex2.OutE.Count, 0);
Assert.AreEqual(loadedVertex2.InE.Count, 1);
Assert.IsTrue(loadedVertex2.InE.Contains(edge1.ORID));
Assert.AreEqual(loadedVertex2.GetField <string>("Foo"), vertex2.GetField <string>("Foo"));
Assert.AreEqual(loadedVertex2.GetField <int>("Bar"), vertex2.GetField <int>("Bar"));
}
}
}
