Package org.teiid.common.buffer

Examples of org.teiid.common.buffer.TupleBuffer


          dataManager = new TempTableDataManager(dataManager, bufferMgr, executor, cache, null, null);
        }       
        if (context.getQueryProcessorFactory() == null) {
          context.setQueryProcessorFactory(new QueryProcessorFactoryImpl(bufferMgr, dataManager, new DefaultCapabilitiesFinder(), null, context.getMetadata()));
        }
        TupleBuffer id = null;
        try {
            QueryProcessor processor = new QueryProcessor(plan, context, bufferMgr, dataManager);
            //processor.setNonBlocking(true);
            BatchCollector collector = processor.createBatchCollector();
            for (int i = 0; i < 100; i++) {
              try {
                id = collector.collectTuples();
                break;
              } catch (BlockedException e) {
               
              }
            }
            if (id == null) {
              fail("did not complete processing");
            }
            if ( expectedResults != null ) {
              examineResults(expectedResults, bufferMgr, id);
            }
        } finally {
          if (id != null) {
            id.remove();
          }
        }
    }
View Full Code Here


    public TupleBuffer getFinalBuffer() throws BlockedException, TeiidComponentException, TeiidProcessingException {
      if (this.output == null) {
        sortPhase();
      }
      usingOutput = true;
      TupleBuffer result = this.output;
      if (this.output.isFinal()) {
          this.output = null;
        close();
      }
      return result;
View Full Code Here

    public TupleBuffer collectTuples() throws TeiidComponentException, TeiidProcessingException {
        TupleBatch batch = null;
      while(!done) {
        if (this.sourceNode.hasFinalBuffer()) {
          if (this.buffer == null) {
            TupleBuffer finalBuffer = this.sourceNode.getFinalBuffer();
            Assertion.isNotNull(finalBuffer);
          this.buffer = finalBuffer;
          }
          if (this.buffer.isFinal()) {
          this.buffer.setForwardOnly(forwardOnly);
View Full Code Here

            // Sort
            if (sortUtility == null) {
              sortUtility = new SortUtility(collectionBuffer.createIndexedTupleSource(), sortItems, removeDuplicates?Mode.DUP_REMOVE_SORT:Mode.SORT, mgr, groupName, collectionBuffer.getSchema());
            }
            TupleBuffer sorted = sortUtility.sort();
            sorted.setForwardOnly(true);
            try {
              // Add all input to proxy
              TupleSource sortedSource = sorted.createIndexedTupleSource();
              while(true) {
                  List tuple = sortedSource.nextTuple();
                  if(tuple == null) {
                      break;
                  }
                  this.proxy.addInputDirect(tuple.get(0), null);
              }
            } finally {
              sorted.remove();
            }
           
            close();
        }
View Full Code Here

     
      return activeTupleBuffers;
    }

  private TupleBuffer createTupleBuffer() throws TeiidComponentException {
    TupleBuffer tb = bufferManager.createTupleBuffer(this.schema, this.groupName, TupleSourceType.PROCESSOR);
    tb.setForwardOnly(true);
    return tb;
  }
View Full Code Here

   
            if(workingTuples.isEmpty()) {
              break;
            }
     
            TupleBuffer sublist = createTupleBuffer();
            activeTupleBuffers.add(sublist);
            if (this.mode == Mode.SORT) {
              //perform a stable sort
            Collections.sort((List<List<?>>)workingTuples, comparator);
            }
            for (List<?> list : workingTuples) {
          sublist.addTuple(list);
        }
            workingTuples = null;
             
            sublist.saveBatch();
            } finally {
            bufferManager.releaseBuffers(totalReservedBuffers);
            }
        }
     
View Full Code Here

    protected void mergePhase() throws TeiidComponentException, TeiidProcessingException {
      while(this.activeTupleBuffers.size() > 1) {       
        ArrayList<SortedSublist> sublists = new ArrayList<SortedSublist>(activeTupleBuffers.size());
           
            TupleBuffer merged = createTupleBuffer();

            int desiredSpace = activeTupleBuffers.size() * schemaSize;
            int reserved = Math.min(desiredSpace, this.bufferManager.getMaxProcessingKB());
            bufferManager.reserveBuffers(reserved, BufferReserveMode.FORCE);
            if (desiredSpace > reserved) {
              reserved += bufferManager.reserveBuffers(desiredSpace - reserved, BufferReserveMode.WAIT);
            }
            int maxSortIndex = Math.max(2, reserved / schemaSize); //always allow progress
            //release any partial excess
            int release = reserved % schemaSize > 0 ? 1 : 0;
            bufferManager.releaseBuffers(release);
            reserved -= release;
            try {
            if (LogManager.isMessageToBeRecorded(org.teiid.logging.LogConstants.CTX_DQP, MessageLevel.TRACE)) {
                LogManager.logTrace(org.teiid.logging.LogConstants.CTX_DQP, "Merging", maxSortIndex, "sublists out of", activeTupleBuffers.size()); //$NON-NLS-1$ //$NON-NLS-2$
              }
            // initialize the sublists with the min value
              for(int i = 0; i<maxSortIndex; i++) {
                 TupleBuffer activeID = activeTupleBuffers.get(i);
                 SortedSublist sortedSublist = new SortedSublist();
                sortedSublist.its = activeID.createIndexedTupleSource();
                sortedSublist.index = i;
                if (activeID == output) {
                  sortedSublist.limit = output.getRowCount();
                }
                incrementWorkingTuple(sublists, sortedSublist);
              }
             
              // iteratively process the lowest tuple
              while (sublists.size() > 0) {
                SortedSublist sortedSublist = sublists.remove(sublists.size() - 1);
              merged.addTuple(sortedSublist.tuple);
                  if (this.output != null && sortedSublist.index > masterSortIndex) {
                    this.output.addTuple(sortedSublist.tuple); //a new distinct row
                }
                incrementWorkingTuple(sublists, sortedSublist);
              }               
 
              // Remove merged sublists
              for(int i=0; i<maxSortIndex; i++) {
                TupleBuffer id = activeTupleBuffers.remove(0);
                if (id != this.output) {
                  id.remove();
                }
              }
              merged.saveBatch();
              this.activeTupleBuffers.add(merged);          
              masterSortIndex = masterSortIndex - maxSortIndex + 1;
              if (masterSortIndex < 0) {
                masterSortIndex = this.activeTupleBuffers.size() - 1;
              }
            } finally {
              this.bufferManager.releaseBuffers(reserved);
            }
        }
     
        // Close sorted source (all others have been removed)
        if (doneReading) {
          if (this.output != null) {
            this.output.close();
            TupleBuffer last = activeTupleBuffers.remove(0);
            if (output != last) {
              last.remove();
            }
          } else {
            activeTupleBuffers.get(0).close();
            activeTupleBuffers.get(0).setForwardOnly(false);
          }
View Full Code Here

              this.joinStrategy.leftSource.setImplicitBuffer(ImplicitBuffer.NONE);
            }
          //left child was already opened by the join node
            this.joinStrategy.loadLeft();
            if (isDependent()) {
                TupleBuffer buffer = this.joinStrategy.leftSource.getTupleBuffer();
                this.getContext().getVariableContext().setGlobalValue(this.dependentValueSource, new DependentValueSource(buffer));
            }
            state = State.LOAD_RIGHT;
        }
        if (state == State.LOAD_RIGHT) {
View Full Code Here

        for (String type : types) {
          ElementSymbol es = new ElementSymbol("x"); //$NON-NLS-1$
          es.setType(DataTypeManager.getDataTypeClass(type));
          schema.add(es);
        }
        TupleBuffer buffer = bufferManager.createTupleBuffer(schema, "cached", TupleSourceType.FINAL); //$NON-NLS-1$
        buffer.setBatchSize(this.batchSize);
        if (this.hint != null) {
          buffer.setPrefersMemory(this.hint.getPrefersMemory());
        }
       
        for (int row = 1; row <= this.rowCount; row+=this.batchSize) {
          TupleBatch batch = (TupleBatch)cache.get(uuid+","+row); //$NON-NLS-1$
          if (batch != null) {         
            buffer.addTupleBatch(batch, true);
          }         
        }
        this.results = buffer; 
        bufferManager.addTupleBuffer(this.results);
        this.results.close();
View Full Code Here

      Arrays.asList(1),
      Arrays.asList(2),
      Arrays.asList(3)
    }, 2));
    BufferManager bm = BufferManagerFactory.getStandaloneBufferManager();
    TupleBuffer tb = bm.createTupleBuffer(Arrays.asList(new ElementSymbol("x")), "test", TupleSourceType.PROCESSOR);
    bi.setBuffer(tb, true)//$NON-NLS-1$
    bi.nextTuple();
    bi.mark();
    bi.nextTuple();
    bi.reset();
View Full Code Here

TOP

Related Classes of org.teiid.common.buffer.TupleBuffer

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.