public void UpsertAllocatesNewNode() { var txn = Substitute.For <ITransaction>(); transactionFactory.NewTransaction(client).Returns(txn); txn.Query(Arg.Any <string>()).Returns(Results.Ok <string>("{\"q\":[]}")); txn.Mutate(Arg.Any <string>()).Returns(Results.Ok <IDictionary <string, string> >(new Dictionary <string, string> { { "upsertNode", "0x1bf" } })); txn.Commit().Returns(Results.Ok()); var result = client.Upsert("aPredicate", GraphValue.BuildStringValue("aString")); Assert.IsTrue(result.IsSuccess); var(node, existed) = result.Value; Assert.IsFalse(existed); switch (node) { case UIDNode uidnode: Assert.AreEqual((ulong)447, uidnode.UID); break; default: Assert.Fail("Wrong node type"); break; } }
private async Task ProcessGenres(IDgraphBatchingClient client) { // Each line in genre file looks like // // genre-name|genreID // // We'll use a client-side node named "genre<genreID>" to identify each genre node. // That name isn't persisted in the store in this example, it's just for client-side reference. using (FileStream fs = new FileStream(genreFile, FileMode.Open)) { using (StreamReader genres = new StreamReader(fs)) { string line; while ((line = genres.ReadLine()) != null) { Interlocked.Increment(ref numProcessed); var split = line.Split(new char[] { '|' }); if (split.Length == 2) { var node = await client.GetOrCreateNode("genre" + split[1]); if (node.IsSuccess) { var edge = Clients.BuildProperty(node.Value, "name", GraphValue.BuildStringValue(split[0])); if (edge.IsSuccess) { await client.BatchAddProperty(edge.Value); } } } } } } }
public void ToStringWorks() { Assert.AreEqual( "True", GraphValue.BuildBoolValue(true).ToString()); var bytes = System.Text.Encoding.UTF8.GetBytes("test"); Assert.AreEqual( System.Text.Encoding.UTF8.GetString(bytes), GraphValue.BuildBytesValue(bytes).ToString()); var now = DateTime.Now; var format = "yyyy-MM-dd'T'HH:mm:ss.fffzzz"; Assert.AreEqual( now.ToString(format, DateTimeFormatInfo.InvariantInfo), GraphValue.BuildDateValue( Encoding.UTF8.GetBytes( now.ToString(format, DateTimeFormatInfo.InvariantInfo))).ToString()); var geojson = "{'type':'Point','coordinates':[-122.4220186,37.772318]}"; var geojsonVal = GraphValue.BuildGeoValue(geojson); Assert.AreEqual( geojson, geojsonVal.ToString()); }
public void CanUseGraphValueResolver_ToResolveValues_InAJob(NodeSet.RenderExecutionModel computeType) { using (var results = new NativeArray <float>(1, Allocator.Persistent)) using (var set = new RenderGraphTests.PotentiallyJobifiedNodeSet(computeType)) { var root = set.Create <RenderPipe>(); GraphValue <float> rootValue = set.CreateGraphValue(root, RenderPipe.KernelPorts.Output); for (int i = 0; i < 100; ++i) { set.SendMessage(root, RenderPipe.SimulationPorts.Input, i); set.Update(); GraphValueReadbackJob job; job.Value = rootValue; job.Result = results; job.Resolver = set.GetGraphValueResolver(out var valueResolverDependency); set.InjectDependencyFromConsumer(job.Schedule(valueResolverDependency)); // Automatically fences before CopyWorlds. Results is accessible now. set.Update(); Assert.AreEqual(i, results[0]); Assert.AreEqual(i, set.GetValueBlocking(rootValue)); } set.Destroy(root); set.ReleaseGraphValue(rootValue); } }
public async Task UpsertHandlesTransactionConflict() { var txn = Substitute.For <ITransaction>(); transactionFactory.NewTransaction(client).Returns(txn); txn.Query(Arg.Any <string>()).Returns(Results.Ok <string>("{\"q\":[]}"), Results.Ok <string>("{\"q\":[{\"uid\":\"0x1bf\"}]}")); txn.Mutate(Arg.Any <string>()).Returns(Results.Ok <IDictionary <string, string> >(new Dictionary <string, string> { { "blank-0", "0xfff" } })); txn.Commit().Returns(Results.Fail("This transaction had a conflict")); var result = await client.Upsert("aPredicate", GraphValue.BuildStringValue("aString"), "a mutation"); Assert.IsTrue(result.IsSuccess); var(node, existed) = result.Value; Assert.IsTrue(existed); switch (node) { case UIDNode uidnode: Assert.AreEqual((ulong)447, uidnode.UID); break; default: Assert.Fail("Wrong node type"); break; } }
public void FeedbackTraversalOrder_IsCoherent([Values] NodeSet.RenderExecutionModel model) { using (var set = new NodeSet()) { set.RendererModel = model; var node1 = set.Create <KernelAdderNode>(); var node2 = set.Create <KernelAdderNode>(); GraphValue <int> node1GV = set.CreateGraphValue(node1, KernelAdderNode.KernelPorts.Output); GraphValue <int> node2GV = set.CreateGraphValue(node2, KernelAdderNode.KernelPorts.Output); set.Connect(node1, KernelAdderNode.KernelPorts.Output, node2, KernelAdderNode.KernelPorts.Input, NodeSet.ConnectionType.Feedback); for (int i = 0; i < 10; ++i) { set.SetData(node1, KernelAdderNode.KernelPorts.Input, i); set.Update(); Assert.AreEqual(i + 1, set.GetValueBlocking(node1GV)); Assert.AreEqual(i + 1, set.GetValueBlocking(node2GV)); } set.ReleaseGraphValue(node1GV); set.ReleaseGraphValue(node2GV); set.Destroy(node1, node2); } }
public void ResolvedGraphBuffers_AreReadOnly() { using (var results = new NativeArray <int>(1, Allocator.Persistent)) using (var set = new RenderGraphTests.PotentiallyJobifiedNodeSet(NodeSet.RenderExecutionModel.MaximallyParallel)) { var root = set.Create <RenderPipeAggregate>(); GraphValue <Aggregate> rootValue = set.CreateGraphValue(root, RenderPipeAggregate.KernelPorts.Output); Aggregate aggr = default; aggr.InputPlusOneI = Buffer <int> .SizeRequest(1); set.SetBufferSize(root, RenderPipeAggregate.KernelPorts.Output, aggr); set.Update(); CheckReadOnlyNess_OfResolvedGraphBuffer job; job.Value = rootValue; job.Result = results; job.Resolver = set.GetGraphValueResolver(out var valueResolverDependency); set.InjectDependencyFromConsumer(job.Schedule(valueResolverDependency)); set.Update(); Assert.AreEqual(1, results[0]); set.Destroy(root); set.ReleaseGraphValue(rootValue); } }
public void TwoNodeFeedbackLoop_Works([Values] NodeSet.RenderExecutionModel model) { using (var set = new NodeSet()) { set.RendererModel = model; var node1 = set.Create <KernelAdderNode>(); var node2 = set.Create <KernelAdderNode>(); GraphValue <int> node1GV = set.CreateGraphValue(node1, KernelAdderNode.KernelPorts.Output); GraphValue <int> node2GV = set.CreateGraphValue(node2, KernelAdderNode.KernelPorts.Output); set.Connect(node1, KernelAdderNode.KernelPorts.Output, node2, KernelAdderNode.KernelPorts.Input); set.Connect(node2, KernelAdderNode.KernelPorts.Output, node1, KernelAdderNode.KernelPorts.Input, NodeSet.ConnectionType.Feedback); // After the first update, we expect GVs 1,2. On the next update, the 2 should be fedback into node1, so we expect 3,4. Next, 5,6... for (int i = 0; i < 10; ++i) { set.Update(); Assert.AreEqual(i * 2 + 1, set.GetValueBlocking(node1GV)); Assert.AreEqual(i * 2 + 2, set.GetValueBlocking(node2GV)); } set.ReleaseGraphValue(node1GV); set.ReleaseGraphValue(node2GV); set.Destroy(node1, node2); } }
static void FillTestData() { long count = Db.SQL <long>("SELECT COUNT(g) FROM Simplified.Ring6.Graph g").First; if (count > 5) { return; } Db.Transact(() => { Simplified.Ring6.Graph gr = new Simplified.Ring6.Graph() { Name = "Graph" + (count + 1), Description = "Test graph " + (count + 1) }; string[] names = System.Globalization.CultureInfo.CurrentCulture.DateTimeFormat.MonthNames; for (int i = 0; i < names.Length; i++) { GraphValue v = new GraphValue() { Graph = gr, XValue = i + 1, XLabel = names[i], YValue = Math.Round(1.0M / ((i + 1) / (decimal)(names.Length / 2)), 4) }; } }); }
public async Task UpsertReturnsExistingNode() { var txn = Substitute.For <ITransaction>(); transactionFactory.NewTransaction(client).Returns(txn); txn.Query(Arg.Any <string>()).Returns(Results.Ok <string>("{\"q\":[{\"uid\":\"0x1bf\"}]}")); var result = await client.Upsert( "aPredicate", GraphValue.BuildStringValue("aString"), "a mutation", "aBlankName"); Assert.IsTrue(result.IsSuccess); var(node, existed) = result.Value; Assert.IsTrue(existed); switch (node) { case UIDNode uidnode: Assert.AreEqual((ulong)447, uidnode.UID); break; default: Assert.Fail("Wrong node type"); break; } }
public VertexProperty SetProperty([NotNull] string key, GraphValue value) { if (key == null) { throw new ArgumentNullException(nameof(key)); } if (value == null) { return(new VertexProperty(key, null)); } var property = new VertexProperty(key, value); if (vertexProperties.ContainsKey(key)) { vertexProperties[key] = property; } else { vertexProperties.Add(key, property); } return(property); }
public void ValuesAreRight() { Assert.AreEqual( true, GraphValue.BuildBoolValue(true).BoolValue); Assert.AreEqual( new byte[] { 0x20, 0x20, 0x20 }, GraphValue.BuildBytesValue(new byte[] { 0x20, 0x20, 0x20 }).Bytesvalue); var now = DateTime.Now; Assert.AreEqual( Encoding.UTF8.GetBytes( now.ToString("yyyy-MM-dd'T'HH:mm:ss.fffzzz", DateTimeFormatInfo.InvariantInfo)), GraphValue.BuildDateValue( Encoding.UTF8.GetBytes( now.ToString("yyyy-MM-dd'T'HH:mm:ss.fffzzz", DateTimeFormatInfo.InvariantInfo))).DateValue); var valNow = GraphValue.BuildDateValue(now); Assert.AreEqual( now.ToString("yyyy-MM-dd'T'HH:mm:ss.fffzzz", DateTimeFormatInfo.InvariantInfo), Encoding.UTF8.GetString(valNow.DateValue, 0, valNow.DateValue.Length)); Assert.AreEqual( "blaa", GraphValue.BuildDefaultValue("blaa").DefaultValue); Assert.AreEqual( 123, GraphValue.BuildDoubleValue(123).DoubleValue); Assert.AreEqual( Encoding.UTF8.GetBytes("{'type':'Point','coordinates':[-122.4220186,37.772318]}"), GraphValue.BuildGeoValue( Encoding.UTF8.GetBytes("{'type':'Point','coordinates':[-122.4220186,37.772318]}")).GeoValue); var geojson = "{'type':'Point','coordinates':[-122.4220186,37.772318]}"; var geojsonVal = GraphValue.BuildGeoValue(geojson); Assert.AreEqual( geojson, Encoding.UTF8.GetString(geojsonVal.GeoValue, 0, geojsonVal.GeoValue.Length)); Assert.AreEqual( 123, GraphValue.BuildIntValue(123).IntValue); Assert.AreEqual( "secret", GraphValue.BuildPasswordValue("secret").PasswordValue); Assert.AreEqual( "something", GraphValue.BuildStringValue("something").StringValue); }
static void Main(string[] args) { using (IDgraphMutationsClient client = DgraphDotNet.Clients.NewDgraphMutationsClient("127.0.0.1:5080")) { client.Connect("127.0.0.1:9080"); client.AlterSchema( "Username: string @index(hash) .\n" + "Password: password ."); while (true) { Console.WriteLine("Hi, please enter your new username"); var username = Console.ReadLine(); // use Upsert to test for a node and value, and create if // not already in the graph as an atomic operation. var result = client.Upsert("Username", GraphValue.BuildStringValue(username)); if (result.IsFailed) { Console.WriteLine("Something went wrong : " + result); continue; } var(node, existed) = result.Value; if (existed) { Console.WriteLine("This user already existed. Try another username."); continue; } Console.WriteLine("Hi, please enter a password for the new user"); var password = Console.ReadLine(); using (var txn = client.NewTransactionWithMutations()) { var mutation = txn.NewMutation(); var property = Clients.BuildProperty(node, "Password", GraphValue.BuildPasswordValue(password)); if (property.IsFailed) { // ... something went wrong } else { mutation.AddProperty(property.Value); var err = mutation.Submit(); if (err.IsFailed) { // ... something went wrong } } txn.Commit(); } } } }
public void NumDeletionsIsCorrect() { Mutation mut = new DgraphDotNet.Mutation(); Edge edge = new Edge(new NamedNode(1, "N1"), "AnEdge", new NamedNode(2, "N2")); Property property = new Property(new NamedNode(1, "N1"), "AProperty", GraphValue.BuildBoolValue(true)); mut.DeleteEdge(edge); mut.DeleteProperty(property); Assert.AreEqual(2, mut.NumDeletions); }
public async Task UpsertReturnsError() { var txn = Substitute.For <ITransaction>(); transactionFactory.NewTransaction(client).Returns(txn); txn.Query(Arg.Any <string>()).Returns(Results.Fail <string>("This didn't work")); var node = await client.Upsert("aPredicate", GraphValue.BuildStringValue("aString"), "a mutation"); Assert.IsTrue(node.IsFailed); }
/// <summary> /// </summary> /// <param name="key"></param> /// <param name="value"></param> /// <param name="persisted"></param> public VertexProperty([NotNull] string key, [CanBeNull] GraphValue value, bool persisted = false) { Key = key ?? throw new ArgumentNullException(nameof(key)); Value = value; Persisted = persisted; if (!persisted && key != "partition") { SetMeta("createdOn", DateTime.Now); SetMeta("createdBy", $"'{RequestContext.Get("User")}'"); } }
public void TestLong() { const long a = 123456789012345; GraphValue b = a; var c = b.ToGraphString(); Assert.Equal("123456789012345", c); GraphValue d = c; long e = d; Assert.Equal(a, e); }
public void TestBoolean() { const bool a = true; GraphValue b = a; var c = b.ToGraphString(); Assert.Equal("true", c); GraphValue d = c; bool e = d; Assert.Equal(a, e); }
public void TestString() { const string a = "Seattle, WA"; GraphValue b = a; var c = b.ToGraphString(); Assert.Equal("'Seattle, WA'", c); GraphValue d = c; string e = d; Assert.Equal(a, e); }
public void TestDateTime() { var a = DateTime.Parse("2017-10-06T11:59:51.4023776Z"); GraphValue b = a; var c = b.ToGraphString(); Assert.Equal("'2017-10-06T11:59:51.4023776Z'", c); GraphValue d = c; DateTime e = d; Assert.Equal(a, e); }
private async Task UpsertExistingNodeReturnsTrue(IDgraphClient client) { var upsertResult = await client.Upsert( nameof(User.Username), GraphValue.BuildStringValue(User1.Username), JsonConvert.SerializeObject(User1)); AssertResultIsSuccess(upsertResult); var(node, existing) = upsertResult.Value; existing.Should().BeTrue(); string.Format("0x{0:x}", node.UID).Should().Be(User1.uid); }
public void TestFloat() { const float a = 123.45f; GraphValue b = a; var c = b.ToGraphString(); Assert.Equal("123.45", c); GraphValue d = c; float e = d; Assert.Equal(a, e); }
public void TestGuid() { var a = Guid.ParseExact("1a189755-8322-443e-8cca-a5c4c83d6207", "D"); GraphValue b = a; var c = b.ToGraphString(); Assert.Equal("'1a189755-8322-443e-8cca-a5c4c83d6207'", c); GraphValue d = c; Guid e = d; Assert.Equal(a, e); }
public void TestInt() { const int a = 123; GraphValue b = a; var c = b.ToGraphString(); Assert.Equal("123", c); GraphValue d = c; int e = d; Assert.Equal(a, e); }
public void TestDouble() { const double a = 123.456754567; GraphValue b = a; var c = b.ToGraphString(); Assert.Equal("123.456754567", c); GraphValue d = c; double e = d; Assert.Equal(a, e); }
public void TestDecimal() { const decimal a = 123.456754567m; GraphValue b = a; var c = b.ToGraphString(); Assert.Equal("123.456754567", c); GraphValue d = c; decimal e = d; Assert.Equal(a, e); }
public void NumAdditonsIsCorrect() { Mutation mut = new DgraphDotNet.Mutation(); var n1 = new UIDNode(1); var n2 = new UIDNode(2); Edge edge = new Edge(n1, "AnEdge", n2); Property property = new Property(n1, "AProperty", GraphValue.BuildBoolValue(true)); mut.AddEdge(edge); mut.AddProperty(property); Assert.AreEqual(2, mut.NumAdditions); }
IEdgeResult IEdgeResult.property(string key, GraphValue value) { if (key == null) { throw new ArgumentNullException(nameof(key)); } if (value == null) { throw new ArgumentNullException(nameof(value)); } queryBuilder.Append($".property('{key}',{value.ToGraphString()})"); return(this); }
IVertexResult IVertexResult.has(string label, string key, GraphValue value) { if (label == null) { throw new ArgumentNullException(nameof(label)); } if (key == null) { throw new ArgumentNullException(nameof(key)); } queryBuilder.Append($".has('{label}','{key}',{value.ToGraphString()})"); return(this); }
/// <summary> /// Gives back the geoloactionData of all the items /// </summary> public WidgetData GetGeoLocationData(DateTime?timestamp = null) { //Create Widgetdata WidgetData geoData = new WidgetData() { KeyValue = "geo", GraphValues = new List <GraphValue>() }; //Get all persons IEnumerable <Person> persons = new ItemManager().GetAllItemsWithInformations(); if (persons == null || persons.Count() == 0) { return(geoData); } //Determine timestamp if (timestamp == null) { timestamp = DateTime.Now.AddDays(-30); } //Fill geoData foreach (Person item in persons) { //Check is district already exsists GraphValue graphValue; graphValue = geoData.GraphValues.Where(value => value.Value.ToLower().Equals(item.District.ToLower())).SingleOrDefault(); int numberOfInfos = item.Informations.Where(info => info.CreationDate >= timestamp).Count(); if (graphValue == null) { graphValue = new GraphValue() { Value = item.District, NumberOfTimes = numberOfInfos }; geoData.GraphValues.Add(graphValue); } else { graphValue.NumberOfTimes += numberOfInfos; } } return(geoData); }
static void FillTestData() { long count = Db.SQL<long>("SELECT COUNT(g) FROM Simplified.Ring6.Graph g").First; if (count > 5) { return; } Db.Transact(() => { Simplified.Ring6.Graph gr = new Simplified.Ring6.Graph() { Name = "Graph" + (count + 1), Description = "Test graph " + (count + 1) }; string[] names = System.Globalization.CultureInfo.CurrentCulture.DateTimeFormat.MonthNames; for (int i = 0; i < names.Length; i++) { GraphValue v = new GraphValue() { Graph = gr, XValue = i + 1, XLabel = names[i], YValue = Math.Round(1.0M / ((i + 1) / (decimal)(names.Length / 2)), 4) }; } }); }