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); }