Beispiel #1
0
void TupleHavingStep::execute()
{
	RGData rgDataIn;
	RGData rgDataOut;
	bool more = false;

	try
	{
		more = fInputDL->next(fInputIterator, &rgDataIn);
		dlTimes.setFirstReadTime();

		if (!more && cancelled())
		{
			fEndOfResult = true;
		}

		while (more && !fEndOfResult)
		{
			fRowGroupIn.setData(&rgDataIn);
			rgDataOut.reinit(fRowGroupOut, fRowGroupIn.getRowCount());
			fRowGroupOut.setData(&rgDataOut);

			doHavingFilters();

			more = fInputDL->next(fInputIterator, &rgDataIn);
			if (cancelled())
			{
				fEndOfResult = true;
			}
			else
			{
				fOutputDL->insert(rgDataOut);
			}
		}
	}
	catch(const std::exception& ex)
	{
		catchHandler(ex.what(), tupleHavingStepErr, fErrorInfo, fSessionId);
	}
	catch(...)
	{
		catchHandler("TupleHavingStep execute caught an unknown exception",
					 tupleHavingStepErr, fErrorInfo, fSessionId);
	}

	while (more)
		more = fInputDL->next(fInputIterator, &rgDataIn);

	fEndOfResult = true;
	fOutputDL->endOfInput();

	dlTimes.setLastReadTime();
	dlTimes.setEndOfInputTime();

	if (traceOn())
		printCalTrace();
}
Beispiel #2
0
uint TupleConstantOnlyStep::nextBand(messageqcpp::ByteStream &bs)
{
	RGData rgDataOut;
	uint rowCount = 0;

	if (!fEndOfResult)
	{
		try
		{
			bs.restart();

			if (traceOn() && dlTimes.FirstReadTime().tv_sec == 0)
				dlTimes.setFirstReadTime();

			rgDataOut.reinit(fRowGroupOut, 1);
			fRowGroupOut.setData(&rgDataOut);

			fillInConstants();
			fRowGroupOut.serializeRGData(bs);
			rowCount = fRowGroupOut.getRowCount();
		}
		catch(const std::exception& ex)
		{
			catchHandler(ex.what(), fSessionId);
			if (status() == 0)
				status(tupleConstantStepErr);
		}
		catch(...)
		{
			catchHandler("TupleConstantStep next band caught an unknown exception", fSessionId);
			if (status() == 0)
				status(tupleConstantStepErr);
		}

		fEndOfResult = true;
	}
	else
	{
		// send an empty / error band
		RGData rgData(fRowGroupOut, 0);
		fRowGroupOut.setData(&rgData);
		fRowGroupOut.resetRowGroup(0);
		fRowGroupOut.setStatus(status());
		fRowGroupOut.serializeRGData(bs);

		if (traceOn())
		{
			dlTimes.setLastReadTime();
			dlTimes.setEndOfInputTime();
			printCalTrace();
		}
	}

	return rowCount;
}
Beispiel #3
0
inline void CrossEngineStep::addRow(RGData &data)
{
	fRowDelivered.setRid(fRowsReturned%fRowsPerGroup);
	fRowDelivered.nextRow();
	fRowGroupDelivered.incRowCount();

	if (++fRowsReturned%fRowsPerGroup == 0)
	{
		fOutputDL->insert(data);
		data.reinit(fRowGroupDelivered, fRowsPerGroup);
		fRowGroupDelivered.setData(&data);
		fRowGroupDelivered.resetRowGroup(fRowsReturned);
		fRowGroupDelivered.getRow(0, &fRowDelivered);
	}
}
Beispiel #4
0
void SubAdapterStep::execute()
{
	RGData rgDataIn;
	RGData rgDataOut;
	Row rowIn;
	Row rowFe;
	Row rowOut;
	fRowGroupIn.initRow(&rowIn);
	fRowGroupOut.initRow(&rowOut);

	RGData rowFeData;
	bool usesFE = false;
	if (fRowGroupFe.getColumnCount() != (uint32_t) -1)
	{
		usesFE = true;
		fRowGroupFe.initRow(&rowFe, true);
		rowFeData = RGData(fRowGroupFe, 1);
		fRowGroupFe.setData(&rowFeData);
		fRowGroupFe.getRow(0, &rowFe);
	}

	bool more = false;
	try
	{
		fSubStep->run();

		more = fInputDL->next(fInputIterator, &rgDataIn);
		if (traceOn()) dlTimes.setFirstReadTime();

		while (more && !cancelled())
		{
			fRowGroupIn.setData(&rgDataIn);
			rgDataOut.reinit(fRowGroupOut, fRowGroupIn.getRowCount());
			fRowGroupOut.setData(&rgDataOut);
			fRowGroupOut.resetRowGroup(fRowGroupIn.getBaseRid());

			fRowGroupIn.getRow(0, &rowIn);
			fRowGroupOut.getRow(0, &rowOut);

			for (uint64_t i = 0; i < fRowGroupIn.getRowCount(); ++i)
			{
				if(fExpression.get() == NULL)
				{
					outputRow(rowIn, rowOut);
				}
				else if (!usesFE)
				{
					if(fExpression->evaluate(&rowIn))
					{
						outputRow(rowIn, rowOut);
					}
				}
				else
				{
					copyRow(rowIn, &rowFe, rowIn.getColumnCount());
					//memcpy(rowFe.getData(), rowIn.getData(), rowIn.getSize());
					if(fExpression->evaluate(&rowFe))
					{
						outputRow(rowFe, rowOut);
					}
				}

				rowIn.nextRow();
			}

			if (fRowGroupOut.getRowCount() > 0)
			{
				fRowsReturned += fRowGroupOut.getRowCount();
				fOutputDL->insert(rgDataOut);
			}

			more = fInputDL->next(fInputIterator, &rgDataIn);
		}
	}
	catch(const std::exception& ex)
	{
		catchHandler(ex.what(), ERR_EXEMGR_MALFUNCTION, fErrorInfo, fSessionId);
	}
	catch(...)
	{
		catchHandler("SubAdapterStep execute caught an unknown exception",
						ERR_EXEMGR_MALFUNCTION, fErrorInfo, fSessionId);
	}

	if (cancelled())
		while (more)
			more = fInputDL->next(fInputIterator, &rgDataIn);

	if (traceOn())
	{
		dlTimes.setLastReadTime();
		dlTimes.setEndOfInputTime();
		printCalTrace();
	}

	// Bug 3136, let mini stats to be formatted if traceOn.
	fOutputDL->endOfInput();
}
Beispiel #5
0
void TupleHavingStep::execute()
{
	RGData rgDataIn;
	RGData rgDataOut;
	bool more = false;
	StepTeleStats sts;
	sts.query_uuid = fQueryUuid;
	sts.step_uuid = fStepUuid;

	try
	{
		more = fInputDL->next(fInputIterator, &rgDataIn);
		dlTimes.setFirstReadTime();

		sts.msg_type = StepTeleStats::ST_START;
		sts.total_units_of_work = 1;
		postStepStartTele(sts);

		if (!more && cancelled())
		{
			fEndOfResult = true;
		}

		while (more && !fEndOfResult)
		{
			fRowGroupIn.setData(&rgDataIn);
			rgDataOut.reinit(fRowGroupOut, fRowGroupIn.getRowCount());
			fRowGroupOut.setData(&rgDataOut);

			doHavingFilters();

			more = fInputDL->next(fInputIterator, &rgDataIn);
			if (cancelled())
			{
				fEndOfResult = true;
			}
			else
			{
				fOutputDL->insert(rgDataOut);
			}
		}
	}
	catch(const std::exception& ex)
	{
		catchHandler(ex.what(), tupleHavingStepErr, fErrorInfo, fSessionId);
	}
	catch(...)
	{
		catchHandler("TupleHavingStep execute caught an unknown exception",
					 tupleHavingStepErr, fErrorInfo, fSessionId);
	}

	while (more)
		more = fInputDL->next(fInputIterator, &rgDataIn);

	fEndOfResult = true;
	fOutputDL->endOfInput();

	sts.msg_type = StepTeleStats::ST_SUMMARY;
	sts.total_units_of_work = sts.units_of_work_completed = 1;
	sts.rows = fRowsReturned;
	postStepSummaryTele(sts);

	dlTimes.setLastReadTime();
	dlTimes.setEndOfInputTime();

	if (traceOn())
		printCalTrace();
}
Beispiel #6
0
uint32_t TupleHavingStep::nextBand(messageqcpp::ByteStream &bs)
{
	RGData rgDataIn;
	RGData rgDataOut;
	bool more = false;
	uint32_t rowCount = 0;

	try
	{
		bs.restart();

		more = fInputDL->next(fInputIterator, &rgDataIn);
		if (dlTimes.FirstReadTime().tv_sec ==0)
            dlTimes.setFirstReadTime();

		if (!more || cancelled())
		{
			fEndOfResult = true;
		}

		bool emptyRowGroup = true;
		while (more && !fEndOfResult && emptyRowGroup)
		{
			if (cancelled())
			{
				while (more)
					more = fInputDL->next(fInputIterator, &rgDataIn);
				break;
			}

			fRowGroupIn.setData(&rgDataIn);
			rgDataOut.reinit(fRowGroupOut, fRowGroupIn.getRowCount());
			fRowGroupOut.setData(&rgDataOut);

			doHavingFilters();

			if (fRowGroupOut.getRowCount() > 0)
			{
				emptyRowGroup = false;
				fRowGroupOut.serializeRGData(bs);
				rowCount = fRowGroupOut.getRowCount();
			}
			else
			{
				more = fInputDL->next(fInputIterator, &rgDataIn);
			}
		}

		if (!more)
		{
			fEndOfResult = true;
		}
	}
	catch(const std::exception& ex)
	{
		catchHandler(ex.what(), tupleHavingStepErr, fErrorInfo, fSessionId);
		while (more)
			more = fInputDL->next(fInputIterator, &rgDataIn);
		fEndOfResult = true;
	}
	catch(...)
	{
		catchHandler("TupleHavingStep next band caught an unknown exception",
					 tupleHavingStepErr, fErrorInfo, fSessionId);
		while (more)
			more = fInputDL->next(fInputIterator, &rgDataIn);
		fEndOfResult = true;
	}

	if (fEndOfResult)
	{
		// send an empty / error band
		rgDataOut.reinit(fRowGroupOut, 0);
		fRowGroupOut.setData(&rgDataOut);
		fRowGroupOut.resetRowGroup(0);
		fRowGroupOut.setStatus(status());
		fRowGroupOut.serializeRGData(bs);

		dlTimes.setLastReadTime();
		dlTimes.setEndOfInputTime();

		if (traceOn())
			printCalTrace();
	}

	return rowCount;
}
Beispiel #7
0
void TupleAnnexStep::executeWithOrderBy()
{
    RGData rgDataIn;
    RGData rgDataOut;
    bool more = false;

    try
    {
        more = fInputDL->next(fInputIterator, &rgDataIn);
        if (traceOn()) dlTimes.setFirstReadTime();

        while (more && !cancelled())
        {
            fRowGroupIn.setData(&rgDataIn);
            fRowGroupIn.getRow(0, &fRowIn);

            for (uint64_t i = 0; i < fRowGroupIn.getRowCount() && !cancelled(); ++i)
            {
                fOrderBy->processRow(fRowIn);
                fRowIn.nextRow();
            }

            more = fInputDL->next(fInputIterator, &rgDataIn);
        }

        fOrderBy->finalize();

        if (!cancelled())
        {
            while (fOrderBy->getData(rgDataIn))
            {
                if (fConstant == NULL &&
                        fRowGroupOut.getColumnCount() == fRowGroupIn.getColumnCount())
                {
                    rgDataOut = rgDataIn;
                    fRowGroupOut.setData(&rgDataOut);
                }
                else
                {
                    fRowGroupIn.setData(&rgDataIn);
                    fRowGroupIn.getRow(0, &fRowIn);

                    rgDataOut.reinit(fRowGroupOut, fRowGroupIn.getRowCount());
                    fRowGroupOut.setData(&rgDataOut);
                    fRowGroupOut.resetRowGroup(fRowGroupIn.getBaseRid());
                    fRowGroupOut.setDBRoot(fRowGroupIn.getDBRoot());
                    fRowGroupOut.getRow(0, &fRowOut);

                    for (uint64_t i = 0; i < fRowGroupIn.getRowCount(); ++i)
                    {
                        if (fConstant)
                            fConstant->fillInConstants(fRowIn, fRowOut);
                        else
                            copyRow(fRowIn, &fRowOut);

                        fRowGroupOut.incRowCount();
                        fRowOut.nextRow();
                        fRowIn.nextRow();
                    }
                }

                if (fRowGroupOut.getRowCount() > 0)
                {
                    fRowsReturned += fRowGroupOut.getRowCount();
                    fOutputDL->insert(rgDataOut);
                }
            }
        }
    }
    catch(const std::exception& ex)
    {
        catchHandler(ex.what(), fSessionId);
        if (status() == 0)
            status(ERR_IN_PROCESS);
    }
    catch(...)
    {
        catchHandler("TupleAnnexStep execute caught an unknown exception", fSessionId);
        if (status() == 0)
            status(ERR_IN_PROCESS);
    }

    while (more)
        more = fInputDL->next(fInputIterator, &rgDataIn);

    if (traceOn() && !fDelivery)
    {
        dlTimes.setLastReadTime();
        dlTimes.setEndOfInputTime();
        printCalTrace();
    }

    // Bug 3136, let mini stats to be formatted if traceOn.
    fOutputDL->endOfInput();
}
Beispiel #8
0
void TupleAnnexStep::executeNoOrderByWithDistinct()
{
    scoped_ptr<DistinctMap_t> distinctMap(new DistinctMap_t(10, TAHasher(this), TAEq(this)));
    vector<RGData> dataVec;
    RGData rgDataIn;
    RGData rgDataOut;
    bool more = false;

    rgDataOut.reinit(fRowGroupOut);
    fRowGroupOut.setData(&rgDataOut);
    fRowGroupOut.resetRowGroup(0);
    fRowGroupOut.getRow(0, &fRowOut);

    fRowGroupOut.initRow(&row1);
    fRowGroupOut.initRow(&row2);

    try
    {
        more = fInputDL->next(fInputIterator, &rgDataIn);
        if (traceOn()) dlTimes.setFirstReadTime();

        while (more && !cancelled() && !fLimitHit)
        {
            fRowGroupIn.setData(&rgDataIn);
            fRowGroupIn.getRow(0, &fRowIn);

            for (uint64_t i = 0; i < fRowGroupIn.getRowCount() && !cancelled() && !fLimitHit; ++i)
            {
                pair<DistinctMap_t::iterator, bool> inserted;
                if (fConstant)
                    fConstant->fillInConstants(fRowIn, fRowOut);
                else
                    copyRow(fRowIn, &fRowOut);

                ++fRowsProcessed;
                fRowIn.nextRow();

                inserted = distinctMap->insert(fRowOut.getPointer());
                if (inserted.second) {
                    fRowGroupOut.incRowCount();
                    fRowOut.nextRow();
                    if (UNLIKELY(++fRowsReturned >= fLimitCount))
                    {
                        fLimitHit = true;
                        fJobList->abortOnLimit((JobStep*) this);
                    }

                    if (UNLIKELY(fRowGroupOut.getRowCount() >= 8192))
                    {
                        dataVec.push_back(rgDataOut);
                        rgDataOut.reinit(fRowGroupOut);
                        fRowGroupOut.setData(&rgDataOut);
                        fRowGroupOut.resetRowGroup(0);
                        fRowGroupOut.getRow(0, &fRowOut);
                    }
                }
            }

            more = fInputDL->next(fInputIterator, &rgDataIn);
        }

        if (fRowGroupOut.getRowCount() > 0)
            dataVec.push_back(rgDataOut);

        for (vector<RGData>::iterator i = dataVec.begin(); i != dataVec.end(); i++)
        {
            rgDataOut = *i;
            fRowGroupOut.setData(&rgDataOut);
            fOutputDL->insert(rgDataOut);
        }
    }
    catch(const std::exception& ex)
    {
        catchHandler(ex.what(), fSessionId);
        if (status() == 0)
            status(ERR_IN_PROCESS);
    }
    catch(...)
    {
        catchHandler("TupleAnnexStep execute caught an unknown exception", fSessionId);
        if (status() == 0)
            status(ERR_IN_PROCESS);
    }


    while (more)
        more = fInputDL->next(fInputIterator, &rgDataIn);

    if (traceOn() && !fDelivery)
    {
        dlTimes.setLastReadTime();
        dlTimes.setEndOfInputTime();
        printCalTrace();
    }

    // Bug 3136, let mini stats to be formatted if traceOn.
    fOutputDL->endOfInput();
}
Beispiel #9
0
void TupleAnnexStep::executeNoOrderBy()
{
    RGData rgDataIn;
    RGData rgDataOut;
    bool more = false;

    try
    {
        more = fInputDL->next(fInputIterator, &rgDataIn);
        if (traceOn()) dlTimes.setFirstReadTime();

        while (more && !cancelled() && !fLimitHit)
        {
            fRowGroupIn.setData(&rgDataIn);
            fRowGroupIn.getRow(0, &fRowIn);

            // Get a new output rowgroup for each input rowgroup to preserve the rids
            rgDataOut.reinit(fRowGroupOut, fRowGroupIn.getRowCount());
            fRowGroupOut.setData(&rgDataOut);
            fRowGroupOut.resetRowGroup(fRowGroupIn.getBaseRid());
            fRowGroupOut.setDBRoot(fRowGroupIn.getDBRoot());
            fRowGroupOut.getRow(0, &fRowOut);

            for (uint64_t i = 0; i < fRowGroupIn.getRowCount() && !cancelled() && !fLimitHit; ++i)
            {
                // skip first limit-start rows
                if (fRowsProcessed++ < fLimitStart)
                {
                    fRowIn.nextRow();
                    continue;
                }

                if (fConstant)
                    fConstant->fillInConstants(fRowIn, fRowOut);
                else
                    copyRow(fRowIn, &fRowOut);

                fRowGroupOut.incRowCount();
                if (++fRowsReturned < fLimitCount)
                {
                    fRowOut.nextRow();
                    fRowIn.nextRow();
                }
                else
                {
                    fLimitHit = true;
                    fJobList->abortOnLimit((JobStep*) this);
                }
            }

            if (fRowGroupOut.getRowCount() > 0)
            {
                fOutputDL->insert(rgDataOut);
            }

            more = fInputDL->next(fInputIterator, &rgDataIn);
        }
    }
    catch(const std::exception& ex)
    {
        catchHandler(ex.what(), fSessionId);
        if (status() == 0)
            status(ERR_IN_PROCESS);
    }
    catch(...)
    {
        catchHandler("TupleAnnexStep execute caught an unknown exception", fSessionId);
        if (status() == 0)
            status(ERR_IN_PROCESS);
    }

    while (more)
        more = fInputDL->next(fInputIterator, &rgDataIn);


    if (traceOn() && !fDelivery)
    {
        dlTimes.setLastReadTime();
        dlTimes.setEndOfInputTime();
        printCalTrace();
    }

    // Bug 3136, let mini stats to be formatted if traceOn.
    fOutputDL->endOfInput();
}
Beispiel #10
0
uint TupleAnnexStep::nextBand(messageqcpp::ByteStream &bs)
{
    RGData rgDataOut;
    bool more = false;
    uint rowCount = 0;

    try
    {
        bs.restart();

        more = fOutputDL->next(fOutputIterator, &rgDataOut);
        if (traceOn() && dlTimes.FirstReadTime().tv_sec ==0)
            dlTimes.setFirstReadTime();

        if (more && !cancelled())
        {
            fRowGroupDeliver.setData(&rgDataOut);
            fRowGroupDeliver.serializeRGData(bs);
            rowCount = fRowGroupDeliver.getRowCount();
        }
        else
        {
            if (more)
                more = fOutputDL->next(fOutputIterator, &rgDataOut);
            fEndOfResult = true;
        }
    }
    catch(const std::exception& ex)
    {
        catchHandler(ex.what(), fSessionId);
        if (status() == 0)
            status(ERR_IN_DELIVERY);
        while (more)
            more = fOutputDL->next(fOutputIterator, &rgDataOut);
        fEndOfResult = true;
    }
    catch(...)
    {
        catchHandler("TupleAnnexStep next band caught an unknown exception", fSessionId);
        if (status() == 0)
            status(ERR_IN_DELIVERY);
        while (more)
            more = fOutputDL->next(fOutputIterator, &rgDataOut);
        fEndOfResult = true;
    }

    if (fEndOfResult)
    {
        // send an empty / error band
        rgDataOut.reinit(fRowGroupDeliver, 0);
        fRowGroupDeliver.setData(&rgDataOut);
        fRowGroupDeliver.resetRowGroup(0);
        fRowGroupDeliver.setStatus(status());
        fRowGroupDeliver.serializeRGData(bs);

        if (traceOn())
        {
            dlTimes.setLastReadTime();
            dlTimes.setEndOfInputTime();
        }

        if (traceOn())
            printCalTrace();
    }

    return rowCount;
}
Beispiel #11
0
void TupleConstantStep::execute()
{
	RGData rgDataIn;
	RGData rgDataOut;
	bool more = false;

	try
	{
		more = fInputDL->next(fInputIterator, &rgDataIn);
		if (traceOn()) dlTimes.setFirstReadTime();

		if (!more && cancelled())
		{
			fEndOfResult = true;
		}

		while (more && !fEndOfResult)
		{
			fRowGroupIn.setData(&rgDataIn);
			rgDataOut.reinit(fRowGroupOut, fRowGroupIn.getRowCount());
			fRowGroupOut.setData(&rgDataOut);

			fillInConstants();

			more = fInputDL->next(fInputIterator, &rgDataIn);
			if (cancelled())
			{
				fEndOfResult = true;
			}
			else
			{
				fOutputDL->insert(rgDataOut);
			}
		}
	}
	catch(const std::exception& ex)
	{
		catchHandler(ex.what(), fSessionId);
		if (status() == 0)
			status(tupleConstantStepErr);
	}
	catch(...)
	{
		catchHandler("TupleConstantStep execute caught an unknown exception", fSessionId);
		if (status() == 0)
			status(tupleConstantStepErr);
	}

	if (!fEndOfResult)
		while (more)
			more = fInputDL->next(fInputIterator, &rgDataIn);

	// Bug 3136, let mini stats to be formatted if traceOn.
	if (traceOn())
	{
		dlTimes.setLastReadTime();
		dlTimes.setEndOfInputTime();
		printCalTrace();
	}

	fEndOfResult = true;
	fOutputDL->endOfInput();
}
Beispiel #12
0
void SubAdapterStep::execute()
{
	RGData rgDataIn;
	RGData rgDataOut;
	Row rowIn;
	Row rowFe;
	Row rowOut;
	fRowGroupIn.initRow(&rowIn);
	fRowGroupOut.initRow(&rowOut);

	RGData rowFeData;
	StepTeleStats sts;
	sts.query_uuid = fQueryUuid;
	sts.step_uuid = fStepUuid;
	bool usesFE = false;
	if (fRowGroupFe.getColumnCount() > 0)
	{
		usesFE = true;
		fRowGroupFe.initRow(&rowFe, true);
		rowFeData = RGData(fRowGroupFe, 1);
		fRowGroupFe.setData(&rowFeData);
		fRowGroupFe.getRow(0, &rowFe);
	}

	bool more = false;
	try
	{
		sts.msg_type = StepTeleStats::ST_START;
		sts.total_units_of_work = 1;
		postStepStartTele(sts);

		fSubStep->run();

		more = fInputDL->next(fInputIterator, &rgDataIn);
		if (traceOn()) dlTimes.setFirstReadTime();

		while (more && !cancelled())
		{
			fRowGroupIn.setData(&rgDataIn);
			rgDataOut.reinit(fRowGroupOut, fRowGroupIn.getRowCount());
			fRowGroupOut.setData(&rgDataOut);
			fRowGroupOut.resetRowGroup(fRowGroupIn.getBaseRid());

			fRowGroupIn.getRow(0, &rowIn);
			fRowGroupOut.getRow(0, &rowOut);

			fRowsInput += fRowGroupIn.getRowCount();

			for (uint64_t i = 0; i < fRowGroupIn.getRowCount(); ++i)
			{
				if(fExpression.get() == NULL)
				{
					outputRow(rowIn, rowOut);
				}
				else if (!usesFE)
				{
					if(fExpression->evaluate(&rowIn))
					{
						outputRow(rowIn, rowOut);
					}
				}
				else
				{
					copyRow(rowIn, &rowFe, rowIn.getColumnCount());
					//memcpy(rowFe.getData(), rowIn.getData(), rowIn.getSize());
					if(fExpression->evaluate(&rowFe))
					{
						outputRow(rowFe, rowOut);
					}
				}

				rowIn.nextRow();
			}

			if (fRowGroupOut.getRowCount() > 0)
			{
				fRowsReturned += fRowGroupOut.getRowCount();
				fOutputDL->insert(rgDataOut);
			}

			more = fInputDL->next(fInputIterator, &rgDataIn);
		}
	}
	catch(const std::exception& ex)
	{
		catchHandler(ex.what(), ERR_EXEMGR_MALFUNCTION, fErrorInfo, fSessionId);
	}
	catch(...)
	{
		catchHandler("SubAdapterStep execute caught an unknown exception",
						ERR_EXEMGR_MALFUNCTION, fErrorInfo, fSessionId);
	}

	if (cancelled())
		while (more)
			more = fInputDL->next(fInputIterator, &rgDataIn);

	if (traceOn())
	{
		dlTimes.setLastReadTime();
		dlTimes.setEndOfInputTime();
		printCalTrace();
	}

	sts.msg_type = StepTeleStats::ST_SUMMARY;
	sts.total_units_of_work = sts.units_of_work_completed = 1;
	sts.rows = fRowsReturned;
	postStepSummaryTele(sts);

	// Bug 3136, let mini stats to be formatted if traceOn.
	fOutputDL->endOfInput();
}