public void AddTitanVertexCentricIndex()
{
WeaverEdgeSchema pkp = vSchema.GetEdgeSchema(typeof(PersonKnowsPerson).Name);
WeaverEdgeSchema rhp = vSchema.GetEdgeSchema(typeof(RootHasPerson).Name);
Assert.AreEqual(2, vProp.AddTitanVertexCentricIndex(pkp), "Incorrect count 2.");
Assert.AreEqual(3, vProp.AddTitanVertexCentricIndex(rhp), "Incorrect count 3.");
}
public void InVertexConnFail()
{
var rs = new WeaverEdgeSchema(null, "TestDoesPass", "TDP", "Does", null);
WeaverTestUtil.CheckThrows <WeaverException>(true,
() => rs.InVertexConn = WeaverEdgeConn.OutOne
);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
protected override void SetUp()
{
base.SetUp();
vSchema = new TestSchema();
vPlc = vSchema.GetEdgeSchema(typeof(PersonLikesCandy).Name);
vProp = new WeaverTitanPropSchema("TestProp", "TP", typeof(string));
vProp.AddTitanVertexCentricIndex(vPlc);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public int AddTitanVertexCentricIndex(WeaverEdgeSchema pEdge)
{
if (vVertCent.ContainsKey(pEdge.DbName))
{
throw new WeaverException(GetType().Name, DbName, "A vertex-centric index was already " +
"added for the edge named '" + pEdge.DbName + "'.");
}
vVertCent.Add(pEdge.DbName, pEdge);
return(vVertCent.Keys.Count);
}
public void Constructor()
{
var outVert = new WeaverVertexSchema("FROM", "F");
var inVert = new WeaverVertexSchema("TO", "T");
var rs = new WeaverEdgeSchema(outVert, "FromLikesTo", "FLT", "Likes", inVert);
Assert.AreEqual(outVert, rs.OutVertex, "Incorrect FromNode.");
Assert.AreEqual("FromLikesTo", rs.Name, "Incorrect Name.");
Assert.AreEqual(inVert, rs.InVertex, "Incorrect ToNode.");
Assert.AreEqual(WeaverEdgeConn.OutZeroOrMore, rs.OutVertexConn, "Incorrect FromNodeComm.");
Assert.AreEqual(WeaverEdgeConn.InZeroOrMore, rs.InVertexConn, "Incorrect ToNodeComm.");
}
public void GetTitanVertexCentricIndexes()
{
WeaverEdgeSchema pkp = vSchema.GetEdgeSchema(typeof(PersonKnowsPerson).Name);
WeaverEdgeSchema rhp = vSchema.GetEdgeSchema(typeof(RootHasPerson).Name);
vProp.AddTitanVertexCentricIndex(pkp);
vProp.AddTitanVertexCentricIndex(rhp);
WeaverEdgeSchema[] result = vProp.GetTitanVertexCentricIndexes();
Assert.NotNull(result, "Result should be filled.");
Assert.AreEqual(3, result.Length, "Incorrect result length.");
WeaverEdgeSchema[] expect = new[] { vPlc, pkp, rhp };
Assert.AreEqual(expect, result, "Incorrect result contents.");
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public TestSchema()
{
Vertices = new List <WeaverVertexSchema>();
Edges = new List <WeaverEdgeSchema>();
WeaverPropSchema ps;
////
var vert = new WeaverVertexSchema("TestVertex", "Tn");
Vertices.Add(vert);
ps = new WeaverPropSchema("Id", "Id", typeof(string));
vert.Props.Add(ps);
ps = new WeaverPropSchema("Name", Vertex_Name, typeof(string));
vert.Props.Add(ps);
////
var item = new WeaverVertexSchema("TestItem", "Ti");
Vertices.Add(item);
ps = new WeaverPropSchema("Value", "Val", typeof(string));
item.Props.Add(ps);
////
var root = new WeaverVertexSchema("Root", "Root");
Vertices.Add(root);
////
var per = new WeaverVertexSchema("Person", "Per");
per.BaseVertex = vert;
Vertices.Add(per);
ps = new WeaverPropSchema("PersonId", Person_PersonId, typeof(int));
per.Props.Add(ps);
ps = new WeaverPropSchema("IsMale", Person_IsMale, typeof(bool));
per.Props.Add(ps);
ps = new WeaverPropSchema("Age", Person_Age, typeof(float));
per.Props.Add(ps);
ps = new WeaverPropSchema("Note", Person_Note, typeof(string));
per.Props.Add(ps);
////
var can = new WeaverVertexSchema("Candy", "Can");
can.BaseVertex = vert;
Vertices.Add(can);
ps = new WeaverPropSchema("CandyId", "CanId", typeof(int));
can.Props.Add(ps);
ps = new WeaverPropSchema("IsChocolate", Candy_IsChocolate, typeof(bool));
can.Props.Add(ps);
ps = new WeaverPropSchema("Calories", Candy_Calories, typeof(int));
can.Props.Add(ps);
////
var rootHasPer = new WeaverEdgeSchema(root, "RootHasPerson", RootHasPerson, "Has", per);
Edges.Add(rootHasPer);
////
var rootHasCan = new WeaverEdgeSchema(root, "RootHasCandy", "RHC", "Has", per);
Edges.Add(rootHasCan);
////
var perKnowsPer = new WeaverEdgeSchema(
per, "PersonKnowsPerson", PersonKnowsPerson, "Knows", per);
Edges.Add(perKnowsPer);
ps = new WeaverPropSchema("MetOnDate", "Met", typeof(string));
perKnowsPer.Props.Add(ps);
ps = new WeaverPropSchema("Amount", "Amt", typeof(float));
perKnowsPer.Props.Add(ps);
////
var perLikesCan = new WeaverEdgeSchema(
root, "PersonLikesCandy", PersonLikesCandy, "Likes", per);
Edges.Add(perLikesCan);
ps = new WeaverPropSchema("TimesEaten", PersonLikesCandy_TimesEaten, typeof(int));
perLikesCan.Props.Add(ps);
ps = new WeaverPropSchema("Enjoyment", PersonLikesCandy_Enjoyment, typeof(float));
perLikesCan.Props.Add(ps);
ps = new WeaverPropSchema("Notes", PersonLikesCandy_Notes, typeof(string));
perLikesCan.Props.Add(ps);
}
/*--------------------------------------------------------------------------------------------*/
public bool HasTitanVertexCentricIndex(WeaverEdgeSchema pEdge)
{
return(HasTitanVertexCentricIndex(pEdge.DbName));
}
