Пример #1
0
 public void incrementProgramCounter() throws TeiidComponentException {
   if (this.programs.isEmpty()) {
     return;
   }
   Program program = peek();
   ProgramInstruction instr = program.getCurrentInstruction();
   if (instr instanceof RepeatedInstruction) {
     RepeatedInstruction repeated = (RepeatedInstruction) instr;
     repeated.postInstruction(this);
   }
   peek().incrementProgramCounter();
 }
Пример #2
0
  public void push(Program program) throws XATransactionException {
    this.evaluator.close();
    program.reset(this.getContext().getConnectionId());
    program.setTrappingExceptions(
        program.getExceptionGroup() != null
            || (!this.programs.isEmpty() && this.programs.peek().isTrappingExceptions()));
    TempTableStore tts = getTempTableStore();
    getContext().setTempTableStore(program.getTempTableStore());
    program.getTempTableStore().setParentTempTableStore(tts);
    this.programs.push(program);
    VariableContext context = new VariableContext(true);
    context.setParentContext(this.currentVarContext);
    this.currentVarContext = context;
    VariableContext cc = new VariableContext(true);
    cc.setParentContext(this.cursorStates);
    this.cursorStates = cc;

    if (program.isAtomic() && this.blockContext == null) {
      TransactionContext tc = this.getContext().getTransactionContext();
      if (tc != null && tc.getTransactionType() == Scope.NONE) {
        // start a transaction
        this.getContext().getTransactionServer().begin(tc);
        this.blockContext = tc;
        program.setStartedTxn(true);
      }
    }
  }
Пример #3
0
 public ProcessorPlan clone() {
   ProcedurePlan plan = new ProcedurePlan(originalProgram.clone());
   plan.setOutputElements(this.getOutputElements());
   plan.setParams(params);
   plan.setOutParams(outParams);
   plan.setMetadata(metadata);
   plan.requiresTransaction = requiresTransaction;
   plan.runInContext = runInContext;
   return plan;
 }
Пример #4
0
 /**
  * @param success
  * @throws TeiidComponentException
  * @throws XATransactionException
  */
 public void pop(boolean success) throws TeiidComponentException {
   this.evaluator.close();
   Program program = this.programs.pop();
   VariableContext vc = this.currentVarContext;
   VariableContext cs = this.cursorStates;
   try {
     this.currentVarContext = this.currentVarContext.getParentContext();
     this.cursorStates = this.cursorStates.getParentContext();
     TempTableStore tempTableStore = program.getTempTableStore();
     this.getContext().setTempTableStore(tempTableStore.getParentTempTableStore());
     tempTableStore.removeTempTables();
     if (program.startedTxn()) {
       TransactionService ts = this.getContext().getTransactionServer();
       TransactionContext tc = this.blockContext;
       this.blockContext = null;
       try {
         ts.resume(tc);
         for (WeakReference<DataTierTupleSource> ref : txnTupleSources) {
           DataTierTupleSource dtts = ref.get();
           if (dtts != null) {
             dtts.fullyCloseSource();
           }
         }
         this.txnTupleSources.clear();
         if (success) {
           ts.commit(tc);
         } else {
           ts.rollback(tc);
         }
       } catch (XATransactionException e) {
         throw new TeiidComponentException(QueryPlugin.Event.TEIID30165, e);
       }
     }
   } finally {
     removeAllCursors(cs);
   }
 }
Пример #5
0
 @Override
 public Boolean requiresTransaction(boolean transactionalReads) {
   return program.requiresTransaction(transactionalReads);
 }
