public void GremlinHasNextAppendStepToTypedRelationshipQuery() { var query = new NodeReference(123).OutE<object>().GremlinHasNext(); Assert.IsInstanceOf<IGremlinRelationshipQuery<object>>(query); Assert.AreEqual("g.v(p0).outE.hasNext()", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); }
public void ExhaustMergeAppendStepToNodeQuery() { var query = new NodeReference(123).OutV<object>().ExhaustMerge(); Assert.IsInstanceOf<IGremlinNodeQuery<object>>(query); Assert.AreEqual("g.v(p0).outV.exhaustMerge", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); }
public void GremlinDistinctAppendStepToRelationshipQuery() { var query = new NodeReference(123).OutE().GremlinDistinct(); Assert.IsInstanceOf<IGremlinRelationshipQuery>(query); Assert.AreEqual("g.v(p0).outE.dedup()", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); }
public void InShouldAppendStepToGremlinQueryWithNoFilter() { var query = new NodeReference(123).In<object>("REL"); Assert.AreEqual("g.v(p0).in(p1)", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); Assert.AreEqual("REL", query.QueryParameters["p1"]); }
public void ExhaustMergeAppendStepToRelationshipQuery() { var query = new NodeReference(123).OutE().ExhaustMerge(); Assert.IsInstanceOf<IGremlinRelationshipQuery>(query); Assert.AreEqual("g.v(p0).outE.exhaustMerge", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); }
public void BackVShouldAppendStep() { var query = new NodeReference(123).BackV<object>("foo"); Assert.AreEqual("g.v(p0).back(p1)", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); Assert.AreEqual("foo", query.QueryParameters["p1"]); }
public void GremlinDistinctAppendStepToNodeQuery() { var query = new NodeReference(123).OutV<object>().GremlinDistinct(); Assert.IsInstanceOf<IGremlinNodeQuery<object>>(query); Assert.AreEqual("g.v(p0).outV.dedup()", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); }
public void ClientShouldReturnClientFromReference() { var client = Substitute.For<IGraphClient>(); var reference = new NodeReference<object>(123, client); var node = new Node<object>(new object(), reference); Assert.AreEqual(client, ((IGremlinQuery)node).Client); }
// graph constructor is marked INTERNAL because we want the client to use the // static class factory method CreateGraph(), which redirects here after doing checks. // For opening existing graphs, // we provide another method called OpenGraph() which redirects here also. internal GlGraph(string graph_name) { bool creating_new = !GlobalsGraphAdmin.AllGraphs().Contains(graph_name); _GlNodeRef = GlobalsGraphAdmin.ActiveConnection().CreateNodeReference(graph_name); if (creating_new) _GlNodeRef.Set(GlobalsGraphAdmin.GL_GRAPH_FLAG); // format identifier, causes persistence else { // opening an existing graph. Start by initializing the existing nodes string loop_node_guid = _GlNodeRef.NextSubscript(GlobalsGraphAdmin.GL_NODES_SUBSCRIPT, ""); while (loop_node_guid != "") { Guid new_guid = Guid.Empty; if (Guid.TryParse(loop_node_guid, out new_guid)) AllNodesByGuid.Add(new_guid, new GlGraphNode(this, new_guid)); else _GlNodeRef.Kill(GlobalsGraphAdmin.GL_NODES_SUBSCRIPT, loop_node_guid); // clean up bad data loop_node_guid = _GlNodeRef.NextSubscript(GlobalsGraphAdmin.GL_NODES_SUBSCRIPT, loop_node_guid); } // now loop again and load the edges foreach (GlGraphNode loop_node in AllNodes) { loop_node.InitializeEdges(); } } }
public void OutVShouldAppendStepToNodeReference() { var node = new NodeReference(123); var query = node.OutV<object>(); Assert.AreEqual("g.v(p0).outV", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); }
public void EmitPropertyShouldAppendStepToTypedRelationshipQuery() { var query = new NodeReference(123).OutE<object>().EmitProperty("foo"); Assert.IsInstanceOf<IGremlinRelationshipQuery<object>>(query); Assert.AreEqual("g.v(p0).outE.foo", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); }
/// <summary> /// Represents a request for sensor data. /// </summary> /// <param name="Types">Readout types to read.</param> /// <param name="From">From what timestamp readout is desired.</param> /// <param name="To">To what timestamp readout is desired.</param> /// <param name="Nodes">Nodes to read.</param> public ReadoutRequest (ReadoutType Types, DateTime From, DateTime To, NodeReference[] Nodes) { this.types = Types; this.from = From; this.to = To; this.nodes = Nodes; }
public void CypherShouldStartQueryFromCurrentNodeReference() { var graphClient = Substitute.For<IRawGraphClient>(); var reference = new NodeReference(123, graphClient); var query = reference.StartCypher("foo").Query; Assert.AreEqual("START foo=node({p0})", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); }
public void CypherQueryShouldPreserveClientReference() { var client = Substitute.For<IRawGraphClient>(); var reference = new NodeReference<object>(123, client); var node = new Node<object>(new object(), reference); var queryBuilder = (IAttachedReference)node.StartCypher("foo"); Assert.AreEqual(client, queryBuilder.Client); }
public void AsShouldAppendStepToNodeQuery() { var query = new NodeReference(123).OutV<object>().As("foo"); Assert.IsInstanceOf<IGremlinNodeQuery<object>>(query); Assert.AreEqual("g.v(p0).outV.as(p1)", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); Assert.AreEqual("foo", query.QueryParameters["p1"]); }
public void AsShouldAppendStepToRelationshipQuery() { var query = new NodeReference(123).OutE().As("foo"); Assert.IsInstanceOf<IGremlinRelationshipQuery>(query); Assert.AreEqual("g.v(p0).outE.as(p1)", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); Assert.AreEqual("foo", query.QueryParameters["p1"]); }
public void IfThenElseVShouldAppendSteps() { var query = new NodeReference(123).IfThenElse( new GremlinIterator().OutV<object>().GremlinHasNext(), null, null); Assert.AreEqual("g.v(p0).ifThenElse{it.outV.hasNext()}{}{}", query.QueryText); }
public void InEShouldAppendStepToGremlinQueryWithLabel() { var query = new NodeReference(123).InE("FOO"); Assert.AreEqual("g.v(p0).inE.filter{ it[p1].equals(p2) }", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); Assert.AreEqual("label", query.QueryParameters["p1"]); Assert.AreEqual("FOO", query.QueryParameters["p2"]); }
public void LoopVShouldAppendStep() { var query = new NodeReference(123).LoopV<object>("foo", 6); Assert.AreEqual("g.v(p0).loop(p1){ it.loops < p2 }", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); Assert.AreEqual("foo", query.QueryParameters["p1"]); Assert.AreEqual(6, query.QueryParameters["p2"]); }
public void CopySplitVShouldMoveInlineBlockVariablesToTheOuterScopeInFinallyQueryUsingStoreV() { var query = new NodeReference(123).CopySplitE(new IdentityPipe().Out<object>("foo").StoreV<object>("xyz"), new IdentityPipe().Out<object>("bar")).Out<object>("baz"); Assert.AreEqual("xyz = [];g.v(p0)._.copySplit(_().out(p1).store(xyz), _().out(p2)).out(p3)", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); Assert.AreEqual("foo", query.QueryParameters["p1"]); Assert.AreEqual("bar", query.QueryParameters["p2"]); Assert.AreEqual("baz", query.QueryParameters["p3"]); }
public void CopySplitEShouldAppendStepAndPreserveOuterQueryParametersWithAllInlineBlocksAsIndentityPipes() { var query = new NodeReference(123).CopySplitE(new IdentityPipe().Out<object>("foo"), new IdentityPipe().Out<object>("bar")).Out<object>("baz"); Assert.AreEqual("g.v(p0)._.copySplit(_().out(p1), _().out(p2)).out(p3)", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); Assert.AreEqual("foo", query.QueryParameters["p1"]); Assert.AreEqual("bar", query.QueryParameters["p2"]); Assert.AreEqual("baz", query.QueryParameters["p3"]); }
public void GremlinSkipVShouldAppendStep() { var node = new NodeReference(123); var query = node.OutV<object>().GremlinSkip<object>(5); Assert.IsInstanceOf<GremlinNodeEnumerable<object>>(query); Assert.AreEqual("g.v(p0).outV.drop(p1)._()", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); Assert.AreEqual(5, query.QueryParameters["p1"]); }
public void GremlinSkipEShouldAppendStep() { var node = new NodeReference(123); var query = node.OutE().GremlinSkip(5); Assert.IsInstanceOf<GremlinRelationshipEnumerable>(query); Assert.AreEqual("g.v(p0).outE.drop(p1)._()", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); Assert.AreEqual(5, query.QueryParameters["p1"]); }
public void GremlinQueryShouldReturnSimpleVectorStep() { var client = Substitute.For<IGraphClient>(); var reference = new NodeReference<object>(123, client); var node = new Node<object>(new object(), reference); var query = (IGremlinQuery)node; Assert.AreEqual("g.v(p0)", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); }
public void CypherQueryShouldIncludeNodeAsStartBit() { var client = Substitute.For<IRawGraphClient>(); var reference = new NodeReference<object>(123, client); var node = new Node<object>(new object(), reference); var query = node.StartCypher("foo").Query; Assert.AreEqual("START foo=node({p0})", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); }
public void PrintLineShouldAppendStepToNodeQuery() { var query = new NodeReference(123).IfThenElse( new GremlinIterator().OutV<object>().GremlinHasNext(), new Statement().PrintLine("\"{$it} Hello\""), new Statement().PrintLine("\"{$it} GoodBye\"")); Assert.AreEqual("g.v(p0).ifThenElse{it.outV.hasNext()}{println \"{$it} Hello\"}{println \"{$it} GoodBye\"}", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); }
public void GremlinTakeEWithTDataShouldAppendStep() { var node = new NodeReference(123); var query = node.OutE<object>().GremlinTake<object>(5); Assert.IsInstanceOf<GremlinRelationshipEnumerable<object>>(query); Assert.AreEqual("g.v(p0).outE.take(p1)._()", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); Assert.AreEqual(5, query.QueryParameters["p1"]); }
private IEnumerable <KnowledgeConstraint> getConstraints(NodeReference generalNode, NodeReference featureNode, NodeReference bestEvidenceAnswer) { var paths = Graph.GetPaths(featureNode, bestEvidenceAnswer, PathMaxLength, PathMaxWidth).Take(MaxPathCount).ToArray(); var result = new List <KnowledgeConstraint>(); foreach (var path in paths) { result.Add(new KnowledgeConstraint(path)); } return(result); }
public InterpretationsFactory(Dialog.ParsedUtterance parsedQuestion, bool isBasedOnContext, NodeReference correctAnswerNode) { if (isBasedOnContext) { throw new NotImplementedException(); } _parsedQuestion = parsedQuestion; _isBasedOnContext = isBasedOnContext; CorrectAnswerNode = correctAnswerNode; ContractedInterpretation = new Interpretation(new[] { new InsertPoolRule(correctAnswerNode) }); }
public void UpdateShouldFailUnderTransaction() { ExecuteRestMethodUnderTransaction(client => { var pocoReference = new NodeReference<TestNode>(456); var updatedNode = client.Update( pocoReference, nodeFromDb => { nodeFromDb.Foo = "fooUpdated"; }); }); }
public void OutVShouldAppendStepToGremlinQueryWithSingleEqualFilter() { var query = new NodeReference(123) .OutV<object>(new List<Filter> { new Filter { PropertyName = "Foo", Value = "Bar", ExpressionType = ExpressionType.Equal } }, StringComparison.Ordinal); Assert.AreEqual("g.v(p0).outV.filter{ it[p1].equals(p2) }", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); Assert.AreEqual("Foo", query.QueryParameters["p1"]); Assert.AreEqual("Bar", query.QueryParameters["p2"]); }
public void UpdateShouldFailUnderTransaction() { ExecuteRestMethodUnderTransaction(client => { var pocoReference = new NodeReference <TestNode>(456); var updatedNode = client.Update( pocoReference, nodeFromDb => { nodeFromDb.Foo = "fooUpdated"; }); }); }
/// <summary> /// Represents a request for sensor data. /// </summary> /// <param name="Types">Readout types to read.</param> /// <param name="From">From what timestamp readout is desired.</param> /// <param name="To">To what timestamp readout is desired.</param> /// <param name="Nodes">Nodes to read.</param> /// <param name="Fields">Fields</param> public ReadoutRequest (ReadoutType Types, DateTime From, DateTime To, NodeReference[] Nodes, IEnumerable<string> Fields) { this.types = Types; this.from = From; this.to = To; this.nodes = Nodes; this.fields = new SortedDictionary<string, bool> (); foreach (string Field in Fields) this.fields [Field] = true; }
public void CopySplitVShouldAppendStepAndPreserveOuterQueryParametersWithOneInlineBlocksAsNodeReference() { var node = new NodeReference(456); var query = new NodeReference(123).CopySplitE(new IdentityPipe().Out <object>("foo"), node.Out <object>("bar")).Out <object>("baz"); Assert.Equal("g.v(p0)._.copySplit(_().out(p1), g.v(p2).out(p3)).out(p4)", query.QueryText); Assert.Equal(123L, query.QueryParameters["p0"]); Assert.Equal("foo", query.QueryParameters["p1"]); Assert.Equal(456L, query.QueryParameters["p2"]); Assert.Equal("bar", query.QueryParameters["p3"]); Assert.Equal("baz", query.QueryParameters["p4"]); }
private bool updateFilterPart(NodeReference correctAnswerNode, PoolHypothesis bestHypothesis) { var pool = Pool.Clone(); runActions(pool, bestHypothesis.ActionBlock, bestHypothesis.Substitutions, false); if (pool.ActiveNodes.Contains(correctAnswerNode)) { setFilter(correctAnswerNode, bestHypothesis.ActionBlock, pool); return(true); } return(false); }
internal double SubstitutionProbability(NodeReference substitution, IEnumerable <NodeReference> originalNodes) { //TODO consider substitution quality if (originalNodes.Contains(substitution)) { //prefer substitution with lower node count return(2.0 / (originalNodes.Count() + 1)); } else { return(1.0 / (originalNodes.Count() + 1)); } }
internal SemanticPart Substitute(NodeReference originalReference, NodeReference substitutedNode) { //TODO for now it is sufficient to have only StartNode substitution //but this is only because of using only path edges !!!! var startNode = StartNode; if (StartNode.Equals(originalReference)) { startNode = substitutedNode; } return(new SemanticPart(Utterance, startNode, Paths)); }
static void Main(string[] args) { try { GraphClient client = new GraphClient(new Uri("http://localhost:7474/db/data")); client.Connect(); // Create nodes and relationship MyNode node1 = new MyNode() { Name = "Test 1" }; MyNode node2 = new MyNode() { Name = "Test 2" }; NodeReference <MyNode> node1ref = client.Create <MyNode>(node1); NodeReference <MyNode> node2ref = client.Create <MyNode>(node2); MyRelationShip rel12 = new MyRelationShip(node2ref); var Rel1 = client.CreateRelationship <MyNode, MyRelationShip>(node1ref, rel12); MyNode node3 = new MyNode() { Name = "Test 3" }; NodeReference <MyNode> node3ref = client.Create <MyNode>(node3); MyRelationShip rel13 = new MyRelationShip(node3ref); var Rel13 = client.CreateRelationship <MyNode, MyRelationShip>(node1ref, rel13); var query = client.Cypher.Start(new { n1 = node1ref }) .Match("n1-[:MYRELATIONSHIP]->targetnode") .Return <MyNode>(targetnode => targetnode.As <MyNode>()); var res = query.Results; int i = 0; foreach (MyNode n in res) { i++; Console.WriteLine(i + ". Name: '" + n.Name + "'"); } } catch (NeoException ex) { Console.WriteLine(ex.ToString()); } Console.ReadKey(); }
public void ShouldUpdateNode() { var nodeToUpdate = new TestNode { Foo = "foo", Bar = "bar", Baz = "baz" }; using (var testHarness = new RestTestHarness { { MockRequest.Get("/node/456"), MockResponse.Json(HttpStatusCode.OK, @"{ 'self': 'http://foo/db/data/node/456', 'data': { 'Foo': 'foo', 'Bar': 'bar', 'Baz': 'baz' }, 'create_relationship': 'http://foo/db/data/node/456/relationships', 'all_relationships': 'http://foo/db/data/node/456/relationships/all', 'all_typed relationships': 'http://foo/db/data/node/456/relationships/all/{-list|&|types}', 'incoming_relationships': 'http://foo/db/data/node/456/relationships/in', 'incoming_typed relationships': 'http://foo/db/data/node/456/relationships/in/{-list|&|types}', 'outgoing_relationships': 'http://foo/db/data/node/456/relationships/out', 'outgoing_typed relationships': 'http://foo/db/data/node/456/relationships/out/{-list|&|types}', 'properties': 'http://foo/db/data/node/456/properties', 'property': 'http://foo/db/data/node/456/property/{key}', 'traverse': 'http://foo/db/data/node/456/traverse/{returnType}' }") }, { MockRequest.PutObjectAsJson("/node/456/properties", nodeToUpdate), MockResponse.Http((int)HttpStatusCode.NoContent) } }) { var graphClient = testHarness.CreateAndConnectGraphClient(); //Act var pocoReference = new NodeReference <TestNode>(456); graphClient.Update( pocoReference, nodeFromDb => { nodeFromDb.Foo = "fooUpdated"; nodeFromDb.Baz = "bazUpdated"; nodeToUpdate = nodeFromDb; } ); Assert.AreEqual("fooUpdated", nodeToUpdate.Foo); Assert.AreEqual("bazUpdated", nodeToUpdate.Baz); Assert.AreEqual("bar", nodeToUpdate.Bar); } }
private void Reset() { CurrentNode = new NodeReference(null, GameObject.Find("StartNode")); //Reset current node //Delete old nodes foreach (GameObject node in GameObject.FindGameObjectsWithTag("Node")) { Destroy(node, 3); node.GetComponent <DrawLineController> ().UnDrawLine_Animated(); } //ReCreate first scene Random.InitState(GameSeed); GenerateNodeSet(); CurrentNode.Reference.GetComponent <DrawLineController> ().UnDrawLine_Animated(); }
public bool PickRightNode() { ///<summary>Returns true if correct node is picked, otherwise false</summary> if (CurrentNode.NextNodeRight.GetComponent <NodeData> ().isCorrectNode) { CurrentNode.Reference.GetComponent <DrawLineController> ().EndPoint = CurrentNode.NextNodeRight.transform; CurrentNode.Reference.GetComponent <DrawLineController> ().DrawLine_Animated(); CurrentNode = new NodeReference(CurrentNode.Reference, CurrentNode.NextNodeRight); GenerateNodeSet(); return(true); } Reset(); return(false); }
internal bool TryGetValue(NodeReference patternNode, out NodeReference substitution) { for (var i = 0; i < OriginalNodes.Count; ++i) { var originalNode = OriginalNodes.GetNode(i); if (originalNode.Equals(patternNode)) { substitution = SubstitutedNodes.GetNode(i); return(true); } } substitution = null; return(false); }
internal PathSubstitution(NodeReference substitution, TraceNode2 originalTrace, double rank = double.NaN) { Substitution = substitution; OriginalTrace = originalTrace; if (double.IsNaN(rank)) { Rank = CompatibleInitialNodes.Count(); } else { Rank = rank; } }
public void CopySplitVShouldMoveInlineBlockVariablesToTheOuterScopeInFinallyQueryUsingStoreVAndFiltersMultipleVariables() { var query = new NodeReference(123).CopySplitE(new IdentityPipe().Out <Test>("foo", t => t.Flag == true).StoreV <object>("xyz"), new IdentityPipe().Out <Test>("bar")).Out <Test>("baz", t => t.Flag == true).AggregateE("sad"); Assert.Equal("sad = [];xyz = [];g.v(p0)._.copySplit(_().out(p1).filter{ it[p2] == p3 }.store(xyz), _().out(p4)).out(p5).filter{ it[p6] == p7 }.aggregate(sad)", query.QueryText); Assert.Equal(123L, query.QueryParameters["p0"]); Assert.Equal("foo", query.QueryParameters["p1"]); Assert.Equal("Flag", query.QueryParameters["p2"]); Assert.Equal(true, query.QueryParameters["p3"]); Assert.Equal("bar", query.QueryParameters["p4"]); Assert.Equal("baz", query.QueryParameters["p5"]); Assert.Equal("Flag", query.QueryParameters["p6"]); Assert.Equal(true, query.QueryParameters["p7"]); }
private Tuple <IType[], NodeReference[]> CollapseStack() { Node[] nodes = _nodeStack.ToArray(); IType[] types = new IType[nodes.Length]; NodeReference[] references = new NodeReference[nodes.Length]; for (int i = 0; i < nodes.Length; i++) { Node node = nodes[i]; types[i] = node.ResultType; references[i] = node.TakeReference(); } _nodeStack.Clear(); return(new Tuple <IType[], NodeReference[]>(types, references)); }
private HashSet <NodeReference> findDomain(NodeReference generalNode) { //TODO this has to be refactored out var domains = new HashSet <NodeReference>(); foreach (var question in _questions.Values) { var featureNode = question.GetFeatureNode(generalNode, Graph); domains.UnionWith(Graph.GetForwardTargets(new[] { featureNode }, new[] { Edge.Incoming("en.label"), Edge.Incoming("P31") })); } /* var edges = Graph.GetNeighbours(new NodeReference("Q30"),100).ToArray();*/ return(domains); }
public void OutShouldAppendStepToGremlinQueryWithEqualFilterForTextOfEnum() { var query = new NodeReference(123) .Out <TestNodeWithNullableEnum>( "REL", x => x.Boo == TestEnum.Bar ); Assert.Equal("g.v(p0).out(p1).filter{ it[p2].equalsIgnoreCase(p3) }", query.QueryText); Assert.Equal(123L, query.QueryParameters["p0"]); Assert.Equal("REL", query.QueryParameters["p1"]); Assert.Equal("Boo", query.QueryParameters["p2"]); Assert.Equal("Bar", query.QueryParameters["p3"]); }
protected override bool adviceAnswer(string question, bool isBasedOnContext, NodeReference correctAnswerNode, IEnumerable <NodeReference> context) { var parsedQuestion = UtteranceParser.Parse(question); var interpretationsFactory = getInterpretationsFactory(parsedQuestion, isBasedOnContext, correctAnswerNode, context); var covers = FeatureCover.GetFeatureCovers(parsedQuestion, Graph); _mapping.Add(interpretationsFactory, covers); //TODO decide whether it would be benefitial to report that //the advice is taken into account, however we don't believe it much. return(true); }
private static object ReadComplexNode(NodeReference node, Type objectType) { var isNullable = EntityTypeDescriptor.IsNullableType(objectType); if (isNullable && IsNullableComplexColumnEmpty(node)) { return(null); } var underlyingType = !isNullable ? objectType : Nullable.GetUnderlyingType(objectType); var typeDescription = EntityTypeDescriptor.GetTypeDescription(underlyingType); var instance = InstanceCreator.CreateInstance(underlyingType); foreach (var column in typeDescription.Columns) { var subscript = column.ColumnAttribute.Name ?? column.ColumnInfo.Name; if (column.IsSimpleColumn) { node.AppendSubscript(subscript); var nodeValue = node.GetObject(); column.ColumnInfo.SetValue(instance, ConvertValue(nodeValue, column.ColumnInfo.PropertyType), null); } else if (column.IsArrayColumn) { node.AppendSubscript(subscript); column.ColumnInfo.SetValue(instance, ReadArray(node, column.ColumnInfo.PropertyType), null); } else if (column.IsEnumerableColumn) { node.AppendSubscript(subscript); column.ColumnInfo.SetValue(instance, ReadEnumerable(node, column.ColumnInfo.PropertyType), null); } else if (column.IsComplexColumn) { node.AppendSubscript(subscript); column.ColumnInfo.SetValue(instance, ReadComplexNode(node, column.ColumnInfo.PropertyType), null); } node.SetSubscriptCount(node.GetSubscriptCount() - 1); } return(instance); }
private PushAction createPushAction(string question, NodeReference correctAnswer) { var relevantUtterances = lastRelevantUtterances(question, correctAnswer); var orderedUtterances = (from utterance in relevantUtterances orderby getFowardTargets(utterance).Count select utterance).ToArray(); if (!orderedUtterances.Any()) { return(null); } var pushPart = orderedUtterances.Last(); var pushAction = new PushAction(pushPart); return(pushAction); }
public void OutVShouldAppendStepToGremlinQueryWithSingleEqualFilter() { var query = new NodeReference(123) .OutV <object>(new List <Filter> { new Filter { PropertyName = "Foo", Value = "Bar", ExpressionType = ExpressionType.Equal } }, StringComparison.Ordinal); Assert.Equal("g.v(p0).outV.filter{ it[p1].equals(p2) }", query.QueryText); Assert.Equal(123L, query.QueryParameters["p0"]); Assert.Equal("Foo", query.QueryParameters["p1"]); Assert.Equal("Bar", query.QueryParameters["p2"]); }
public void GremlinCountShouldExecuteScalar() { var client = Substitute.For <IGraphClient>(); client .ExecuteScalarGremlin( "g.v(p0).count()", Arg.Is <IDictionary <string, object> >( d => (long)d["p0"] == 123)) .Returns("456"); var node = new NodeReference(123L, client); var result = node.GremlinCount(); Assert.Equal(456, result); }
/// </inheritdoc> protected override IEnumerable <NodeReference> Incoming(NodeReference toNode, string edge) { var id = toNode.Data; var entity = _db.GetEntryFromId(id); foreach (var target in entity.Targets) { if (target.Item1.IsOutcoming) { continue; } yield return(CreateReference(target.Item2)); } }
private IEnumerable <KnowledgeConstraint> findTopEvidenceConstraints(NodeReference generalNode, IEnumerable <KnowledgeConstraint> constraints) { var orderedConstraints = (from constraint in constraints select constraint).OrderByDescending(c => getEvidenceScore(generalNode, c)).ToArray(); var selectedConstraints = orderedConstraints.Take(1).ToArray(); var scores = new List <int>(); foreach (var constraint in selectedConstraints) { var score = getEvidenceScore(generalNode, constraint); scores.Add(score); } return(selectedConstraints); }
public void IfThenElseVShouldAppendStepsWithThenQueryAndElseQueryWithParameters() { var query = new NodeReference(123).IfThenElse( new GremlinIterator().OutV <Test>(t => t.Flag == true).GremlinHasNext(), new GremlinIterator().OutV <Test>(t => t.Name == "foo"), new GremlinIterator().InV <Test>(t => t.Name == "bar")); Assert.Equal("g.v(p0).ifThenElse{it.outV.filter{ it[p1] == p2 }.hasNext()}{it.outV.filter{ it[p3].equalsIgnoreCase(p4) }}{it.inV.filter{ it[p5].equalsIgnoreCase(p6) }}", query.QueryText); Assert.Equal(123L, query.QueryParameters["p0"]); Assert.Equal("Flag", query.QueryParameters["p1"]); Assert.Equal(true, query.QueryParameters["p2"]); Assert.Equal("Name", query.QueryParameters["p3"]); Assert.Equal("foo", query.QueryParameters["p4"]); Assert.Equal("Name", query.QueryParameters["p5"]); Assert.Equal("bar", query.QueryParameters["p6"]); }
public static void Main(String[] args) { Connection myConn = ConnectionContext.GetConnection(); try { myConn.Connect("User", "_SYSTEM", "SYS"); NodeReference nodeRef = myConn.CreateNodeReference("myGlobal"); // Read both existing nodes Console.WriteLine("Value of ^myGlobal is " + nodeRef.GetString()); Console.WriteLine("Value of ^myGlobal(\"sub1\") is " + nodeRef.GetString("sub1")); nodeRef.Kill(); // delete entire array nodeRef.Close(); myConn.Close(); } catch (GlobalsException e) { Console.WriteLine(e.Message); } } // end Main()
protected override bool adviceAnswer(string question, bool isBasedOnContext, NodeReference correctAnswerNode, IEnumerable <NodeReference> context) { if (question == null || question.Trim() == "") { return(false); } fillPool(context); var questionEntry = GetQuestionEntry(UtteranceParser.Parse(question)); questionEntry.RegisterAnswer(isBasedOnContext, correctAnswerNode); return (updateOldActions(question, isBasedOnContext, correctAnswerNode) || createNewActions(question, isBasedOnContext, correctAnswerNode)); }
public void IfThenElseVShouldAppendStepsWithThenQueryAndElseQueryWithParametersAndMultipleDeclarations() { var query = new NodeReference(123).IfThenElse( new GremlinIterator().OutV <Test>(t => t.Flag == true).GremlinHasNext(), new GremlinIterator().AggregateV <object>("x").OutV <Test>(t => t.Name == "foo"), new GremlinIterator().AggregateV <object>("y").InV <Test>(t => t.Name == "bar")); Assert.AreEqual("y = [];x = [];g.v(p0).ifThenElse{it.outV.filter{ it[p1] == p2 }.hasNext()}{it.aggregate(x).outV.filter{ it[p3].equalsIgnoreCase(p4) }}{it.aggregate(y).inV.filter{ it[p5].equalsIgnoreCase(p6) }}", query.QueryText); Assert.AreEqual(123, query.QueryParameters["p0"]); Assert.AreEqual("Flag", query.QueryParameters["p1"]); Assert.AreEqual(true, query.QueryParameters["p2"]); Assert.AreEqual("Name", query.QueryParameters["p3"]); Assert.AreEqual("foo", query.QueryParameters["p4"]); Assert.AreEqual("Name", query.QueryParameters["p5"]); Assert.AreEqual("bar", query.QueryParameters["p6"]); }
private double getRank(NodeReference answerCandidate, MultiTraceLog2 pattern) { var commonTraceNodes = getCommonTraceNodes(answerCandidate, pattern); var rank = 0.0; var initialNodeCount = pattern.InitialNodes.Count(); foreach (var traceNode in commonTraceNodes) { var compatibleNodes = traceNode.CompatibleInitialNodes.ToArray(); var edgeImportance = 1.0 * compatibleNodes.Length / initialNodeCount; rank += edgeImportance; } //TODO here could be more precise formula return(rank / commonTraceNodes.Count()); }
void DoNode(NodeReference reference, int idx, Vector4 enabled, Vector4 disabled) { var col = instance.NodeEnabled(reference) ? enabled : disabled; string label = null; if (reference.IsAttachmentNode) { label = string.Format("Attachment##{0}", idx); } else { label = string.Format("{0}##{1}", reference.Node.NodeName, idx); } ImGui.PushStyleColor(ImGuiCol.Text, col); string icon; Color4 color; NodeIcon(reference.Node, out icon, out color); if (reference.Children.Count > 0) { if (ImGui.TreeNodeEx(ImGuiExt.Pad(label), ImGuiTreeNodeFlags.OpenOnDoubleClick | ImGuiTreeNodeFlags.OpenOnArrow)) { Theme.RenderTreeIcon(label.Split('#')[0], icon, color); int j = 0; foreach (var child in reference.Children) { DoNode(child, j++, enabled, disabled); } ImGui.TreePop(); } else { Theme.RenderTreeIcon(label.Split('#')[0], icon, color); } } else { Theme.Icon(icon, color); ImGui.SameLine(); if (ImGui.Selectable(label, selectedReference == reference)) { selectedReference = reference; } } ImGui.PopStyleColor(); }