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(); }
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); } } }
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; }
/** * @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); } }
@Override public Boolean requiresTransaction(boolean transactionalReads) { return program.requiresTransaction(transactionalReads); }
/** * 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; }