Package org.drools.core.common

Examples of org.drools.core.common.LeftTupleSets

232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
                      LeftTupleSets trgTuples,
                      InternalWorkingMemory wm,
                      LinkedList<StackEntry> stack,
                      Set<String> visitedRules,
                      boolean processRian) {
        LeftTupleSets srcTuples;
        SegmentMemory smem = smems[smemIndex];
        while (true) {
            srcTuples = trgTuples; // previous target, is now the source
            if (log.isTraceEnabled()) {
                int offset = getOffset(node);
                log.trace("{} {} {}", indent(offset), node.toString(), srcTuples.toStringSizes());
            }

            if (NodeTypeEnums.isTerminalNode(node)) {
                TerminalNode rtn = rmem.getRuleTerminalNode();
                if (node.getType() == NodeTypeEnums.QueryTerminalNode) {
                    pQtNode.doNode((QueryTerminalNode) rtn,
                                   wm,
                                   srcTuples,
                                   stack);
                } else {
                    pRtNode.doNode(rtn,
                                   wm,
                                   srcTuples);
                }
                return;
            } else if (NodeTypeEnums.RightInputAdaterNode == node.getType()) {
                doRiaNode2(wm, srcTuples, (RightInputAdapterNode) node, stack);
                return;
            }

            LeftTupleSets stagedLeftTuples;
            if (node == smem.getTipNode() && smem.getFirst() != null) {
                // we are about to process the segment tip, allow it to merge insert/update/delete clashes
                // Can happen if the next segments have not yet been initialized
                stagedLeftTuples = smem.getFirst().getStagedLeftTuples();
            } else {
                stagedLeftTuples = null;
            }

            LeftTupleSinkNode sink = ((LeftTupleSource) node).getSinkPropagator().getFirstLeftTupleSink();

            trgTuples = new LeftTupleSets();

            if (NodeTypeEnums.isBetaNode(node)) {
                BetaNode betaNode = (BetaNode) node;

                BetaMemory bm = null;
View Full Code Here
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
            // order of left and right operations is to minimise wasted of innefficient joins.

            // We need to collect which leftTuple where updated, so that we can
            // add their result tuple to the real target tuples later
            LeftTupleSets tempLeftTuples = new LeftTupleSets();

            if (srcLeftTuples.getDeleteFirst() != null) {
                // use the real target here, as dealing direct with left tuples
                doLeftDeletes(accNode, am, wm, srcLeftTuples, trgLeftTuples);
            }

            if (srcRightTuples.getDeleteFirst() != null) {
                doRightDeletes(accNode, am, wm, srcRightTuples, tempLeftTuples);
            }

            if (srcLeftTuples.getUpdateFirst() != null || srcRightTuples.getUpdateFirst() != null) {
                dpUpdatesReorderLeftMemory(am.getBetaMemory(), wm,
                                           srcRightTuples, srcLeftTuples);
                dpUpdatesReorderRightMemory(am.getBetaMemory(), wm,
                                            srcRightTuples, srcLeftTuples);
            }

            if (srcLeftTuples.getUpdateFirst() != null) {
                doLeftUpdates(accNode, sink, am, wm, srcLeftTuples, tempLeftTuples);
            }

            if (srcRightTuples.getUpdateFirst() != null) {
                doRightUpdates(accNode, sink, am, wm, srcRightTuples, tempLeftTuples);
            }

            if (srcRightTuples.getInsertFirst() != null) {
                doRightInserts(accNode, sink, am, wm, srcRightTuples, tempLeftTuples);
            }

            if (srcLeftTuples.getInsertFirst() != null) {
                doLeftInserts(accNode, sink, am, wm, srcLeftTuples, tempLeftTuples);
            }

            Accumulate accumulate = accNode.getAccumulate();
            // we do not need collect retracts. RightTuple retracts end up as updates for lefttuples.
            // LeftTuple retracts are already on the trgLeftTuples
            for (LeftTuple leftTuple = tempLeftTuples.getInsertFirst(); leftTuple != null; ) {
                LeftTuple next = leftTuple.getStagedNext();
                evaluateResultConstraints(accNode, sink, accumulate, leftTuple, leftTuple.getPropagationContext(),
                                          wm, am, (AccumulateContext) leftTuple.getObject(), useLeftMemory,
                                          trgLeftTuples, stagedLeftTuples);
                leftTuple.clearStaged();
                leftTuple = next;
            }

            for (LeftTuple leftTuple = tempLeftTuples.getUpdateFirst(); leftTuple != null; ) {
                LeftTuple next = leftTuple.getStagedNext();
                evaluateResultConstraints(accNode, sink, accumulate, leftTuple, leftTuple.getPropagationContext(),
                                          wm, am, (AccumulateContext) leftTuple.getObject(), useLeftMemory,
                                          trgLeftTuples, stagedLeftTuples);
                leftTuple.clearStaged();
View Full Code Here
788
789
790
791
792
793
794
        private LeftTupleSets resultLeftTuples;
       
        public QueryElementNodeMemory(QueryElementNode node) {
            this.node = node;
            this.resultLeftTuples = new LeftTupleSets();
        }
View Full Code Here
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
                                                      liaNode.getSinkPropagator() );
            }
            sm = sm.getFirst(); // repoint to the child sm
        }

        LeftTupleSets leftTuples = sm.getStagedLeftTuples();
        switch ( leftTuple.getStagedType() ) {
        // handle clash with already staged entries
            case LeftTuple.INSERT :
                leftTuples.removeInsert( leftTuple );
                break;
            case LeftTuple.UPDATE :
                leftTuples.removeUpdate( leftTuple );
                break;
        }

//        if ( linkOrNotify && sm.getStagedLeftTuples().deleteSize() == 0 ) {
//            // staged is empty, so notify rule, to force re-evaluation
//            sm.notifyRuleLinkSegment( wm );
//        }
        leftTuple.setPropagationContext( context );
        sm.getStagedLeftTuples().addDelete( leftTuple );

        if ( sm.getNext() != null) {
            // sm points to lia child sm, so iterate for all remaining children

            for ( sm = sm.getNext(); sm != null; sm = sm.getNext() ) {
                // iterate for peers segment memory
                leftTuple = leftTuple.getPeer();
                leftTuples = sm.getStagedLeftTuples();
                switch ( leftTuple.getStagedType() ) {
                    // handle clash with already staged entries
                    case LeftTuple.INSERT :
                        leftTuples.removeInsert( leftTuple );
                        break;
                    case LeftTuple.UPDATE :
                        leftTuples.removeUpdate( leftTuple );
                        break;
                }
                if ( sm.getStagedLeftTuples().deleteSize() == 0 ) {
                    // staged is empty, so notify rule, to force re-evaluation
                    sm.notifyRuleLinkSegment( wm );
                }
                leftTuple.setPropagationContext( context );
                leftTuples.addDelete( leftTuple );
            }
        }

        if ( lm.getAndDecreaseCounter() == 1 ) {
            if ( linkOrNotify ) {
View Full Code Here
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
                SegmentUtilities.createChildSegments( wm, sm, liaNode.getSinkPropagator() );
            }
            sm = sm.getFirst(); // repoint to the child sm
        }
       
        LeftTupleSets leftTuples = sm.getStagedLeftTuples();
                      
        LeftTupleSink sink = liaNode.getSinkPropagator().getFirstLeftTupleSink() ;

        if ( leftTuple.getStagedType() != LeftTuple.INSERT ) {
            // things staged as inserts, are left as inserts and use the pctx associated from the time of insertion
            leftTuple.setPropagationContext( context );
        }
        if ( leftTuple.getStagedType() == LeftTuple.NONE ) {
            // if LeftTuple is already staged, leave it there
            long mask = sink.getLeftInferredMask();

            if ( mask == Long.MAX_VALUE ||
                 intersect( context.getModificationMask(),  mask) ) {
                // only add to staging if masks match
               
                if ( linkOrNotify && sm.getStagedLeftTuples().updateSize() == 0 ) {
                    // staged is empty, so notify rule, to force re-evaluation
                    sm.notifyRuleLinkSegment(wm);
                }               
                leftTuples.addUpdate( leftTuple ); 
            }
        }

       
        if (  sm.getNext() != null ) {
            // sm points to lia child sm, so iterate for all remaining children
            for ( sm = sm.getNext(); sm != null; sm = sm.getNext() ) {
                // iterate for peers segment memory
                leftTuple = leftTuple.getPeer();
                leftTuples = sm.getStagedLeftTuples();

                if ( leftTuple.getStagedType() != LeftTuple.INSERT ) {
                    // things staged as inserts, are left as inserts and use the pctx associated from the time of insertion
                    leftTuple.setPropagationContext( context );
                }
                if ( leftTuple.getStagedType() == LeftTuple.NONE ) {
                    // if LeftTuple is already staged, leave it there
                    long mask =  ((LeftTupleSink) sm.getRootNode()).getLeftInferredMask();
                    if ( mask == Long.MAX_VALUE ||
                         intersect( context.getModificationMask(),  mask) ) {
                        // only add to staging if masks match
                       
                        if ( linkOrNotify && sm.getStagedLeftTuples().updateSize() == 0 ) {
                            // staged is empty, so notify rule, to force re-evaluation
                            sm.notifyRuleLinkSegment(wm);
                        }                     
                        leftTuples.addUpdate( leftTuple ); 
                    }
                }              
            }
        }
    }   
