Example #1
0
  @Override
  protected synchronized TupleBatch nextBatchDirect()
      throws BlockedException, TeiidComponentException, TeiidProcessingException {

    evaluate(false);

    if (streaming) {
      while (state == State.BUILDING) {
        try {
          this.wait();
        } catch (InterruptedException e) {
          throw new TeiidRuntimeException(QueryPlugin.Event.TEIID30169, e);
        }
      }
      unwrapException(asynchException);
      TupleBatch batch = this.buffer.getBatch(outputRow);
      outputRow = batch.getEndRow() + 1;
      if (state != State.DONE && !batch.getTerminationFlag()) {
        state = hasNextBatch() ? State.AVAILABLE : State.BUILDING;
      }
      return batch;
    }

    while (!isBatchFull() && !isLastBatch()) {
      if (item == null) {
        try {
          item = result.iter.next();
        } catch (XPathException e) {
          throw new TeiidProcessingException(
              QueryPlugin.Event.TEIID30170,
              e,
              QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30170, e.getMessage()));
        }
        rowCount++;
        if (item == null) {
          terminateBatches();
          break;
        }
      }
      addBatchRow(processRow());
      if (rowCount == rowLimit) {
        terminateBatches();
        break;
      }
    }
    return pullBatch();
  }
Example #2
0
  private TupleBatch nextBatchDirect()
      throws BlockedException, TeiidProcessingException, TeiidComponentException {

    boolean done = false;
    TupleBatch result = null;

    try {
      init();
      long currentTime = System.currentTimeMillis();
      Assertion.assertTrue(!processorClosed);

      // TODO: see if there is pending work before preempting

      while (currentTime < context.getTimeSliceEnd() || context.isNonBlocking()) {
        if (requestCanceled) {
          throw new TeiidProcessingException(
              QueryPlugin.Event.TEIID30160,
              QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30160, getProcessID()));
        }
        if (currentTime > context.getTimeoutEnd()) {
          throw new TeiidProcessingException(
              QueryPlugin.Event.TEIID30161, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30161));
        }
        result = processPlan.nextBatch();

        if (continuous) {
          result.setRowOffset(rowOffset);

          if (result.getTerminationFlag()) {
            result.setTermination(TupleBatch.ITERATION_TERMINATED);
            List<Object> terminationTuple =
                Arrays.asList(new Object[this.getOutputElements().size()]);
            result.getTuples().add(terminationTuple);
            this.context.getTupleSourceCache().close();
            this.processPlan.close();
            this.processPlan.reset();
            this.context.incrementReuseCount();
            this.open = false;
          }

          rowOffset = result.getEndRow() + 1;
        }

        if (result.getTermination() != TupleBatch.NOT_TERMINATED) {
          if (result.getTerminationFlag()) {
            done = true;
          }
          break;
        }

        if (result.getRowCount() > 0) {
          break;
        }
      }
    } catch (BlockedException e) {
      throw e;
    } catch (TeiidException e) {
      closeProcessing();
      if (e instanceof TeiidProcessingException) {
        throw (TeiidProcessingException) e;
      }
      if (e instanceof TeiidComponentException) {
        throw (TeiidComponentException) e;
      }
      throw new TeiidComponentException(QueryPlugin.Event.TEIID30162, e);
    }
    if (done) {
      closeProcessing();
    }
    if (result == null) {
      throw EXPIRED_TIME_SLICE;
    }
    return result;
  }
Example #3
0
  /**
   * Get batch from child node Walk through each row of child batch Bind values to insertCommand
   * Execute insertCommand Update insertCount When no more data is available, output batch with
   * single row containing insertCount
   */
  public TupleBatch nextBatchDirect()
      throws BlockedException, TeiidComponentException, TeiidProcessingException {

    while (phase == REQUEST_CREATION) {

      checkExitConditions();

      /* If we don't have a batch to work, get the next
       */
      if (currentBatch == null) {
        if (sourceDone) {
          phase = RESPONSE_PROCESSING;
          break;
        }
        currentBatch = getChildren()[0].nextBatch(); // can throw BlockedException
        sourceDone = currentBatch.getTerminationFlag();
        this.batchRow = currentBatch.getBeginRow();

        // normally we would want to skip a 0 sized batch, but it typically represents the terminal
        // batch
        // and for implicit temp tables we need to issue an empty insert
        if (currentBatch.getRowCount() == 0
            && (!currentBatch.getTerminationFlag() || mode != Mode.ITERATOR)) {
          currentBatch = null;
          continue;
        }
      }

      int batchSize = currentBatch.getRowCount();
      int requests = 1;
      switch (mode) {
        case ITERATOR:
          if (buffer == null) {
            buffer =
                getBufferManager()
                    .createTupleBuffer(intoElements, getConnectionID(), TupleSourceType.PROCESSOR);
          }
          buffer.addTupleBatch(currentBatch, true);
          if (currentBatch.getTerminationFlag()
              && (buffer.getRowCount() != 0 || intoGroup.isImplicitTempGroupSymbol())) {
            Insert insert = new Insert(intoGroup, intoElements, null);
            buffer.close();
            insert.setTupleSource(buffer.createIndexedTupleSource(true));
            // Register insert command against source
            registerRequest(insert);
          } else {
            requests = 0;
          }
          break;
        case BATCH:
          // Register batched update command against source
          int endRow = currentBatch.getEndRow();
          List<Command> rows = new ArrayList<Command>(endRow - batchRow);
          for (int rowNum = batchRow; rowNum <= endRow; rowNum++) {

            Insert insert =
                new Insert(
                    intoGroup,
                    intoElements,
                    convertValuesToConstants(currentBatch.getTuple(rowNum), intoElements));
            rows.add(insert);
          }
          registerRequest(new BatchedUpdateCommand(rows));
          break;
        case SINGLE:
          batchSize = 1;
          // Register insert command against source
          // Defect 16036 - submit a new INSERT command to the DataManager.
          registerRequest(
              new Insert(
                  intoGroup,
                  intoElements,
                  convertValuesToConstants(currentBatch.getTuple(batchRow), intoElements)));
      }

      this.batchRow += batchSize;
      if (batchRow > currentBatch.getEndRow()) {
        currentBatch = null;
      }
      this.requestsRegistered += requests;
    }

    checkExitConditions();

    // End this node's work
    addBatchRow(Arrays.asList(insertCount));
    terminateBatches();
    return pullBatch();
  }