TupleInfo getTupleInfo(uint32_t columnKey, const JobInfo& jobInfo)
{
    TupleInfoMap::const_iterator cit = jobInfo.keyInfo->tupleInfoMap.find(columnKey);

    if ((cit == jobInfo.keyInfo->tupleInfoMap.end()) ||
            (cit->second.dtype == CalpontSystemCatalog::BIT))
    {
        ostringstream strstm;
        strstm << "TupleInfo for (" << jobInfo.keyInfo->tupleKeyVec[columnKey].fId << ","
               << jobInfo.keyInfo->tupleKeyVec[columnKey].fTable;

        if (jobInfo.keyInfo->tupleKeyVec[columnKey].fView.length() > 0)
            strstm << "," << jobInfo.keyInfo->tupleKeyVec[columnKey].fView;

        strstm << ") could not be found." << endl;
        cerr << strstm.str();

        Message::Args args;
        args.add(strstm.str());
        jobInfo.logger->logMessage(LOG_TYPE_DEBUG, LogMakeJobList, args,
                                   LoggingID(5, jobInfo.sessionId, jobInfo.txnId, 0));

        throw runtime_error("column's tuple info could not be found");
    }

    return cit->second;
}
Beispiel #2
0
Logger::Logger() :
	fMl1(LoggingID(28))
{
	fMsgMap[logging::M0000] = Message(logging::M0000);
	fMsgMap[logging::M0016] = Message(logging::M0016);
	fMsgMap[logging::M0045] = Message(logging::M0045);
	fMsgMap[logging::M0053] = Message(logging::M0053);
	fMsgMap[logging::M0058] = Message(logging::M0058);
	fMsgMap[logging::M0061] = Message(logging::M0061);
	fMsgMap[logging::M0069] = Message(logging::M0069);
	fMsgMap[logging::M0070] = Message(logging::M0070);
	fMsgMap[logging::M0077] = Message(logging::M0077);
}
Beispiel #3
0
Logger::Logger(unsigned subsys) :
	fMl1(LoggingID(subsys))
{
}
Beispiel #4
0
bool pColScanStep::isEmptyVal(const uint8_t *val8) const
{
    const int width = fColType.colWidth;

    switch (fColType.colDataType)
    {
		case CalpontSystemCatalog::UTINYINT:
		{
			return(*val8 == joblist::UTINYINTEMPTYROW);
		}
		case CalpontSystemCatalog::USMALLINT:
		{
			const uint16_t *val16 = reinterpret_cast<const uint16_t *>(val8);
			return(*val16 == joblist::USMALLINTEMPTYROW);
		}
		case CalpontSystemCatalog::UMEDINT:
		case CalpontSystemCatalog::UINT:
		{
			const uint32_t *val32 = reinterpret_cast<const uint32_t *>(val8);
			return(*val32 == joblist::UINTEMPTYROW);
		}
		case CalpontSystemCatalog::UBIGINT:
		{
			const uint64_t *val64 = reinterpret_cast<const uint64_t *>(val8);
			return(*val64 == joblist::BIGINTEMPTYROW);
		}
        case CalpontSystemCatalog::FLOAT:
		case CalpontSystemCatalog::UFLOAT:
        {
            const uint32_t *val32 = reinterpret_cast<const uint32_t *>(val8);
            return(*val32 == joblist::FLOATEMPTYROW);
        }
        case CalpontSystemCatalog::DOUBLE:
		case CalpontSystemCatalog::UDOUBLE:
        {
            const uint64_t *val64 = reinterpret_cast<const uint64_t *>(val8);
            return(*val64 == joblist::DOUBLEEMPTYROW);
        }
        case CalpontSystemCatalog::CHAR:
        case CalpontSystemCatalog::VARCHAR:
        case CalpontSystemCatalog::DATE:
        case CalpontSystemCatalog::DATETIME:
            if (width == 1)
            {
                return(*val8 == joblist::CHAR1EMPTYROW);
            }
            else if (width == 2)
            {
                const uint16_t *val16 = reinterpret_cast<const uint16_t *>(val8);
                return(*val16 == joblist::CHAR2EMPTYROW);
            }
            else if (width <= 4)
            {
                const uint32_t *val32 = reinterpret_cast<const uint32_t *>(val8);
                return(*val32 == joblist::CHAR4EMPTYROW);
            }
            else if (width <= 8)
            {
                const uint64_t *val64 = reinterpret_cast<const uint64_t *>(val8);
                return(*val64 == joblist::CHAR8EMPTYROW);
            }
        default:
            break;
    }

    switch (width)
    {
        case 1:
        {
            return(*val8 == joblist::TINYINTEMPTYROW);
        }
        case 2:
        {
            const uint16_t *val16 = reinterpret_cast<const uint16_t *>(val8);
            return(*val16 == joblist::SMALLINTEMPTYROW);
        }
        case 4:
        {
            const uint32_t *val32 = reinterpret_cast<const uint32_t *>(val8);
            return(*val32 == joblist::INTEMPTYROW);
        }
        case 8:
        {
                const uint64_t *val64 = reinterpret_cast<const uint64_t *>(val8);
                return(*val64 == joblist::BIGINTEMPTYROW);
        }
        default:
            MessageLog logger(LoggingID(28));
            logging::Message::Args colWidth;
            Message msg(33);

            colWidth.add(width);
            msg.format(colWidth);
            logger.logErrorMessage(msg);
            return false;
    }

    return false;
}