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