public void ShouldExecuteSimpleGremlinQuery()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.ConnectionOptions))
{
OVertex vertex1 = database
.Create.Vertex <OVertex>()
.Set("Foo", "foo string value 1")
.Set("Bar", 12345)
.Run();
OVertex vertex2 = database
.Create.Vertex <OVertex>()
.Set("Foo", "foo string value 2")
.Set("Bar", 54321)
.Run();
OEdge edge1 = database
.Create.Edge <OEdge>()
.From(vertex1)
.To(vertex2)
.Set("Foo", "foo string value 3")
.Set("Bar", 123)
.Run();
OCommandResult documents = database.Gremlin("g.V");
}
}
}
public void ShouldCreateEdgeFromOEdge()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GLOBAL_TEST_DATABASE_ALIAS))
{
OVertex vertex1 = database
.Create.Vertex <OVertex>()
.Run();
OVertex vertex2 = database
.Create.Vertex <OVertex>()
.Run();
OEdge edge = new OEdge();
edge.SetField("Foo", "foo string value");
edge.SetField("Bar", 12345);
OEdge createdEdge = database
.Create.Edge(edge)
.From(vertex1)
.To(vertex2)
.Run();
Assert.IsTrue(!string.IsNullOrEmpty(createdEdge.ORID.ToString()));
Assert.AreEqual(createdEdge.Label, "E");
Assert.AreEqual(createdEdge.OClassName, "E");
Assert.AreEqual(createdEdge.InV, vertex2.ORID);
Assert.AreEqual(createdEdge.OutV, vertex1.ORID);
Assert.AreEqual(createdEdge.GetField <string>("Foo"), edge.GetField <string>("Foo"));
Assert.AreEqual(createdEdge.GetField <int>("Bar"), edge.GetField <int>("Bar"));
}
}
}
public void ShouldCreateEdgeFromOEdge()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
OVertex vertex1 = database
.Create.Vertex <OVertex>()
.Run();
OVertex vertex2 = database
.Create.Vertex <OVertex>()
.Run();
OEdge edge = new OEdge();
edge.SetField("Foo", "foo string value");
edge.SetField("Bar", 12345);
OEdge createdEdge = database
.Create.Edge(edge)
.From(vertex1)
.To(vertex2)
.Run();
Assert.NotNull(createdEdge.ORID);
Assert.Equal("E", createdEdge.Label);
Assert.Equal("E", createdEdge.OClassName);
Assert.Equal(vertex2.ORID, createdEdge.InV);
Assert.Equal(vertex1.ORID, createdEdge.OutV);
Assert.Equal(edge.GetField <string>("Foo"), createdEdge.GetField <string>("Foo"));
Assert.Equal(edge.GetField <int>("Bar"), createdEdge.GetField <int>("Bar"));
}
}
}
private async void PeriodicLinkData()
{
while (!_disposed)
{
Console.Clear();
using (var db = new ODatabase("localhost", 2424, "txgraph", ODatabaseType.Graph, "admin", "admin"))
{
var nodes = db.Query <OVertex>($"SELECT * FROM Transaction WHERE Unlinked = true LIMIT 100000");
foreach (var node in nodes)
{
var transaction = db.Transaction;
if (IsCoinbaseTx(node))
{
node.SetField("Unlinked", false);
transaction.AddOrUpdate(node);
transaction.Commit();
continue;
}
try
{
transaction.AddOrUpdate(node);
for (var i = 0; i < GetInputCount(node); i++)
{
var inputString = node.GetField <string>($"INPUT{i}");
var prevHash = inputString.Split(':')[0];
var prevN = Int64.Parse(inputString.Split(':')[1]);
var prevTx = db.Query <OVertex>($"SELECT * FROM Transaction WHERE Hash = \"{prevHash}\"").FirstOrDefault();
if (prevTx != null)
{
transaction.AddOrUpdate(prevTx);
var prevOutString = prevTx.GetField <string>($"OUTPUT{prevN}");
var prevOutN = prevOutString?.Split(':')[0];
var outAddr = prevOutString?.Split(':')[1];
var outAmount = prevOutString != null?Int64.Parse(prevOutString?.Split(':')[2]) : 0;
var edge = new OEdge()
{
OClassName = "Link"
};
edge.SetField("sTx", prevHash);
edge.SetField("sN", prevN);
edge.SetField("amount", outAmount);
edge.SetField("tTx", node.GetField <string>("Hash"));
edge.SetField("tAddr", outAddr ?? "");
transaction.AddEdge(edge, prevTx, node);
}
}
node.SetField("Unlinked", false);
transaction.Update(node);
transaction.Commit();
}
catch (Exception e)
{
transaction.Reset();
}
}
}
await Task.Delay(60000);
}
}
public void ShouldExecuteSimpleGremlinQuery()
{
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 value 1")
.Set("Bar", 12345)
.Run();
OVertex vertex2 = database
.Create.Vertex <OVertex>()
.Set("Foo", "foo string value 2")
.Set("Bar", 54321)
.Run();
OEdge edge1 = database
.Create.Edge <OEdge>()
.From(vertex1)
.To(vertex2)
.Set("Foo", "foo string value 3")
.Set("Bar", 123)
.Run();
List <ODocument> documents = database.Gremlin("g.V");
}
}
}
public void ShouldExecuteSimpleJavascriptQuery()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias))
{
OVertex vertex1 = database
.Create.Vertex <OVertex>()
.Set("Foo", "foo string value 1")
.Set("Bar", 12345)
.Run();
OVertex vertex2 = database
.Create.Vertex <OVertex>()
.Set("Foo", "foo string value 2")
.Set("Bar", 54321)
.Run();
OEdge edge1 = database
.Create.Edge <OEdge>()
.From(vertex1)
.To(vertex2)
.Set("Foo", "foo string value 3")
.Set("Bar", 123)
.Run();
List <ODocument> documents = database
.JavaScript("db.command('select from V');")
.Run()
.ToList();
Assert.AreEqual(2, documents.Count);
var loadedVertex1 = documents.Find(d => d.ORID.Equals(vertex1.ORID));
var loadedVertex2 = documents.Find(d => d.ORID.Equals(vertex2.ORID));
Assert.IsNotNull(loadedVertex1);
Assert.IsNotNull(loadedVertex2);
Assert.AreEqual(vertex1.GetField <string>("Foo"), loadedVertex1.GetField <string>("Foo"));
Assert.AreEqual(vertex1.GetField <int>("Bar"), loadedVertex1.GetField <int>("Bar"));
Assert.AreEqual(vertex2.GetField <string>("Foo"), loadedVertex2.GetField <string>("Foo"));
Assert.AreEqual(vertex2.GetField <int>("Bar"), loadedVertex2.GetField <int>("Bar"));
Assert.AreEqual(1, loadedVertex1.GetField <HashSet <ORID> >("out_").Count);
Assert.IsTrue(loadedVertex1.GetField <HashSet <ORID> >("out_").Contains(edge1.ORID));
Assert.IsTrue(loadedVertex2.GetField <HashSet <ORID> >("in_").Contains(edge1.ORID));
}
}
public void AddEdge(OEdge edge, OVertex from, OVertex to)
{
this.Add(edge);
edge.SetField("out", from.ORID);
edge.SetField("in", to.ORID);
appendOridToField(from, "out_" + edge.OClassName, edge.ORID);
appendOridToField(to, "in_" + edge.OClassName, edge.ORID);
if (!_records.ContainsKey(from.ORID))
{
Update(from);
}
if (!_records.ContainsKey(to.ORID))
{
Update(to);
}
}
public void DeleteEdge(OEdge edge)
{
var inV = this.getDocumentByOrid(edge.InV);
var outV = this.getDocumentByOrid(edge.OutV);
this.removeFromOridField(inV, "in_" + edge.OClassName, edge.ORID);
this.removeFromOridField(outV, "out_" + edge.OClassName, edge.ORID);
if (!_records.ContainsKey(inV.ORID))
{
Update(inV);
}
if (!_records.ContainsKey(outV.ORID))
{
Update(outV);
}
Insert(new TypedTransactionRecord <OEdge>(RecordType.Delete, edge));
}
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();
var res = database.Command("alter class TestEdgeClass addcluster testcluster");
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.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);
}
}
}
public void ShouldCreateEdgeClusterFromTo()
{
using (TestDatabaseContext testContext = new TestDatabaseContext())
{
using (ODatabase database = new ODatabase(TestConnection.GLOBAL_TEST_DATABASE_ALIAS))
{
// 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"));
}
}
}
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"));
}
}
}
private static void InsertHelper <T>(ODatabase db, T model,
OTransaction transaction, ICollection <object> exclude, ORID parent = null)
where T : OBaseRecord, new()
{
// Avoid following loops into a stack overflow
if (exclude.Contains(model))
{
return;
}
exclude.Add(model);
ODocument record = new ODocument();
record.OClassName = model.GetType().Name;
PropertyInfo[] properties = model.GetType().GetProperties(
BindingFlags.Public | BindingFlags.Instance |
BindingFlags.SetProperty | BindingFlags.GetProperty);
ICollection <PropertyInfo> linkableProperties = new List <PropertyInfo>();
foreach (PropertyInfo prop in properties)
{
if (reservedProperties.Contains(prop.Name))
{
continue;
}
OProperty aliasProperty = prop.GetCustomAttributes(typeof(OProperty))
.Where(attr => ((OProperty)attr).Alias != null)
.FirstOrDefault() as OProperty;
string name = aliasProperty == null ? prop.Name : aliasProperty.Alias;
// Record properties of model, but store properties linking to other
// vertex classes for later
if (typeof(OBaseRecord).IsAssignableFrom(prop.PropertyType))
{
linkableProperties.Add(prop);
}
else
{
record[name] = prop.GetValue(model);
}
}
transaction.Add(record);
model.ORID = record.ORID;
foreach (PropertyInfo prop in linkableProperties)
{
ORID outV, inV;
OBaseRecord propValue = prop.GetValue(model) as OBaseRecord;
if (!exclude.Select(ex => ex is OBaseRecord ? ((OBaseRecord)ex).ORID :
ORID_DEFAULT).Contains(propValue.ORID))
{
MethodInfo insertMethod = typeof(DatabaseExtensions)
.GetMethod("InsertHelper", BindingFlags.NonPublic |
BindingFlags.Static).MakeGenericMethod(propValue.GetType());
insertMethod.Invoke(null,
new object[] {
db, propValue, transaction, exclude, model.ORID
});
}
outV = model.ORID;
inV = propValue.ORID;
OEdgeAttribute edgeType =
prop.GetCustomAttributes(typeof(OEdgeAttribute))
.FirstOrDefault() as OEdgeAttribute;
OProperty propertyAlias = prop.GetCustomAttributes(typeof(OProperty))
.Where(p => ((OProperty)p).Alias != null)
.FirstOrDefault() as OProperty;
string alias = propertyAlias == null ? prop.Name : propertyAlias.Alias;
if (edgeType != null)
{
OEdge link = new OEdge();
link.OClassName = alias;
link["out"] = outV;
link["in"] = inV;
if (edgeType.IsInV)
{
ORID tmp = link.OutV;
link["out"] = link.InV;
link["in"] = tmp;
}
// Do not create an edge if there is an edge already
// connecting these vertices
IEnumerable <Tuple <ORID, ORID> > excludedLinks = exclude
.Select(ex => ex is OEdge ?
new Tuple <ORID, ORID>(((OEdge)ex).OutV, ((OEdge)ex).InV) :
new Tuple <ORID, ORID>(ORID_DEFAULT, ORID_DEFAULT));
if (excludedLinks.Contains(
new Tuple <ORID, ORID>(link.OutV, link.InV)))
{
continue;
}
exclude.Add(link);
transaction.Add(link);
}
}
}
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"));
}
}
}
static void Main(string[] args)
{
List <Occupations> _lisOccupations = LoadOccupations();
#region
try
{
OrientDBDriver.CreateDatabase();
OrientDBDriver.CreatePool();
ODatabase oDB = new ODatabase(OrientDBDriver.DatabaseAlias);
// we are setting Database to useLightweightEdges set to True because currently
// we don't need any properties in edges for User hasOccupationa and Movies_genres
oDB.Command("ALTER DATABASE custom useLightweightEdges=true");
#region Load Occupation
// First of all create Class of Occupation which extends from vertex class V
Console.WriteLine("Creating VERTEX Occupation ....");
oDB.Create.Class <Occupations>().Extends <OVertex>().CreateProperties <Occupations>().Run();
foreach (Occupations occ in _lisOccupations)
{
oDB.Create.Vertex <Occupations>(occ).Run();
}
Console.WriteLine("Successfully created Vertex Occupation");
#endregion
#region Load Users
List <Users> _listUsers = LoadUsers();
Console.WriteLine("Creating VERTEX Users with relation 'hasOccupation' using EDGE ....");
oDB.Create.Class <Users>().Extends <OVertex>().CreateProperties().Run();
oDB.Create.Class("hasOccupation").Extends <OEdge>().Run();
foreach (Users user in _listUsers)
{
ODocument odoc = oDB.Create.Vertex("Users")
.Set("userID", user.userID)
.Set("Gender", user.gender)
// .Set("OccupationID",user.OccupationID)
.Set("Age", user.age)
.Set("ZipCode", user.ZipCode)
.Run();
string generateSQL = new OSqlSelect().Select().From("Occupations").Where("OccupationID").Equals(user.OccupationID).Limit(1).ToString();
List <ODocument> result = oDB.Query(generateSQL);
if (result.Count > 0)
{
OEdge edge = oDB.Create.Edge("hasOccupation").From(odoc.ORID).To(result[0].ORID).Run();
}
}
Console.WriteLine("Successfully created Vertex Users");
#endregion
#region Load Genres
List <Genres> _listGenres = LoadGenres();
Console.WriteLine("Creating VERTEX Genres ....");
oDB.Create.Class <Genres>().Extends <OVertex>().CreateProperties <Genres>().Run();
foreach (Genres g in _listGenres)
{
oDB.Create.Vertex <Genres>(g).Run();
}
Console.WriteLine("Successfully created Vertex Occupation");
Console.WriteLine("Successfully created Vertex Genres");
#endregion
#region Load Movies
// ------------- Load Movies with Relation Genres-----------------
List <Movies> _listMovies = LoadMovies();
Console.WriteLine("Creating VERTEX Movies ....");
oDB.Create.Class <Movies>().Extends <OVertex>().CreateProperties().Run();
oDB.Create.Class("hasGenera").Extends <OEdge>().Run();
foreach (Movies g in _listMovies)
{
ODocument odoc = oDB.Create.Vertex("Movies")
.Set("MovieID", g.MovieID)
.Set("Title", g.Title)
.Run();
foreach (string genres in g.Genres)
{
string generateSQL = new OSqlSelect().Select().From("Genres").Where("description").Equals(genres).Limit(1).ToString();
List <ODocument> result = oDB.Query(generateSQL);
if (result.Count > 0)
{
OEdge edge = oDB.Create.Edge("hasGenera").From(odoc.ORID).To(result[0].ORID).Run();
}
}
}
Console.WriteLine("Successfully created Vertex Movies with relation has genres");
#endregion
//---------- Load One Million I takes almost ~20mins in Core i7 6th Gen, 2.5 GHz processor with 8GB RAM
// --- Waiting for response from OrientDB for Bulkinsert (massiveinsert) operaion support in .Net API
#region Load Ratings
oDB.Command("ALTER DATABASE custom useLightweightEdges=false");
oDB.Create.Class <Rated>().Extends <OEdge>().CreateProperties().Run();
oDB.Command("CREATE INDEX users.userID UNIQUE");
oDB.Command("CREATE INDEX Movies.movieID UNIQUE");
Console.WriteLine("Creating Ratings one Million....");
int i = 0;
System.Diagnostics.Stopwatch st = new System.Diagnostics.Stopwatch();
st.Start();
List <Rating> _listRating = LoadRatings(_PathRatings);
oDB.Transaction.Reset();
object locker = new object();
Parallel.ForEach(_listRating, r =>
{
lock (locker)
{
i++;
// we can also use OrientDB command to create Edges between two vertices
oDB.Command(" create edge rated from (select from Users where userID = " + r.userID + ") to (select from Movies where MovieID = " + r.movieID + " ) set rating =" + r.Ratings + " ");
Console.WriteLine("Creating Ratings...." + i.ToString());
}
});
st.Stop();
Console.WriteLine("Successfully Created Ratings Transaction committed...." + st.Elapsed.TotalMinutes + "mins");
#endregion
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
#endregion
Console.ReadLine();
}
