Example #1
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);
      }
    }
  }
Example #2
0
 private TempTableSynchronization getSynchronization(CommandContext context)
     throws TeiidProcessingException {
   TempTableSynchronization synch = null;
   if (context == null || transactionMode == TransactionMode.NONE) {
     return null;
   }
   TransactionContext tc = context.getTransactionContext();
   if (tc == null || tc.getTransactionType() == Scope.NONE) {
     return null;
   }
   String transactionId = tc.getTransactionId();
   synch = synchronizations.get(transactionId);
   if (synch == null) {
     boolean success = false;
     try {
       synch = new TempTableSynchronization(transactionId);
       synchronizations.put(transactionId, synch);
       tc.getTransaction().registerSynchronization(synch);
       success = true;
     } catch (RollbackException e) {
       throw new TeiidProcessingException(QueryPlugin.Event.TEIID30223, e);
     } catch (SystemException e) {
       throw new TeiidProcessingException(QueryPlugin.Event.TEIID30224, e);
     } finally {
       if (!success) {
         synchronizations.remove(transactionId);
       }
     }
   }
   return synch;
 }
Example #3
0
 private TempTable getTempTable(
     String tempTableID,
     Command command,
     BufferManager buffer,
     boolean delegate,
     boolean forUpdate,
     CommandContext context)
     throws TeiidProcessingException {
   final TempTable tempTable = tempTables.get(tempTableID);
   if (tempTable != null) {
     // isolate if needed
     if (forUpdate) {
       if (transactionMode == TransactionMode.ISOLATE_WRITES) {
         TransactionContext tc = context.getTransactionContext();
         if (tc != null) {
           TempTableSynchronization synch = getSynchronization(context);
           if (synch != null && synch.existingTables.contains(tempTable.getId())) {
             TempTable result = synch.tables.get(tempTableID);
             if (result == null) {
               synchronized (synch) {
                 if (synch.isCompleted()) {
                   throw new AssertionError("Expected active transaction"); // $NON-NLS-1$
                 }
                 if (!tempTable.getActive().compareAndSet(0, 1)) {
                   throw new TeiidProcessingException(
                       QueryPlugin.Event.TEIID30227,
                       QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30227, tempTableID));
                 }
                 synch.tables.put(tempTableID, tempTable.clone());
               }
             }
             return tempTable;
           }
         } else if (tempTable.getActive().get() != 0) {
           throw new TeiidProcessingException(
               QueryPlugin.Event.TEIID30227,
               QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30227, tempTableID));
         }
       }
     } else if (transactionMode == TransactionMode.ISOLATE_READS) {
       TransactionContext tc = context.getTransactionContext();
       if (tc != null && tc.getIsolationLevel() > Connection.TRANSACTION_READ_COMMITTED) {
         TempTableSynchronization synch = getSynchronization(context);
         if (synch != null) {
           TempTable result = synch.tables.get(tempTableID);
           if (result == null) {
             result = tempTable;
             synchronized (synch) {
               if (!synch.isCompleted()) {
                 synch.tables.put(tempTableID, tempTable);
                 result.getActive().getAndIncrement();
               }
             }
           }
           return result;
         }
       }
     }
     return tempTable;
   }
   if (delegate && this.parentTempTableStore != null) {
     return this.parentTempTableStore.getTempTable(
         tempTableID, command, buffer, delegate, forUpdate, context);
   }
   return null;
 }
Example #4
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;
  }