View Full Code Here
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
            LeftTupleMemory ltm = bm.getLeftTupleMemory();
            RightTupleMemory rtm = bm.getRightTupleMemory();
            ContextEntry[] contextEntry = bm.getContext();
            BetaConstraints constraints = notNode.getRawConstraints();

            LeftTupleSets stagedLeftTuples = null;
            if (!bm.getSegmentMemory().isEmpty()) {
                stagedLeftTuples = bm.getSegmentMemory().getFirst().getStagedLeftTuples();
            }

            // this must be processed here, rather than initial insert, as we need to link the blocker
View Full Code Here
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
            rightTuple.setLeftTuple( null );
            resultLeftTuple.setObject( null );

            DroolsQuery query = (DroolsQuery) this.factHandle.getObject();
            if ( unlinkedEnabled ) {
                LeftTupleSets leftTuples = query.getResultLeftTupleSets();
                LeftTuple childLeftTuple = rightTuple.getFirstChild();
                switch ( childLeftTuple.getStagedType() ) {
                    // handle clash with already staged entries
                    case LeftTuple.INSERT :
                        leftTuples.removeInsert( childLeftTuple );
                        break;
                    case LeftTuple.UPDATE :
                        leftTuples.removeUpdate( childLeftTuple );
                        break;
                }
                leftTuples.addDelete( childLeftTuple  );
                return;
            }

            RightTupleList rightTuples = query.getResultRetractRightTupleList();
            if ( rightTuples == null ) {
View Full Code Here
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
                rightTuple.setLeftTuple( resultLeftTuple );
                resultLeftTuple.setObject( rightTuple );
            }

            if ( unlinkedEnabled ) {
                LeftTupleSets leftTuples = dquery.getResultLeftTupleSets();
                LeftTuple childLeftTuple = rightTuple.getFirstChild();
                switch ( childLeftTuple.getStagedType() ) {
                    // handle clash with already staged entries
                    case LeftTuple.INSERT :
                        leftTuples.removeInsert( childLeftTuple );
                        break;
                    case LeftTuple.UPDATE :
                        leftTuples.removeUpdate( childLeftTuple );
                        break;
                }
                leftTuples.addUpdate( childLeftTuple  );
                return;
            }

            // Don't need to recreate child links, as they will already be there form the first "add"