Пример #6
0
  /**
   * Process the procedure, using the stack of Programs supplied by the ProcessorEnvironment. With
   * each pass through the loop, the current Program is gotten off the top of the stack, and the
   * current instruction is gotten from that program; each call to an instruction's process method
   * may alter the Program Stack and/or the current instruction pointer of a Program, so it's
   * important that this method's loop refer to the call stack of the ProcessorEnvironment each
   * time, and not cache things in local variables. If the current Program's current instruction is
   * null, then it's time to pop that Program off the stack.
   *
   * @return List a single tuple containing one Integer: the update count resulting from the
   *     procedure execution.
   */
  private TupleSource processProcedure()
      throws TeiidComponentException, TeiidProcessingException, BlockedException {

    // execute plan
    ProgramInstruction inst = null;

    while (!this.programs.empty()) {
      Program program = peek();
      inst = program.getCurrentInstruction();
      if (inst == null) {
        LogManager.logTrace(
            org.teiid.logging.LogConstants.CTX_DQP, "Finished program", program); // $NON-NLS-1$
        // look ahead to see if we need to process in place
        VariableContext vc = this.cursorStates.getParentContext();
        CursorState last = (CursorState) this.cursorStates.getValue(null);
        if (last != null) {
          if (last.resultsBuffer == null && (last.usesLocalTemp || !txnTupleSources.isEmpty())) {
            last.resultsBuffer =
                bufferMgr.createTupleBuffer(
                    last.processor.getOutputElements(),
                    getContext().getConnectionId(),
                    TupleSourceType.PROCESSOR);
            last.returning = true;
          }
          if (last.returning) {
            while (last.ts.hasNext()) {
              List<?> tuple = last.ts.nextTuple();
              last.resultsBuffer.addTuple(tuple);
            }
            last.resultsBuffer.close();
            last.ts = last.resultsBuffer.createIndexedTupleSource(true);
            last.returning = false;
          }
        }
        this.pop(true);
        continue;
      }
      try {
        if (inst instanceof RepeatedInstruction) {
          LogManager.logTrace(
              org.teiid.logging.LogConstants.CTX_DQP,
              "Executing repeated instruction",
              inst); //$NON-NLS-1$
          RepeatedInstruction loop = (RepeatedInstruction) inst;
          if (loop.testCondition(this)) {
            LogManager.logTrace(
                org.teiid.logging.LogConstants.CTX_DQP,
                "Passed condition, executing program " + loop.getNestedProgram()); // $NON-NLS-1$
            inst.process(this);
            this.push(loop.getNestedProgram());
            continue;
          }
          LogManager.logTrace(
              org.teiid.logging.LogConstants.CTX_DQP,
              "Exiting repeated instruction",
              inst); //$NON-NLS-1$
          loop.postInstruction(this);
        } else {
          LogManager.logTrace(
              org.teiid.logging.LogConstants.CTX_DQP, "Executing instruction", inst); // $NON-NLS-1$
          inst.process(this);
          this.evaluator.close();
        }
      } catch (RuntimeException e) {
        throw e;
      } catch (TeiidComponentException e) {
        throw e;
      } catch (Exception e) {
        // processing or teiidsqlexception
        boolean atomic = program.isAtomic();
        while (program.getExceptionGroup() == null) {
          this.pop(false);
          if (this.programs.empty()) {
            // reached the top without a handler, so throw
            if (e instanceof TeiidProcessingException) {
              throw (TeiidProcessingException) e;
            }
            throw new ProcedureErrorInstructionException(QueryPlugin.Event.TEIID30167, e);
          }
          program = peek();
          atomic |= program.isAtomic();
        }
        this.pop(false); // allow the current program to go out of scope
        if (atomic) {
          TransactionContext tc = this.getContext().getTransactionContext();
          if (tc != null && tc.getTransactionType() != Scope.NONE) {
            // a non-completing atomic block under a higher level transaction

            // this will not work correctly until we support
            // checkpoints/subtransactions
            try {
              tc.getTransaction().setRollbackOnly();
            } catch (IllegalStateException e1) {
              throw new TeiidComponentException(e1);
            } catch (SystemException e1) {
              throw new TeiidComponentException(e1);
            }
          }
        }
        if (program.getExceptionProgram() == null) {
          continue;
        }
        Program exceptionProgram = program.getExceptionProgram();
        this.push(exceptionProgram);
        TeiidSQLException tse = TeiidSQLException.create(e);
        GroupSymbol gs = new GroupSymbol(program.getExceptionGroup());
        this.currentVarContext.setValue(exceptionSymbol(gs, 0), tse.getSQLState());
        this.currentVarContext.setValue(exceptionSymbol(gs, 1), tse.getErrorCode());
        this.currentVarContext.setValue(exceptionSymbol(gs, 2), tse.getTeiidCode());
        this.currentVarContext.setValue(exceptionSymbol(gs, 3), tse);
        this.currentVarContext.setValue(exceptionSymbol(gs, 4), tse.getCause());
        continue;
      }
      program.incrementProgramCounter();
    }
    CursorState last = (CursorState) this.cursorStates.getValue(null);
    if (last == null) {
      return CollectionTupleSource.createNullTupleSource();
    }
    return last.ts;
  }