VarCallbacksAny(const detail::VarCallbacksCFuncPtr<OT, VT> & cbs)
{
static_assert(DataSizeBytes >= sizeof(cbs), "Size mismatch!");
clear();
callbacks = cbs.clone(getDataPtr());
}
void
SimpleSignal::print(FILE * out) const {
fprintf(out, "---- Signal ----------------\n");
SignalLoggerManager::printSignalHeader(out, header, 0, 0, false);
SignalLoggerManager::printSignalData(out, header, getDataPtr());
for(Uint32 i = 0; i<header.m_noOfSections; i++) {
Uint32 len = ptr[i].sz;
fprintf(out, " --- Section %d size=%d ---\n", i, len);
Uint32 * signalData = ptr[i].p;
while(len >= 7) {
fprintf(out,
" H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x\n",
signalData[0], signalData[1], signalData[2], signalData[3],
signalData[4], signalData[5], signalData[6]);
len -= 7;
signalData += 7;
}
if(len > 0) {
fprintf(out, " H\'%.8x", signalData[0]);
for(Uint32 i = 1; i<len; i++)
fprintf(out, " H\'%.8x", signalData[i]);
fprintf(out, "\n");
}
}
}
LiteralTypeInstance* VarCharLiteralTypeInstance::makeCopy() const {
if (isNull()) {
return new NullLiteralTypeInstance(getType());
} else {
return new VarCharLiteralTypeInstance(static_cast<const VarCharType&>(getType()),
static_cast<const char*>(getDataPtr()),
asciiStringMaximumLength());
}
}
/****************************************************************************
Desc: Get a pointer to the UTF8 - no conversions are done.
****************************************************************************/
RCODE XFLAPI F_DataVector::getUTF8Ptr(
FLMUINT uiElementNumber,
const FLMBYTE ** ppszUTF8,
FLMUINT * puiBufLen)
{
RCODE rc = NE_XFLM_OK;
F_VECTOR_ELEMENT * pVector = getVector( uiElementNumber,
VECT_SLOT_HAS_DATA);
void * pvValue;
FLMUINT uiStorageLen;
FLMUINT uiSenLen;
if (!pVector)
{
*ppszUTF8 = NULL;
if (puiBufLen)
{
*puiBufLen = 0;
}
goto Exit;
}
if (pVector->uiDataType != XFLM_TEXT_TYPE)
{
rc = RC_SET( NE_XFLM_BAD_DATA_TYPE);
goto Exit;
}
if ((pvValue = getDataPtr( pVector)) != NULL)
{
*ppszUTF8 = (FLMBYTE *)pvValue;
uiStorageLen = pVector->uiDataLength;
if( RC_BAD( rc = flmGetCharCountFromStorageBuf( ppszUTF8,
uiStorageLen, NULL, &uiSenLen)))
{
goto Exit;
}
flmAssert( uiStorageLen > uiSenLen);
uiStorageLen -= uiSenLen;
}
else
{
*ppszUTF8 = NULL;
uiStorageLen = 0;
}
if (puiBufLen)
{
*puiBufLen = uiStorageLen;
}
Exit:
return( rc);
}
void CBaseStar::initialize() {
_minVal = 9.9999998e10;
_maxVal = -9.9999998e10;
_sub4.initialize();
for (uint idx = 0; idx < _data.size(); ++idx) {
const CBaseStarEntry *entry = getDataPtr(idx);
_sub4.checkEntry(entry->_val);
if (entry->_value < _minVal)
_minVal = entry->_value;
if (entry->_value > _maxVal)
_maxVal = entry->_value;
}
_range = (_maxVal - _minVal) / 1.0;
}
/****************************************************************************
Desc: Compose a key buffer from the vector's components.
****************************************************************************/
RCODE F_DataVector::outputKey(
IXD * pIxd,
FLMUINT uiMatchFlags,
FLMBYTE * pucKeyBuf,
FLMUINT uiKeyBufSize,
FLMUINT * puiKeyLen,
FLMUINT uiSearchKeyFlag)
{
RCODE rc = NE_XFLM_OK;
ICD * pIcd;
FLMBYTE * pucToKey;
FLMBYTE * pucKeyLenPos;
FLMUINT uiToKeyLen;
FLMUINT uiKeyLen;
FLMUINT uiKeyComponent;
FLMUINT uiDataComponent;
FLMUINT uiContextComponent;
FLMBOOL bDataTruncated;
FLMUINT uiDataType;
FLMUINT uiLanguage;
F_VECTOR_ELEMENT * pVector = NULL;
FLMBYTE ucIDBuf [256];
FLMUINT uiIDLen = 0;
FLMUINT64 ui64Id;
FLMUINT uiMaxKeySize;
FLMUINT uiDataLen;
const FLMBYTE * pucDataPtr;
FLMBYTE ucTmpSen [FLM_MAX_NUM_BUF_SIZE];
FLMBYTE * pucTmpSen;
FLMUINT uiSenLen;
FLMUINT uiIDMatchFlags = uiMatchFlags & (XFLM_MATCH_IDS | XFLM_MATCH_DOC_ID);
IF_BufferIStream * pBufferStream = NULL;
if (uiIDMatchFlags)
{
pucToKey = &ucIDBuf [0];
uiIDLen = 0;
// Put document ID into buffer. If there is room for at least nine
// bytes, we can encode the ID right into the buffer safely. Otherwise,
// we have to use a temporary buffer and see if there is room.
if (sizeof( ucIDBuf) - uiIDLen >= 9)
{
uiIDLen += f_encodeSEN( m_ui64DocumentID, &pucToKey);
}
else
{
pucTmpSen = &ucTmpSen [0];
uiSenLen = f_encodeSEN( m_ui64DocumentID, &pucTmpSen);
if (uiSenLen + uiIDLen > sizeof( ucIDBuf))
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto Exit;
}
f_memcpy( pucToKey, ucTmpSen, uiSenLen);
uiIDLen += uiSenLen;
pucToKey += uiSenLen;
}
if (uiIDMatchFlags & XFLM_MATCH_IDS)
{
// Append the Key component NODE IDs to the key
for (uiKeyComponent = 0;
uiKeyComponent < pIxd->uiNumKeyComponents;
uiKeyComponent++)
{
ui64Id = getID( uiKeyComponent);
// Put node ID into buffer. If there is room for at least nine
// bytes, we can encode the ID right into the buffer safely. Otherwise,
// we have to use a temporary buffer and see if there is room.
if (sizeof( ucIDBuf) - uiIDLen >= 9)
{
uiIDLen += f_encodeSEN( ui64Id, &pucToKey);
}
else
{
pucTmpSen = &ucTmpSen [0];
uiSenLen = f_encodeSEN( ui64Id, &pucTmpSen);
if (uiSenLen + uiIDLen > sizeof( ucIDBuf))
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto Exit;
}
f_memcpy( pucToKey, ucTmpSen, uiSenLen);
uiIDLen += uiSenLen;
pucToKey += uiSenLen;
}
}
// Append the Data NODE IDs to the key
for (uiDataComponent = 0;
uiDataComponent < pIxd->uiNumDataComponents;
uiDataComponent++)
{
ui64Id = getID( uiDataComponent +
pIxd->uiNumKeyComponents);
// Put node ID into buffer. If there is room for at least nine
// bytes, we can encode the ID right into the buffer safely. Otherwise,
// we have to use a temporary buffer and see if there is room.
if (sizeof( ucIDBuf) - uiIDLen >= 9)
{
uiIDLen += f_encodeSEN( ui64Id, &pucToKey);
}
else
{
pucTmpSen = &ucTmpSen [0];
uiSenLen = f_encodeSEN( ui64Id, &pucTmpSen);
if (uiSenLen + uiIDLen > sizeof( ucIDBuf))
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto Exit;
}
f_memcpy( pucToKey, ucTmpSen, uiSenLen);
uiIDLen += uiSenLen;
pucToKey += uiSenLen;
}
}
// Append the Context NODE IDs to the key
for (uiContextComponent = 0;
uiContextComponent < pIxd->uiNumContextComponents;
uiContextComponent++)
{
ui64Id = getID( uiContextComponent +
pIxd->uiNumKeyComponents +
pIxd->uiNumDataComponents);
// Put node ID into buffer. If there is room for at least nine
// bytes, we can encode the ID right into the buffer safely. Otherwise,
// we have to use a temporary buffer and see if there is room.
if (sizeof( ucIDBuf) - uiIDLen >= 9)
{
uiIDLen += f_encodeSEN( ui64Id, &pucToKey);
}
else
{
pucTmpSen = &ucTmpSen [0];
uiSenLen = f_encodeSEN( ui64Id, &pucTmpSen);
if (uiSenLen + uiIDLen > sizeof( ucIDBuf))
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto Exit;
}
f_memcpy( pucToKey, ucTmpSen, uiSenLen);
uiIDLen += uiSenLen;
pucToKey += uiSenLen;
}
}
}
if (uiIDLen >= uiKeyBufSize)
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto Exit;
}
}
// Output the key components
uiMaxKeySize = uiKeyBufSize - uiIDLen;
uiLanguage = pIxd->uiLanguage;
uiKeyLen = 0;
pucToKey = pucKeyBuf;
pIcd = pIxd->pFirstKey;
for (uiKeyComponent = 0;;pIcd = pIcd->pNextKeyComponent, uiKeyComponent++)
{
pucKeyLenPos = pucToKey;
pucToKey += 2;
uiKeyLen += 2;
uiDataType = icdGetDataType( pIcd);
// Find matching node in the tree - if not found skip and continue.
if ((pVector = getVector( uiKeyComponent, VECT_SLOT_HAS_DATA)) == NULL)
{
UW2FBA( 0, pucKeyLenPos);
}
else
{
uiToKeyLen = 0;
bDataTruncated = FALSE;
// Take the dictionary number and make it the key
if (pIcd->uiFlags & ICD_PRESENCE)
{
FLMUINT uiNum;
// Component better be a number - and better match the
// tag number of the ICD
if (RC_BAD( rc = getUINT( uiKeyComponent, &uiNum)))
{
goto Exit;
}
flmAssert( uiNum == pIcd->uiDictNum || pIcd->uiDictNum == ELM_ROOT_TAG);
// Output the tag number
if (uiKeyLen + 4 > uiMaxKeySize)
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto Exit;
}
f_UINT32ToBigEndian( (FLMUINT32)uiNum, pucToKey);
uiToKeyLen = 4;
}
else if (pIcd->uiFlags & ICD_METAPHONE)
{
FLMUINT uiMeta;
FLMBYTE ucStorageBuf[ FLM_MAX_NUM_BUF_SIZE];
FLMUINT uiStorageLen;
if (uiDataType != XFLM_TEXT_TYPE)
{
rc = RC_SET_AND_ASSERT( NE_XFLM_SYNTAX);
goto Exit;
}
if (pVector->uiDataType == XFLM_TEXT_TYPE)
{
if (RC_BAD( rc = getUTF8Ptr( uiKeyComponent,
&pucDataPtr, &uiDataLen)))
{
goto Exit;
}
if( !pBufferStream)
{
if( RC_BAD( rc = FlmAllocBufferIStream( &pBufferStream)))
{
goto Exit;
}
}
if (RC_BAD( rc = pBufferStream->openStream(
(const char *)pucDataPtr, uiDataLen)))
{
goto Exit;
}
if (RC_BAD( rc = f_getNextMetaphone( pBufferStream, &uiMeta)))
{
if( rc == NE_XFLM_EOF_HIT)
{
rc = RC_SET( NE_XFLM_SYNTAX);
}
goto Exit;
}
pBufferStream->closeStream();
}
else if (pVector->uiDataType == XFLM_NUMBER_TYPE)
{
if( RC_BAD( rc = getUINT( uiKeyComponent, &uiMeta)))
{
goto Exit;
}
}
else
{
rc = RC_SET_AND_ASSERT( NE_XFLM_SYNTAX);
goto Exit;
}
if ( uiMeta)
{
uiStorageLen = FLM_MAX_NUM_BUF_SIZE;
if( RC_BAD( rc = flmNumber64ToStorage( uiMeta,
&uiStorageLen, ucStorageBuf, FALSE, FALSE)))
{
goto Exit;
}
if( !pBufferStream)
{
if( RC_BAD( rc = FlmAllocBufferIStream( &pBufferStream)))
{
goto Exit;
}
}
if (RC_BAD( rc = pBufferStream->openStream(
(const char *)ucStorageBuf, uiStorageLen)))
{
goto Exit;
}
// Output the metaphone key piece
uiToKeyLen = uiMaxKeySize - uiKeyLen;
if( RC_BAD( rc = KYCollateValue( pucToKey, &uiToKeyLen,
pBufferStream, XFLM_NUMBER_TYPE,
pIcd->uiFlags, pIcd->uiCompareRules, pIcd->uiLimit,
NULL, NULL, uiLanguage,
FALSE, FALSE, &bDataTruncated, NULL)))
{
goto Exit;
}
pBufferStream->closeStream();
}
}
else
{
if (uiDataType == XFLM_TEXT_TYPE)
{
if (RC_BAD( rc = getUTF8Ptr( uiKeyComponent,
&pucDataPtr, &uiDataLen)))
{
goto Exit;
}
}
else
{
pucDataPtr = (FLMBYTE *)getDataPtr( pVector);
uiDataLen = pVector->uiDataLength;
}
if (uiDataLen)
{
if( !pBufferStream)
{
if( RC_BAD( rc = FlmAllocBufferIStream( &pBufferStream)))
{
goto Exit;
}
}
if (RC_BAD( rc = pBufferStream->openStream(
(const char *)pucDataPtr, uiDataLen)))
{
goto Exit;
}
uiToKeyLen = uiMaxKeySize - uiKeyLen;
if( RC_BAD( rc = KYCollateValue( pucToKey, &uiToKeyLen,
pBufferStream, uiDataType,
pIcd->uiFlags, pIcd->uiCompareRules, pIcd->uiLimit,
NULL, NULL, uiLanguage,
(FLMBOOL) ((pIcd->uiFlags & ICD_SUBSTRING)
? (isLeftTruncated( pVector)
? FALSE : TRUE)
: FALSE),
isRightTruncated( pVector),
&bDataTruncated, NULL)))
{
goto Exit;
}
pBufferStream->closeStream();
}
}
if (uiToKeyLen)
{
// Increment total key length
pucToKey += uiToKeyLen;
uiKeyLen += uiToKeyLen;
}
if (!bDataTruncated)
{
UW2FBA( (FLMUINT16)(uiToKeyLen | uiSearchKeyFlag),
pucKeyLenPos);
}
else
{
UW2FBA( (FLMUINT16)(uiToKeyLen | TRUNCATED_FLAG |
uiSearchKeyFlag), pucKeyLenPos);
}
}
// Check if done.
if (!pIcd->pNextKeyComponent)
{
break;
}
}
// Output the node IDs, if requested.
if (uiIDMatchFlags)
{
// There will always be room at this point for the
// IDs - because it was subtracted out above.
f_memcpy( pucToKey, ucIDBuf, uiIDLen);
}
*puiKeyLen = uiKeyLen + uiIDLen;
Exit:
if( pBufferStream)
{
pBufferStream->Release();
pBufferStream = NULL;
}
return( rc);
}
/****************************************************************************
Desc: Compose a data buffer from the vector's components.
****************************************************************************/
RCODE F_DataVector::outputData(
IXD * pIxd,
FLMBYTE * pucDataBuf,
FLMUINT uiDataBufSize,
FLMUINT * puiDataLen)
{
RCODE rc = NE_XFLM_OK;
ICD * pIcd = pIxd->pFirstData;
FLMUINT uiDataComponent = 0;
F_VECTOR_ELEMENT * pVector;
FLMBYTE * pucData;
FLMUINT uiDataLength;
FLMUINT uiTotalLength = 0;
FLMBYTE ucTmpSen [32];
FLMBYTE * pucTmpSen = &ucTmpSen [0];
FLMUINT uiSENLen;
FLMUINT uiLastDataLen = 0;
while (pIcd)
{
if ((pVector = getVector( uiDataComponent + pIxd->uiNumKeyComponents,
VECT_SLOT_HAS_DATA)) != NULL)
{
// Cannot do data conversions right now.
flmAssert( pVector->uiDataType == icdGetDataType( pIcd));
uiDataLength = pVector->uiDataLength;
pucData = (FLMBYTE *)getDataPtr( pVector);
}
else
{
uiDataLength = 0;
pucData = NULL;
}
// Output the length of the data as a SEN value
uiSENLen = f_encodeSEN( uiDataLength, &pucTmpSen);
if (uiTotalLength + uiSENLen > uiDataBufSize)
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto Exit;
}
f_memcpy( pucDataBuf, ucTmpSen, uiSENLen);
pucDataBuf += uiSENLen;
uiTotalLength += uiSENLen;
// Output the data
if (uiDataLength)
{
if (uiTotalLength + uiDataLength > uiDataBufSize)
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto Exit;
}
f_memcpy( pucDataBuf, pucData, uiDataLength);
pucDataBuf += uiDataLength;
uiTotalLength += uiDataLength;
uiLastDataLen = uiTotalLength;
}
pIcd = pIcd->pNextDataComponent;
uiDataComponent++;
}
Exit:
// Even if rc == NE_XFLM_CONV_DEST_OVERFLOW, return a length
*puiDataLen = uiLastDataLen;
return( rc);
}
Uint32 getFragmentId() const {
return (m_fragmentInfo == 0 ? 0 : getDataPtr()[theLength - 1]);
}
/**********************************************************************
Uint32 readData(Uint32 aDataNo);
Return Value: Return Data word in a signal.
Return -1: In all other case.
aDataNo: Data number in signal.
Remark: Return the dataWord information in a signal for a dataNo.
******************************************************************************/
inline
Uint32
NdbApiSignal::readData(Uint32 aDataNo) const {
return getDataPtr()[aDataNo-1];
}
const CBaseStarEntry *CStarField::getStar(int index) const {
return (index < 0 || index >= (int)_data.size()) ? nullptr : getDataPtr(index);
}
const CBaseStarEntry *CStarField::getRandomStar() const {
if (_data.empty())
return nullptr;
return getDataPtr(g_vm->getRandomNumber(_data.size() - 1));
}