View Full Code Here
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
                          expectedResultBuilder.isTestStagedInsert(),  expectedResultBuilder.isTestStagedDelete(),  expectedResultBuilder.isTestStagedUpdate() );
        }                    
       
        if ( !preStagedBuilders.isEmpty() ) {
            for ( StagedBuilder stagedBuilder : preStagedBuilders ) {
                LeftTupleSets expected = stagedBuilder.get();
                LeftTupleSets actual = stagedBuilder.getSegmentMemory().getStagedLeftTuples();
               
                assertEquals( expected, actual, stagedBuilder.isTestStagedInsert(), stagedBuilder.isTestStagedDelete(), stagedBuilder.isTestStagedUpdate() );   
            }
        }       
       
        SegmentMemory smem = bm.getSegmentMemory();
        SegmentPropagator.propagate(smem, actualResultLeftTuples, wm);
        if ( testLeftMemory ) {
            equalsLeftMemory( leftMemory );
        }
        if ( testRightMemory) {
            equalsRightMemory( rightMemory );
        } 
       
        if ( !postStagedBuilders.isEmpty() ) {
            for ( StagedBuilder stagedBuilder : postStagedBuilders ) {
                LeftTupleSets expected = stagedBuilder.get();
                LeftTupleSets actual = stagedBuilder.getSegmentMemory().getStagedLeftTuples();
               
                assertEquals( expected, actual, stagedBuilder.isTestStagedInsert(), stagedBuilder.isTestStagedDelete(), stagedBuilder.isTestStagedUpdate() );   
            }
        }
       
