/// <summary> /// Called when [join node] is visited. /// </summary> /// <param name="node">The node.</param> public override void OnJoinNode(JoinNode node) { _sb.Append(_indentString).Append("Join Node <---------- "); node.AlphaMemory.Accept(this); if (node.IsHeadOfSubNetwork) { _sb.Append("").AppendLine(" |"); _indentString = " | "; _sb.Append(" |--------> ").AppendLine("SUBNETWORK"); _sb.Append(_indentString).AppendLine(" |"); _sb.Append(_indentString).AppendLine(" V"); foreach (ReteNode child in node.Children) { if ((child is NCCNode) == false) { child.Accept(this); } } } else { _sb.Append(_indentString).AppendLine(" |"); _sb.Append(_indentString).AppendLine(" V"); foreach (ReteNode child in node.Children) { child.Accept(this); } } }
public void Visit(JoinNode node) { SetQueryPart(QueryPart.From); var joins = new Stack <JoinNode>(); var join = node; while (join != null) { joins.Push(join); join = join.Source as JoinNode; } join = joins.Pop(); join.Source.Accept(this); join.With.Accept(this); join.Expression.Accept(this); join.Accept(_visitor); while (joins.Count > 0) { join = joins.Pop(); join.With.Accept(this); join.Expression.Accept(this); join.Accept(_visitor); } }
public void Find(Action <JoinNode <T> > callback) { if (_node == null) { var joinNode = _left.Successors .OfType <JoinNode <T> >() .Where(node => _matchRight(node.RightActivation)) .FirstOrDefault(); if (joinNode != null) { _node = joinNode; } else { var rightActivation = _rightActivation(); _node = _configurator.Join(rightActivation); _left.AddActivation(_node); } } if (_node != null) { callback(_node); } }
public async Task Should_properly_handle_activation() { ITupleSource <Member> leftSource = new TestTupleSource <Member>(new Tuple <Member>(new Member() { MemberId = 27, Name = "Frank" })); IFactSource <Address> rightSource = new TestFactSource <Address>(); var testSink = new TestTupleSink <Address>(); IBetaNode <Member, Address> betaNode = new JoinNode <Member, Address>(leftSource, rightSource, new BetaCondition <Member, Address>((m, a) => true)); betaNode.Connect(testSink); var sessionContext = new TestSession(); var factContext = new TestFactContext <Address>(sessionContext, new Address() { MemberId = 42, PostalCode = "68106" }); await betaNode.Insert(factContext); Assert.That(testSink.Tuples.Count(), Is.EqualTo(1)); }
public void FirstTestName() { var route = new RouteNode <Uri>(new StubRoute <Uri>()); var joinNode = new JoinNode <Uri>(_id++, new ConstantNode <Uri>()); joinNode.Add(route); var alpha = new AlphaNode <Uri>(_id++); alpha.Add(joinNode); var equal = new EqualNode <Uri>(() => _id++); equal.Add("version", alpha); var segment = new SegmentNode <Uri>(1); segment.Add(equal); var engine = new MagnumRoutingEngine <Uri>(x => x); engine.Match <RootNode <Uri> >().Single().Add(segment); bool called = false; var uri = new Uri("http://localhost/version"); engine.Route(uri, x => { called = true; }); called.ShouldBeTrue(); }
public async Task Should_handle_inverse_activation() { ITupleSource <Member> leftSource = new TestTupleSource <Member>(); IFactSource <Address> rightSource = new TestFactSource <Address>( new Address() { MemberId = 27, PostalCode = "68106" }, new Address() { MemberId = 27, PostalCode = "74011" }, new Address() { MemberId = 42, PostalCode = "74011" }); var testSink = new TestTupleSink <Address>(); IBetaNode <Member, Address> betaNode = new JoinNode <Member, Address>(leftSource, rightSource, new BetaCondition <Member, Address>((m, a) => m.Right.MemberId == a.MemberId)); betaNode.Connect(testSink); var sessionContext = new TestSession(); var tupleContext = new TestTupleContext <Member>(sessionContext, new Member { MemberId = 27, Name = "Frank" }); await betaNode.Insert(tupleContext); Assert.That(testSink.Tuples.Count(), Is.EqualTo(2)); }
private void RemovePrefix(JoinNode node, string prefix) { if (!string.IsNullOrEmpty(prefix)) { RemovePrefix(node, prefix, new Dictionary <DBTable, DBTable>()); } }
public static JoinNode <T> CreateJunction <T>(this IEnumerable <AlphaNode <T> > nodes, RightActivation <T> rightActivation) { var junction = new JoinNode <T>(rightActivation); // junction.AddSuccessor(nodes.CreateJunction()); throw new NotImplementedException(); }
public void FirstTestName() { var route = new RouteNode<Uri>(new StubRoute<Uri>()); var joinNode = new JoinNode<Uri>(_id++, new ConstantNode<Uri>()); joinNode.Add(route); var alpha = new AlphaNode<Uri>(_id++); alpha.Add(joinNode); var equal = new EqualNode<Uri>(() => _id++); equal.Add("version", alpha); var segment = new SegmentNode<Uri>(1); segment.Add(equal); var engine = new MagnumRoutingEngine<Uri>(x => x); engine.Match<RootNode<Uri>>().Single().Add(segment); bool called = false; var uri = new Uri("http://localhost/version"); engine.Route(uri, x => { called = true; }); called.ShouldBeTrue(); }
private (CfgNode, CfgNode) CreateBranchConditionNodes(ProgramState state, Expression trueNodeCondition, Expression falseNodeCondition) { var truePruneNode = new PruneNode(state.CurrentLocation, true, PruneNode.PruneNodeKind.MethodBody, Prune.IfKind.Ik_if, state.ProcDesc); var falsePruneNode = new PruneNode(state.CurrentLocation, false, PruneNode.PruneNodeKind.MethodBody, Prune.IfKind.Ik_if, state.ProcDesc); truePruneNode.Instructions.Add(new Prune(trueNodeCondition, true, Prune.IfKind.Ik_if, state.CurrentLocation)); falsePruneNode.Instructions.Add(new Prune(falseNodeCondition, false, Prune.IfKind.Ik_if, state.CurrentLocation)); if (HasLoops(state.CurrentInstruction)) { var joinNode = new JoinNode(state.CurrentLocation, state.ProcDesc); RegisterNode(state, joinNode); state.PreviousNode = joinNode; } return(truePruneNode, falsePruneNode); }
protected override bool Visit <T>(JoinNode <T> node) { _current = GetVertex(node.GetHashCode(), () => "J", typeof(JoinNode <>), typeof(T)); LinkFromParent(); return(WithVertex(() => base.Visit(node))); }
internal static ReteNode Create(JoinNode node) { var conditions = node.ExpressionElements.Select(c => new KeyValuePair <string, LambdaExpression>("Condition", c.Expression)); return(new ReteNode(node.Id, NodeType.Join, expressions: conditions, rules: node.NodeInfo.Rules)); }
public void Visit(JoinNode node) { var expression = Nodes.Pop(); var joinedTable = (FromNode)Nodes.Pop(); var source = (FromNode)Nodes.Pop(); Nodes.Push(new JoinNode(source, joinedTable, expression, node.JoinType)); }
protected internal override void VisitJoinNode(SnapshotBuilder builder, JoinNode node) { if (builder.IsVisited(node)) { return; } builder.AddNode(node, NodeInfo.Create); base.VisitJoinNode(builder, node); }
public override void VisitJoinNode <TLeft, TRight>(GraphContext context, JoinNode <TLeft, TRight> node) { var nodeInfo = new Node(Interlocked.Increment(ref _id), node, typeof(TRight), "join"); context.Add(nodeInfo); context.Link(nodeInfo, new Node(-1, node.MemoryNode, typeof(TRight), "")); base.VisitJoinNode(context, node); }
protected internal override void VisitJoinNode(SchemaBuilder builder, JoinNode node) { if (builder.IsVisited(node)) { return; } builder.AddNode(node, ReteNode.Create); base.VisitJoinNode(builder, node); }
void Bind(Action <JoinNode <T> > callback) { if (_join == null) { _join = new JoinNode <T>(new ConstantNode <T>()); _alphaNode.AddActivation(_join); } callback(_join); }
public void Only_those_that_are_matched_should_be_called() { var junction = new JoinNode <Customer>(_constantNode); junction.AddSuccessor(_actionNode); var alphaNodeA = new AlphaNode <Customer>(); alphaNodeA.AddSuccessor(junction); var joinJunction = new JoinNode <Customer>(alphaNodeA); var alphaNodeB = new AlphaNode <Customer>(); alphaNodeB.AddSuccessor(joinJunction); var actionNode = new ActionNode <Customer>(x => _secondaryCalled.Complete(x.Element.Object)); var joinJunction2 = new JoinNode <Customer>(alphaNodeA); joinJunction2.AddSuccessor(actionNode); var alphaNodeC = new AlphaNode <Customer>(); alphaNodeC.AddSuccessor(joinJunction2); var tree = new TypeNode <Customer>(); var isPreferred = new ConditionNode <Customer>(x => x.Preferred); isPreferred.AddSuccessor(alphaNodeA); tree.AddSuccessor(isPreferred); tree.AddSuccessor(alphaNodeB); var isActive = new ConditionNode <Customer>(x => x.Active); isActive.AddSuccessor(alphaNodeC); tree.AddSuccessor(isActive); var visitor = new StringNodeVisitor(); tree.Visit(visitor); Trace.WriteLine(visitor.Result); tree.Activate(_context); _session.Run(); _primaryCalled.IsCompleted.ShouldBeTrue(); _secondaryCalled.IsCompleted.ShouldBeFalse(); }
protected virtual bool Visit <T>(JoinNode <T> node) { IncreaseDepth(); if (node.RightActivation as ConstantNode <T> != null) { Visit(node.RightActivation); } node.Activations.Each(activation => Visit(activation)); DecreaseDepth(); return(true); }
public void FirstTestName() { var junction = new JoinNode<Customer>(_constantNode); junction.AddSuccessor(_actionNode); var memoryA = new BetaMemory<Customer>(junction); memoryA.Activate(_context); _agenda.Execute(); _context.VerifyAllExpectations(); }
public void FirstTestName() { var junction = new JoinNode<Customer>(_constantNode); junction.AddSuccessor(_actionNode); var memoryA = new BetaMemory<Customer>(junction); memoryA.Activate(_context); _session.Run(); _primaryCalled.IsCompleted.ShouldBeTrue(); }
object FindJoinNode <T>() { JoinNode <T> result = null; new MatchAlphaNode <T>(_engine, alphaNode => { new MatchJoinNode <T>(alphaNode, joinNode => { result = joinNode; }); }); if (result == null) { throw new InvalidOperationException("Failed to create join node: " + typeof(T).ToShortTypeName()); } return(result.BetaMemory); }
public void FirstTestName() { var junction = new JoinNode <Customer>(_constantNode); junction.AddSuccessor(_actionNode); var memoryA = new BetaMemory <Customer>(junction); memoryA.Activate(_context); _agenda.Execute(); _context.VerifyAllExpectations(); }
public void FirstTestName() { var junction = new JoinNode <Customer>(_constantNode); junction.AddSuccessor(_actionNode); var memoryA = new BetaMemory <Customer>(junction); memoryA.Activate(_context); _session.Run(); _primaryCalled.IsCompleted.ShouldBeTrue(); }
public void One_more_level_of_indirection() { var junction = new JoinNode<Customer>(_constantNode); junction.AddSuccessor(_actionNode); var alphaNode = new AlphaNode<Customer>(); alphaNode.AddSuccessor(junction); alphaNode.Activate(_context); _session.Run(); _primaryCalled.IsCompleted.ShouldBeTrue(); }
public void Visit(JoinNode node) { var expression = Nodes.Pop(); var fromNode = (FromNode)Nodes.Pop(); if (node is OuterJoinNode outerJoin) { Nodes.Push(new OuterJoinNode(outerJoin.Type, fromNode, expression)); } else { Nodes.Push(new InnerJoinNode(fromNode, expression)); } }
public void AddRoutes(IEnumerable<string> paths) { foreach (string path in paths) { var route = new RouteNode<Uri>(new StubRoute<Uri>()); var joinNode = new JoinNode<Uri>(_id++, new ConstantNode<Uri>()); joinNode.Add(route); var alpha = new AlphaNode<Uri>(_id++); alpha.Add(joinNode); _equal.Add(path.Substring(1), alpha); } }
public override bool Visit <T>(JoinNode <T> node, Func <RuntimeVisitor, bool> next) { _current = _vertices.Get(node.Id, id => new Vertex(typeof(JoinNode <>), typeof(T), typeof(T).Tokens())); if (_rightActivation == node.Id) { _edges.Add(new Edge(_current, _stack.Peek(), _current.TargetType.Name)); } else if (_stack.Count > 0) { _edges.Add(new Edge(_stack.Peek(), _current, _current.TargetType.Name)); } return(Next(node.RightActivation.Id, () => base.Visit(node, next))); }
public BetaBuilderContext <T, T> BuildJoinNode <T>(AlphaBuilderContext <T> context) where T : class { using (_logger.BeginScope($"{nameof(BuildJoinNode)}<{typeof(T).Name}>")) { var betaSource = new DummyNode <T>() as ITupleSource <T>; var alphaSource = context.CurrentSource as IFactSource <T>; _logger.LogDebug($"Creating join node: {typeof(T).Name}"); var node = new JoinNode <T, T>(betaSource, alphaSource, new BetaCondition <T, T>((x, y) => true)); return(new RuntimeBetaBuilderContext <T, T>(context.Declaration, node)); } }
public void AddRoutes(IEnumerable <string> paths) { foreach (string path in paths) { var route = new RouteNode <Uri>(new StubRoute <Uri>()); var joinNode = new JoinNode <Uri>(_id++, new ConstantNode <Uri>()); joinNode.Add(route); var alpha = new AlphaNode <Uri>(_id++); alpha.Add(joinNode); _equal.Add(path.Substring(1), alpha); } }
public void One_more_level_of_indirection() { var junction = new JoinNode <Customer>(_constantNode); junction.AddSuccessor(_actionNode); var alphaNode = new AlphaNode <Customer>(); alphaNode.AddSuccessor(junction); alphaNode.Activate(_context); _session.Run(); _primaryCalled.IsCompleted.ShouldBeTrue(); }
protected override bool Visit <TChannel>(JoinNode <TChannel> node) { var match = node as JoinNode <T>; if (match != null) { var constant = match.RightActivation as ConstantNode <T>; if (constant != null) { _join = match; return(false); } } return(base.Visit(node)); }
private void RemovePrefix(JoinNode node, string prefix, Dictionary <DBTable, DBTable> clonedTables) { if (node.Table.Name.StartsWith(prefix, StringComparison.Ordinal)) { DBTable cloned; if (!clonedTables.TryGetValue(node.Table, out cloned)) { cloned = RemovePrefix(node.Table, prefix); clonedTables[node.Table] = cloned; node.Table = cloned; } } foreach (var subNode in node.SubNodes) { RemovePrefix(subNode, prefix, clonedTables); } }
public void Only_those_that_are_matched_should_be_called() { var junction = new JoinNode<Customer>(_constantNode); junction.AddSuccessor(_actionNode); var alphaNodeA = new AlphaNode<Customer>(); alphaNodeA.AddSuccessor(junction); var joinJunction = new JoinNode<Customer>(alphaNodeA); var alphaNodeB = new AlphaNode<Customer>(); alphaNodeB.AddSuccessor(joinJunction); var actionNode = new ActionNode<Customer>(x => _secondaryCalled.Complete(x.Element.Object)); var joinJunction2 = new JoinNode<Customer>(alphaNodeA); joinJunction2.AddSuccessor(actionNode); var alphaNodeC = new AlphaNode<Customer>(); alphaNodeC.AddSuccessor(joinJunction2); var tree = new TypeNode<Customer>(); var isPreferred = new ConditionNode<Customer>(x => x.Preferred); isPreferred.AddSuccessor(alphaNodeA); tree.AddSuccessor(isPreferred); tree.AddSuccessor(alphaNodeB); var isActive = new ConditionNode<Customer>(x => x.Active); isActive.AddSuccessor(alphaNodeC); tree.AddSuccessor(isActive); var visitor = new StringNodeVisitor(); tree.Visit(visitor); Trace.WriteLine(visitor.Result); tree.Activate(_context); _session.Run(); _primaryCalled.IsCompleted.ShouldBeTrue(); _secondaryCalled.IsCompleted.ShouldBeFalse(); }
public void Pulling_an_element_through_two_memories_should_merge_properly() { var junction = new JoinNode<Customer>(_constantNode); junction.AddSuccessor(_actionNode); var memoryB = new BetaMemory<Customer>(junction); var joinJunction = new JoinNode<Customer>(memoryB); var memoryA = new BetaMemory<Customer>(joinJunction); memoryA.Activate(_context); memoryB.Activate(_context); _agenda.Execute(); _context.VerifyAllExpectations(); }
public IBetaNode <T, T> BuildJoinNode <T>(BuilderContext context) where T : class { using (_logger.BeginScope($"{nameof(BuildJoinNode)}<{typeof(T).Name}>")) { var betaSource = (context.BetaSource ?? new DummyNode <T>()) as ITupleSource <T>; var alphaSource = context.AlphaSource as IFactSource <T>; _logger.LogDebug($"Creating join node: {typeof(T).Name}"); var node = new JoinNode <T, T>(betaSource, alphaSource, new BetaCondition <T, T>((x, y) => true)); context.BetaSource = node.MemoryNode; context.ClearAlphaSource(); return(node); } }
public void Pulling_an_element_through_two_memories_should_merge_properly() { var junction = new JoinNode <Customer>(_constantNode); junction.AddSuccessor(_actionNode); var memoryB = new BetaMemory <Customer>(junction); var joinJunction = new JoinNode <Customer>(memoryB); var memoryA = new BetaMemory <Customer>(joinJunction); memoryA.Activate(_context); memoryB.Activate(_context); _agenda.Execute(); _context.VerifyAllExpectations(); }
public void Setup() { _called = null; var productionNode = new DelegateProductionNode<A>(16, (session,x) => _called = x); var constantNode = new ConstantNode<A>(42); var joinNode = new JoinNode<A>(69, constantNode); joinNode.AddActivation(productionNode); var engine = new OdoyuleRulesEngine(new OdoyuleRuntimeConfigurator()); AlphaNode<A> alphaNode = engine.GetAlphaNode<A>(); alphaNode.AddActivation(joinNode); using (Session session = engine.CreateSession()) { session.Add(new A()); session.Run(); } }
/// <summary> /// Called when [join node] is visited. /// </summary> /// <param name="node">The node.</param> public override void OnJoinNode(JoinNode node) { _sb.Append(_indentString).Append("Join Node <---------- "); node.AlphaMemory.Accept(this); if (node.IsHeadOfSubNetwork) { _sb.Append("").AppendLine(" |"); _indentString = " | "; _sb.Append(" |--------> ").AppendLine("SUBNETWORK"); _sb.Append(_indentString).AppendLine(" |"); _sb.Append(_indentString).AppendLine(" V"); foreach (ReteNode child in node.Children) { if ((child is NCCNode) == false) child.Accept(this); } } else { _sb.Append(_indentString).AppendLine(" |"); _sb.Append(_indentString).AppendLine(" V"); foreach (ReteNode child in node.Children) { child.Accept(this); } } }
private void traceStatement(JoinNode statement, string methodName) { Tracing.Tracer.LogVerboseSubSeparator("Filter DataStore -- "+ methodName); Tracing.Tracer.LogVerboseValue("statement.TableName", statement.TableName); Tracing.Tracer.LogVerboseValue("statement", statement); Tracing.Tracer.LogVerboseValue("FilterProviderManager.Providers.Count", FilterProviderManager.Providers.Count); }
public void Pulling_an_element_through_two_memories_should_merge_properly() { var junction = new JoinNode<Customer>(_constantNode); junction.AddSuccessor(_actionNode); var alphaNodeA = new AlphaNode<Customer>(); alphaNodeA.AddSuccessor(junction); var joinJunction = new JoinNode<Customer>(alphaNodeA); var alphaNodeB = new AlphaNode<Customer>(); alphaNodeB.AddSuccessor(joinJunction); alphaNodeA.Activate(_context); alphaNodeB.Activate(_context); _session.Run(); }
internal static NodeInfo Create(JoinNode node) { return new NodeInfo(NodeType.Join, string.Empty, node.Conditions.Select(c => c.ToString()), Empty, Empty); }
private void Process(JoinNode node) { if (node == null) return; node.Alias = ProcessAlias(node.Alias); Process(node.Condition); if (node.SubNodes != null) foreach (JoinNode sub in node.SubNodes) Process(sub); }
/// <summary> /// Called when [join node] is visited. /// </summary> /// <param name="node">The node.</param> public virtual void OnJoinNode(JoinNode node) { }
private void CollectTables(JoinNode node) { string alias = node.Alias ?? string.Empty; if (!tables.ContainsKey(alias)) { DBTableEx table = XPDictionaryInformer.TranslateAndGet(node.TableName); if (table != null && table.IsCustom) { DBTableEx table2 = table.CustomPersistent.GetTable(dataStore); tables.Add(alias, new Tuple<DBTableEx, DBTableEx>(table, table2)); } } if (node.SubNodes != null) foreach (JoinNode subNode in node.SubNodes) CollectTables(subNode); }
private List<JoinNode> JoinTags(string sql, string joinClause) { var joinTags = new List<JoinNode>(); var startIndex = 0; var fromIndex = sql.IndexOf(joinClause, startIndex, StringComparison.InvariantCultureIgnoreCase); while (fromIndex > 0) { var joinNode = new JoinNode(); joinNode.Position = fromIndex; joinNode.Name = joinClause; joinTags.Add(joinNode); startIndex = fromIndex + 1; fromIndex = sql.IndexOf(joinClause, startIndex, StringComparison.InvariantCultureIgnoreCase); } return joinTags; }
private void Process(JoinNode node) { if (node == null) return; string alias = node.Alias ?? string.Empty; if (tables.ContainsKey(alias)) { Tuple<DBTableEx, DBTableEx> replace = tables[alias]; node.TableName = replace.Item2.Name; } Process(node.Condition); if (node.SubNodes != null) foreach (JoinNode sub in node.SubNodes) Process(sub); }
private void AppendJoinNode(JoinNode node, StringBuilder joins) { if (formatter.BraceJoin) joins.Insert(0, "("); joins.Append("\n "); joins.Append(node.Type == JoinType.Inner ? "inner" : "left"); joins.Append(" join "); joins.Append(GetTableOrView(node)); joins.Append(" on "); joins.Append(Process(node.Condition)); if (formatter.BraceJoin) joins.Append(')'); foreach (JoinNode subNode in node.SubNodes) AppendJoinNode(subNode, joins); }
private string GetTableOrView(JoinNode node) { string nodeName = translateNames ? XPDictionaryInformer.TranslateTableName(node.TableName) : node.TableName; bool isCustom = customAliases != null && customAliases.Contains(node.Alias ?? string.Empty); if (isCustom) return formatterSequred.FormatCustomTable(nodeName, node.Alias); string nodeSchema = formatter.ComposeSafeSchemaName(nodeName); string nodeTable = formatter.ComposeSafeTableName(nodeName); return secured ? formatterSequred.FormatView(nodeSchema, nodeTable, node.Alias) : formatterSequred.FormatTable(nodeSchema, nodeTable, node.Alias); }