public IEnumerable <Triple> O(TripleObject o, Triple c)
{
if (c == null)
{
return(O(o));
}
var oh = KeySegments.GetNameOKeyObject(_name, o);
var startS = KeyConfig.ConcatBytes(oh, KeyConfig.ByteZero);
var endS = KeyConfig.ConcatBytes(oh, KeyConfig.ByteOne);
var(_, _, oKey) = new KeySegments(_name, c).GetKeys();
var continuation = KeyConfig.ConcatBytes(oKey, KeyConfig.ByteOne);
if (KeyConfig.ByteCompare(continuation, startS) < 0)
{
throw new InvalidOperationException("Invalid continuation token. Before range");
}
else if (KeyConfig.ByteCompare(continuation, endS) > 0)
{
return(Enumerable.Empty <Triple>());
}
return(new RocksEnumerable(_db, continuation, endS, (Iterator it) => { return it.Next(); }));
}
public void Assert_Exists_Returns()
{
var rsp1 = _set.Assert("a", "b", "c");
Assert.AreEqual(rsp1, true);
var rsp2 = _set.Assert("a", "b", TripleObject.FromData("c"));
Assert.AreEqual(rsp2, true);
var exist1 = _set.Exists("a", "b", "c");
Assert.AreEqual(exist1, true);
var exist2 = _set.Exists("a", "b", TripleObject.FromId("c"));
Assert.AreEqual(exist2, true);
var exist3 = _set.Exists("a", "b", "d");
Assert.AreEqual(exist3, false);
var exist4 = _set.Exists("b", "b", "c");
Assert.AreEqual(exist4, false);
var exist5 = _set.Exists("a", "b", "d");
Assert.AreEqual(exist5, false);
var rsp3 = _set.Assert("x", "y", "z");
var exists6 = _set.Exists("x", "y", "z");
Assert.AreEqual(exists6, true);
var exists7 = _set.Exists("x", "y", TripleObject.FromData("z"));
Assert.AreEqual(exists7, false);
}
public void Query_Value_LE_Multiple_Returns()
{
var(set, _, _) = StoreProcessor.GetGraphs("app1");
var query = new ObjectQueryModel
{
Filter = new Dictionary <string, QueryUnit>()
{
["name"] = new QueryUnit {
Operator = "contains", Value = "name"
},
["age"] = new QueryUnit {
Operator = "le", Value = 20
}
},
PageSize = 10
};
var rsp = new ObjectQueryExecutor().Query(query, (RocksGraph)set);
var values = rsp.Values.ToArray();
var testTriple1 = new Triple("100", "name", TripleObject.FromData("name100"));
var testTriple2 = new Triple("500", "name", TripleObject.FromData("name500"));
CollectionAssert.Contains(values, testTriple1);
CollectionAssert.Contains(values, testTriple2);
Assert.AreEqual(2, rsp.Values.Count());
Assert.AreEqual(null, rsp.Continuation);
}
private bool SubjectMatch(string t, IStoreGraph graph, ObjectQueryModel target)
{
if (target.Id != null)
{
return(t == target.Id);
}
var result = true;
foreach (var filter in target.Filter)
{
switch (filter.Value.Operator)
{
case "eq":
result &= graph.Exists(t, filter.Key, TripleObject.FromData(filter.Value.Value.ToString()));
break;
case "gt":
case "ge":
case "lt":
case "le":
case "contains":
var match = graph.SP(t, filter.Key).Any(Comparator(filter.Value));
result &= match;
break;
default:
throw _storeErrors.UnknownComparator;
}
}
return(result);
}
private TripleObject BuildFromTriple(Instruction fromInstruction,
string fromInstanceOwnerKey,
MethodDefinition parentMethod)
{
var tripleObj = new TripleObject();
tripleObj.Instruction = fromInstruction;
var fromObjectType = InstructionKeyService.GetFromObjectType(fromInstruction);
tripleObj.ObjectType = fromObjectType;
if (fromObjectType == ObjectType.Argument)
{
int fromArgumentIndex = (int)DecompilerService.GetPosition(fromInstruction);
tripleObj.ObjectKey = InstructionKeyService.GetObjectKey(fromInstruction, fromObjectType, parentMethod, fromArgumentIndex);
}
else
{
tripleObj.ObjectKey = InstructionKeyService.GetObjectKey(fromInstruction, fromObjectType, parentMethod);
}
tripleObj.InstructionKey = InstructionKeyService.GetInstructionKey(fromInstruction, parentMethod);
tripleObj.OwnerTypeCategory = InstructionKeyService.GetTypeCategory(fromInstruction);
tripleObj.OwnerTypeKey = InstructionKeyService.GetTypeKey(fromInstruction);
tripleObj.InheritsFromConcreteClass = InstructionKeyService.GetConcreteInheritance(fromInstruction);
tripleObj.InstanceOwnerKey = fromInstanceOwnerKey;
return(tripleObj);
}
private TripleObject BuildToTriple(Instruction toInstruction,
string toInstanceOwnerKey,
MethodDefinition parentMethod,
int?toArgumentCounter = null)
{
var tripleObj = new TripleObject();
tripleObj.Instruction = toInstruction;
var toObjectType = InstructionKeyService.GetToObjectType(toInstruction);
tripleObj.ObjectType = toObjectType;
tripleObj.InstanceOwnerKey = toInstanceOwnerKey;
if (toObjectType == ObjectType.Argument)
{
var methodCallReference = (MethodReference)toInstruction.Operand;
tripleObj.ObjectKey = InstructionKeyService.GetObjectKey(toInstruction, toObjectType, methodCallReference, toArgumentCounter.Value);
}
else
{
tripleObj.ObjectKey = InstructionKeyService.GetObjectKey(toInstruction, toObjectType, parentMethod);
}
tripleObj.InstructionKey = InstructionKeyService.GetInstructionKey(toInstruction, parentMethod);
tripleObj.OwnerTypeCategory = InstructionKeyService.GetTypeCategory(toInstruction);
tripleObj.OwnerTypeKey = InstructionKeyService.GetTypeKey(toInstruction);
tripleObj.InheritsFromConcreteClass = InstructionKeyService.GetConcreteInheritance(toInstruction);
return(tripleObj);
}
public void GetBy_S_Returns()
{
_set.Assert("s1", "b2", "c2");
_set.Assert("s1", "b3", TripleObject.FromData("c3"));
_set.Assert("s1", "b1", "c1");
_set.Assert("s2", "b2", "c2");
_set.Assert("s2", "b3", "c3");
_set.Assert("s3", "b1", "c1");
var byS1 = _set.S("s1").ToArray();
Assert.AreEqual(byS1.Count(), 3);
CollectionAssert.Contains(byS1, new Triple("s1", "b1", "c1"));
CollectionAssert.Contains(byS1, new Triple("s1", "b2", "c2"));
CollectionAssert.Contains(byS1, new Triple("s1", "b3", TripleObject.FromData("c3")));
var byS2 = _set.S("s2").ToArray();
Assert.AreEqual(byS2.Count(), 2);
CollectionAssert.Contains(byS2, new Triple("s2", "b2", "c2"));
CollectionAssert.Contains(byS2, new Triple("s2", "b3", "c3"));
var byS3 = _set.S("s3").ToArray();
Assert.AreEqual(byS3.Count(), 1);
CollectionAssert.Contains(byS3, new Triple("s3", "b1", "c1"));
var byS4 = _set.S("s4").ToArray();
Assert.AreEqual(byS4.Count(), 0);
}
public void To_Patch()
{
var item = new
{
id = "100",
name = "name101",
contains = new
{
name = "name200",
values = new object[] {
new
{
age = (int?)null,
}
}
}
};
var json = JObject.FromObject(item);
var graph = TripleConverter.FromJson(json);
var expected = new List <Triple>();
expected.Add(new Triple("100", "name", TripleObject.FromData("name101")));
expected.Add(new Triple("100", "contains", "100#contains"));
expected.Add(new Triple("100#contains", "name", TripleObject.FromData("name200")));
expected.Add(new Triple("100#contains", "values", "100#contains#values#0"));
expected.Add(new Triple("100#contains#values#0", "age", TripleObject.FromData(null)));
CollectionAssert.AreEqual(expected, graph.ToArray(), new UnorderedTripleComparer());
}
public IEnumerable <Triple> OS(TripleObject o, string s)
{
var oh = KeySegments.GetNameOKeyObjectSubject(_name, o, s);
var startS = KeyConfig.ConcatBytes(oh, KeyConfig.ByteZero);
var endS = KeyConfig.ConcatBytes(oh, KeyConfig.ByteOne);
return(new RocksEnumerable(_db, startS, endS, (Iterator it) => { return it.Next(); }));
}
public IEnumerable <Triple> PO(string p, TripleObject o)
{
var ph = KeySegments.GetNamePKeyPredicateObject(_name, p, o);
var startS = KeyConfig.ConcatBytes(ph, KeyConfig.ByteZero);
var endS = KeyConfig.ConcatBytes(ph, KeyConfig.ByteOne);
return(new RocksEnumerable(_db, startS, endS, (Iterator it) => { return it.Next(); }));
}
public static byte[] ToBytes(this TripleObject o)
{
var oBytes = KeyConfig.GetBytes(o.ToValue());
var isIdBytes = o.IsID ? KeyConfig.ByteTrue : KeyConfig.ByteFalse;
var typeBytes = KeyConfig.GetBytes((int)o.TokenType);
// index is not converted
return(KeyConfig.ConcatBytes(isIdBytes, typeBytes, oBytes));
}
public KeySegments(string name, string s, string p, TripleObject o)
{
_name = KeyConfig.GetBytes(name);
S = KeyConfig.GetBytes(s);
P = KeyConfig.GetBytes(p);
O = KeyConfig.GetBytes(o.ToValue());
IsId = o.IsID ? KeyConfig.ByteTrue : KeyConfig.ByteFalse;
Index = BitConverter.GetBytes(o.Index);
}
public static byte[] GetNameOKeyObject(string name, TripleObject o)
{
var nameBytes = KeyConfig.GetBytes(name);
var z = KeyConfig.ByteZero;
var oBytes = KeyConfig.GetBytes(o.ToValue());
var isIdBytes = o.IsID ? KeyConfig.ByteTrue : KeyConfig.ByteFalse;
return(KeyConfig.ConcatBytes(nameBytes, KeyConfig.ByteO, z, isIdBytes, z, oBytes));
}
public bool Exists(string s, string p, TripleObject o)
{
var keySegments = new KeySegments(_name, s, p, o);
var oPrefix = keySegments.GetOPrefix();
var start = KeyConfig.ConcatBytes(oPrefix, KeyConfig.ByteZero);
var end = KeyConfig.ConcatBytes(oPrefix, KeyConfig.ByteOne);
var oEnumerable = new RocksEnumerable(_db, start, end, (it) => it.Next());
return(oEnumerable.Any());
}
private bool Domain(DisjointUnion graph, IGraph meta)
{
var any = false;
var rules = meta.P(Constants.Domain);
foreach (var rule in rules)
{
var triples = graph.P(rule.Subject);
foreach (var t in triples)
{
any |= graph.Assert(t.Subject, Constants.Type, TripleObject.FromData(rule.Object.ToValue()));
}
}
return(any);
}
public bool Retract(string s, string p, TripleObject o)
{
if (!Exists(s, p, o))
{
return(false);
}
var(sKey, pKey, oKey) = new KeySegments(_name, s, p, o).GetKeys();
using (var batch = new WriteBatch()) {
batch.Delete(sKey);
batch.Delete(pKey);
batch.Delete(oKey);
_db.Write(batch, _writeOptions);
}
return(true);
}
private bool SubClassOf(IGraph graph, IGraph meta)
{
var any = false;
var rules = meta.P(Constants.SubClassOf);
foreach (var rule in rules)
{
var triples = graph.PO(Constants.Type, TripleObject.FromData(rule.Subject));
foreach (var t in triples)
{
any |= graph.Assert(t.Subject, Constants.Type, TripleObject.FromData(rule.Object.ToValue()));
}
}
return(any);
}
public void Query_Value_Id_Returns()
{
var(set, _, _) = StoreProcessor.GetGraphs("app1");
var query = new ObjectQueryModel
{
Id = "300",
};
var rsp = new ObjectQueryExecutor().Query(query, (RocksGraph)set);
var values = rsp.Values.ToArray();
var testTriple = new Triple("300", "age", TripleObject.FromData(30));
CollectionAssert.Contains(values, testTriple);
Assert.AreEqual(1, values.Count());
Assert.AreEqual(rsp.Continuation, null);
}
public void GetBy_OS_Returns()
{
_set.Assert("s1", "p1", "o1");
_set.Assert("s1", "p2", "o1");
_set.Assert("s1", "p3", "o1");
_set.Assert("s1", "p1", TripleObject.FromData("o1"));
_set.Assert("s1", "p2", TripleObject.FromData("o1"));
_set.Assert("s2", "p1", TripleObject.FromData("o1"));
_set.Assert("s2", "p1", "o2");
_set.Assert("s3", "p1", "o2");
_set.Assert("s2", "p3", "c2");
_set.Assert("s2", "p3", "c3");
_set.Assert("s2", "p3", "c3"); // duplicate assert
_set.Assert("s3", "p5", "c1");
var o1s1 = _set.OS("o1", "s1").ToArray();
Assert.AreEqual(o1s1.Count(), 3);
CollectionAssert.Contains(o1s1, new Triple("s1", "p1", "o1"));
CollectionAssert.Contains(o1s1, new Triple("s1", "p2", "o1"));
CollectionAssert.Contains(o1s1, new Triple("s1", "p3", "o1"));
// without the fOSP index the below is disabled
// ############################################
// var o1vs1 = _set.OS(TripleObject.FromData("o1"), "s1").ToArray();
// Assert.AreEqual(o1vs1.Count(), 2);
// CollectionAssert.Contains(o1vs1, new Triple("s1", "p1", TripleObject.FromData("o1")));
// CollectionAssert.Contains(o1vs1, new Triple("s1", "p2", TripleObject.FromData("o1")));
var c3s2 = _set.OS("c3", "s2").ToArray();
Assert.AreEqual(c3s2.Count(), 1);
CollectionAssert.Contains(c3s2, new Triple("s2", "p3", "c3"));
var o0s1 = _set.OS("o0", "s1").ToArray();
Assert.AreEqual(o0s1.Count(), 0);
var o7s2 = _set.OS("o7", "s2").ToArray();
Assert.AreEqual(o7s2.Count(), 0);
}
public void Get_P_Returns()
{
_set.Assert("s1", "p1", "o1");
_set.Assert("s1", "p1", TripleObject.FromData("o1"));
_set.Assert("s2", "p1", "c1");
_set.Assert("s2", "p3", "c2");
_set.Assert("s2", "p3", "c3");
_set.Assert("s2", "p3", "c3"); // duplicate assert
_set.Assert("s3", "p5", "c1");
var p = _set.P().ToArray();
Assert.AreEqual(p.Count(), 3);
CollectionAssert.Contains(p, "p1");
CollectionAssert.Contains(p, "p3");
CollectionAssert.Contains(p, "p5");
}
public void Convert_To_Byte_Roundtrip_Returns()
{
var o1 = new TripleObject("abc", true, JTokenType.String, null);
var bytes1 = o1.ToBytes();
var roundtripped = bytes1.ToTripleObject();
Assert.IsTrue(roundtripped.IsID);
Assert.AreEqual(o1.Value, roundtripped.Value);
Assert.AreEqual(o1.TokenType, roundtripped.TokenType);
var o2 = TripleObject.FromData(5);
var bytes2 = o2.ToBytes();
var roundtripped2 = bytes2.ToTripleObject();
Assert.IsFalse(roundtripped2.IsID);
Assert.AreEqual(o2.Value, roundtripped2.Value);
Assert.AreEqual(o2.TokenType, roundtripped2.TokenType);
}
private IEnumerable <Triple> CreateConstraint(IStoreGraph graph, string key, QueryUnit value, Triple continuation)
{
var input = new JValue(value.Value);
switch (value.Operator)
{
case "eq":
return(graph.PO(key, TripleObject.FromData(value.Value.ToString()), continuation));
case "gt":
case "ge":
case "lt":
case "le":
case "contains":
return(graph.P(key, continuation).Where(Comparator(value)));
default:
throw _storeErrors.UnknownComparator;
}
}
public void To_Triples()
{
var item = new
{
id = "100",
name = "name100",
age = (int)20,
contains = new
{
name = "name200",
values = new object[] {
new
{
name = "name300",
age = (int)30,
},
new
{
name = "name400"
}
}
}
};
var json = JObject.FromObject(item);
var graph = TripleConverter.FromJson(json);
var expected = new List <Triple>();
expected.Assert("100", "name", TripleObject.FromData("name100"));
expected.Assert("100", "age", TripleObject.FromData(20));
expected.Assert("100", "contains", "100#contains");
expected.Assert("100#contains", "name", TripleObject.FromData("name200"));
expected.Assert("100#contains", "values", "100#contains#values#0");
expected.Assert("100#contains#values#0", "name", TripleObject.FromData("name300"));
expected.Assert("100#contains#values#0", "age", TripleObject.FromData(30));
expected.Assert("100#contains", "values", "100#contains#values#1");
expected.Assert("100#contains#values#1", "name", TripleObject.FromData("name400"));
CollectionAssert.AreEqual(expected, graph.ToArray(), new UnorderedTripleComparer());
}
public void GetBy_O_Returns()
{
_set.Assert("s1", "p1", "o1");
_set.Assert("s1", "p1", TripleObject.FromData("o1"));
_set.Assert("s2", "p1", TripleObject.FromData("o1"));
_set.Assert("s2", "p1", "o2");
_set.Assert("s3", "p1", "o2");
_set.Assert("s2", "p3", "c2");
_set.Assert("s2", "p3", "c3");
_set.Assert("s2", "p3", "c3"); // duplicate assert
_set.Assert("s3", "p5", "c1");
var o1 = _set.O("o1").ToArray();
Assert.AreEqual(o1.Count(), 1);
CollectionAssert.Contains(o1, new Triple("s1", "p1", "o1"));
// without the fOSP index the below is disabled
// ############################################
// var o1v = _set.O(TripleObject.FromData("o1")).ToArray();
// Assert.AreEqual(o1v.Count(), 2);
// CollectionAssert.Contains(o1v, new Triple("s1", "p1", TripleObject.FromData("o1")));
// CollectionAssert.Contains(o1v, new Triple("s2", "p1", TripleObject.FromData("o1")));
var c3 = _set.O("c3").ToArray();
Assert.AreEqual(c3.Count(), 1);
CollectionAssert.Contains(c3, new Triple("s2", "p3", "c3"));
var c0 = _set.O("c0").ToArray();
Assert.AreEqual(c0.Count(), 0);
var c5 = _set.O("c5").ToArray();
Assert.AreEqual(c5.Count(), 0);
}
public void Query_Incoming_Level_Returns()
{
var(set, _, _) = StoreProcessor.GetGraphs("app2");
var query = new ObjectQueryModel
{
Filter = new Dictionary <string, QueryUnit>()
{
["name"] = new QueryUnit {
Operator = "contains", Value = "name"
}
},
PageSize = 10,
HasSubject = new LinkQuery[]
{
new LinkQuery
{
Path = "*",
Level = 3,
Target = new ObjectQueryModel
{
Filter = new Dictionary <string, QueryUnit>()
{
["name"] = new QueryUnit {
Operator = "eq", Value = "root1"
}
}
}
}
}
};
var rsp = new ObjectQueryExecutor().Query(query, set);
var values = rsp.Values.Select(x => x.Subject).ToArray();
CollectionAssert.AreEqual(values, new string[] { "i00", "i01", "i02", "i03", "i04", "i05", "i06", "i07", "i08", "i09" });
Assert.AreEqual((Continuation) new Triple("i09", "name", TripleObject.FromData("name09")), rsp.Continuation);
}
public void GetBy_P_Returns()
{
_set.Assert("s1", "p1", "o1");
_set.Assert("s1", "p1", TripleObject.FromData("o1"));
_set.Assert("s2", "p1", "c1");
_set.Assert("s2", "p3", "c2");
_set.Assert("s2", "p3", "c3");
_set.Assert("s2", "p3", "c3"); // duplicate assert
_set.Assert("s3", "p5", "c1");
var byP1 = _set.P("p1").ToArray();
Assert.AreEqual(byP1.Count(), 3);
CollectionAssert.Contains(byP1, new Triple("s1", "p1", "o1"));
CollectionAssert.Contains(byP1, new Triple("s2", "p1", "c1"));
CollectionAssert.Contains(byP1, new Triple("s1", "p1", TripleObject.FromData("o1")));
var byP3 = _set.P("p3").ToArray();
Assert.AreEqual(byP3.Count(), 2);
CollectionAssert.Contains(byP3, new Triple("s2", "p3", "c2"));
CollectionAssert.Contains(byP3, new Triple("s2", "p3", "c3"));
var byP5 = _set.P("p5").ToArray();
Assert.AreEqual(byP5.Count(), 1);
CollectionAssert.Contains(byP5, new Triple("s3", "p5", "c1"));
var byP0 = _set.P("p0").ToArray();
Assert.AreEqual(byP0.Count(), 0);
var byP7 = _set.P("p7").ToArray();
Assert.AreEqual(byP7.Count(), 0);
}
public void GetBy_PO_Returns()
{
_set.Assert("s1", "p1", "o1");
_set.Assert("s1", "p1", TripleObject.FromData("o1"));
_set.Assert("s2", "p1", TripleObject.FromData("o1"));
_set.Assert("s2", "p1", "o2");
_set.Assert("s3", "p1", "o2");
_set.Assert("s2", "p3", "c2");
_set.Assert("s2", "p3", "c3");
_set.Assert("s2", "p3", "c3"); // duplicate assert
_set.Assert("s3", "p5", "c1");
var p1o1 = _set.PO("p1", "o1").ToArray();
Assert.AreEqual(p1o1.Count(), 1);
CollectionAssert.Contains(p1o1, new Triple("s1", "p1", "o1"));
var p1o1v = _set.PO("p1", TripleObject.FromData("o1")).ToArray();
Assert.AreEqual(p1o1v.Count(), 2);
CollectionAssert.Contains(p1o1v, new Triple("s1", "p1", TripleObject.FromData("o1")));
CollectionAssert.Contains(p1o1v, new Triple("s2", "p1", TripleObject.FromData("o1")));
var p3c3 = _set.PO("p3", "c3").ToArray();
Assert.AreEqual(p3c3.Count(), 1);
CollectionAssert.Contains(p3c3, new Triple("s2", "p3", "c3"));
var byP0 = _set.PO("p0", "s1").ToArray();
Assert.AreEqual(byP0.Count(), 0);
var byP7 = _set.PO("p7", "s1").ToArray();
Assert.AreEqual(byP7.Count(), 0);
}
private IEnumerable <Triple> ApplyConstraint(IEnumerable <Triple> rsp, IGraph graph, string key, QueryUnit value)
{
var input = new JValue(value.Value);
switch (value.Operator)
{
case "eq":
return(rsp.Where(x => graph.Exists(x.Subject, key, TripleObject.FromData(value.Value.ToString()))));
case "gt":
case "ge":
case "lt":
case "le":
case "contains":
return(rsp.Where((x) => {
var t = graph.SP(x.Subject, key).Any(Comparator(value));
return t;
}));
default:
throw _storeErrors.UnknownComparator;
}
}
public IEnumerable <Triple> PO(string p, TripleObject o, Triple c)
{
if (c == null)
{
return(PO(p, o));
}
var ph = KeySegments.GetNamePKeyPredicateObject(Name, p, o);
var startS = KeyConfig.ConcatBytes(ph, KeyConfig.ByteZero);
var endS = KeyConfig.ConcatBytes(ph, KeyConfig.ByteOne);
var(_, pKey, _) = new KeySegments(Name, c).GetKeys();
var continuation = KeyConfig.ConcatBytes(pKey, KeyConfig.ByteOne);
if (KeyConfig.ByteCompare(continuation, startS) < 0)
{
throw new InvalidOperationException("Invalid continuation token. Before range");
}
else if (KeyConfig.ByteCompare(continuation, endS) > 0)
{
return(Enumerable.Empty <Triple>());
}
return(new RocksEnumerable(_db, continuation, endS, (Iterator it) => { return it.Next(); }));
}
public void GetBy_SP_Returns()
{
_set.Assert("s2", "b2", "c2");
_set.Assert("s2", "b2", "c2"); // duplicate assert
_set.Assert("s2", "b3", "c3");
_set.Assert("s1", "b2", "c21");
_set.Assert("s1", "b2", "c22");
_set.Assert("s1", "b3", TripleObject.FromData("c3"));
_set.Assert("s1", "b1", "c1");
_set.Assert("s3", "b1", "c1");
var byS1B2 = _set.SP("s1", "b2").ToArray();
Assert.AreEqual(byS1B2.Count(), 2);
CollectionAssert.Contains(byS1B2, new Triple("s1", "b2", "c21"));
CollectionAssert.Contains(byS1B2, new Triple("s1", "b2", "c22"));
var byS1B3 = _set.SP("s1", "b3").ToArray();
Assert.AreEqual(byS1B3.Count(), 1);
CollectionAssert.Contains(byS1B3, new Triple("s1", "b3", TripleObject.FromData("c3")));
var byS1B4 = _set.SP("s1", "b4").ToArray();
Assert.AreEqual(byS1B4.Count(), 0);
var byS1B0 = _set.SP("s1", "b0").ToArray();
Assert.AreEqual(byS1B0.Count(), 0);
var byS0B1 = _set.SP("s0", "b1").ToArray();
Assert.AreEqual(byS0B1.Count(), 0);
}