View Full Code Here
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
                          expectedResultBuilder.isTestStagedInsert(),  expectedResultBuilder.isTestStagedDelete(),  expectedResultBuilder.isTestStagedUpdate() );
        }                    
       
        if ( !preStagedBuilders.isEmpty() ) {
            for ( StagedBuilder stagedBuilder : preStagedBuilders ) {
                LeftTupleSets expected = stagedBuilder.get();
                LeftTupleSets actual = stagedBuilder.getSegmentMemory().getStagedLeftTuples();
               
                assertEquals( expected, actual, stagedBuilder.isTestStagedInsert(), stagedBuilder.isTestStagedDelete(), stagedBuilder.isTestStagedUpdate() );   
            }
        }       
       
        SegmentMemory smem = bm.getSegmentMemory();
        SegmentPropagator.propagate(smem, actualResultLeftTuples, wm);
        if ( testLeftMemory ) {
            equalsLeftMemory( leftMemory );
        }
        if ( testRightMemory) {
            equalsRightMemory( rightMemory );
        } 
       
        if ( !postStagedBuilders.isEmpty() ) {
            for ( StagedBuilder stagedBuilder : postStagedBuilders ) {
                LeftTupleSets expected = stagedBuilder.get();
                LeftTupleSets actual = stagedBuilder.getSegmentMemory().getStagedLeftTuples();
               
                assertEquals( expected, actual, stagedBuilder.isTestStagedInsert(), stagedBuilder.isTestStagedDelete(), stagedBuilder.isTestStagedUpdate() );   
            }
        }
       
View Full Code Here
TOP

Related Classes of org.drools.core.common.LeftTupleSets

  • org.drools.compiler.integrationtests.Misc2Test
  • org.drools.compiler.phreak.Scenario
  • org.drools.compiler.phreak.StagedBuilder
  • org.drools.core.phreak.AddRemoveRule
  • org.drools.core.phreak.PhreakAccumulateNode
  • org.drools.core.phreak.PhreakNotNode
  • org.drools.core.phreak.PhreakTimerNode$Executor
  • org.drools.core.phreak.RuleExecutor
  • org.drools.core.phreak.RuleNetworkEvaluator
  • org.drools.core.phreak.RuleNetworkEvaluator$PhreakAccumulateNode
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.